1mod keymap_file;
2
3use anyhow::Result;
4use gpui::{
5 font_cache::{FamilyId, FontCache},
6 AssetSource,
7};
8use schemars::{
9 gen::{SchemaGenerator, SchemaSettings},
10 schema::{InstanceType, ObjectValidation, Schema, SchemaObject, SingleOrVec},
11 JsonSchema,
12};
13use serde::{de::DeserializeOwned, Deserialize};
14use serde_json::Value;
15use std::{collections::HashMap, num::NonZeroU32, str, sync::Arc};
16use theme::{Theme, ThemeRegistry};
17use util::ResultExt as _;
18
19pub use keymap_file::{keymap_file_json_schema, KeymapFileContent};
20
21#[derive(Clone)]
22pub struct Settings {
23 pub experiments: FeatureFlags,
24 pub projects_online_by_default: bool,
25 pub buffer_font_family: FamilyId,
26 pub default_buffer_font_size: f32,
27 pub buffer_font_size: f32,
28 pub hover_popover_enabled: bool,
29 pub show_completions_on_input: bool,
30 pub vim_mode: bool,
31 pub autosave: Autosave,
32 pub editor_defaults: EditorSettings,
33 pub editor_overrides: EditorSettings,
34 pub terminal_defaults: TerminalSettings,
35 pub terminal_overrides: TerminalSettings,
36 pub language_defaults: HashMap<Arc<str>, EditorSettings>,
37 pub language_overrides: HashMap<Arc<str>, EditorSettings>,
38 pub lsp: HashMap<Arc<str>, LspSettings>,
39 pub theme: Arc<Theme>,
40}
41
42#[derive(Copy, Clone, Debug, Default, Deserialize, JsonSchema)]
43pub struct FeatureFlags {}
44
45impl FeatureFlags {
46 pub fn keymap_files(&self) -> Vec<&'static str> {
47 vec![]
48 }
49}
50
51#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
52pub struct EditorSettings {
53 pub tab_size: Option<NonZeroU32>,
54 pub hard_tabs: Option<bool>,
55 pub soft_wrap: Option<SoftWrap>,
56 pub preferred_line_length: Option<u32>,
57 pub format_on_save: Option<FormatOnSave>,
58 pub enable_language_server: Option<bool>,
59}
60
61#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
62#[serde(rename_all = "snake_case")]
63pub enum SoftWrap {
64 None,
65 EditorWidth,
66 PreferredLineLength,
67}
68
69#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
70#[serde(rename_all = "snake_case")]
71pub enum FormatOnSave {
72 Off,
73 LanguageServer,
74 External {
75 command: String,
76 arguments: Vec<String>,
77 },
78}
79
80#[derive(Copy, Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
81#[serde(rename_all = "snake_case")]
82pub enum Autosave {
83 Off,
84 AfterDelay { milliseconds: u64 },
85 OnFocusChange,
86 OnWindowChange,
87}
88
89#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
90pub struct TerminalSettings {
91 pub shell: Option<Shell>,
92 pub working_directory: Option<WorkingDirectory>,
93 pub font_size: Option<f32>,
94 pub font_family: Option<String>,
95 pub env: Option<HashMap<String, String>>,
96 pub blinking: Option<TerminalBlink>,
97 pub alternate_scroll: Option<AlternateScroll>,
98}
99
100#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
101#[serde(rename_all = "snake_case")]
102pub enum TerminalBlink {
103 Off,
104 TerminalControlled,
105 On,
106}
107
108impl Default for TerminalBlink {
109 fn default() -> Self {
110 TerminalBlink::TerminalControlled
111 }
112}
113
114#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
115#[serde(rename_all = "snake_case")]
116pub enum Shell {
117 System,
118 Program(String),
119 WithArguments { program: String, args: Vec<String> },
120}
121
122impl Default for Shell {
123 fn default() -> Self {
124 Shell::System
125 }
126}
127
128#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
129#[serde(rename_all = "snake_case")]
130pub enum AlternateScroll {
131 On,
132 Off,
133}
134
135impl Default for AlternateScroll {
136 fn default() -> Self {
137 AlternateScroll::On
138 }
139}
140
141#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
142#[serde(rename_all = "snake_case")]
143pub enum WorkingDirectory {
144 CurrentProjectDirectory,
145 FirstProjectDirectory,
146 AlwaysHome,
147 Always { directory: String },
148}
149
150#[derive(Clone, Debug, Default, Deserialize, JsonSchema)]
151pub struct SettingsFileContent {
152 pub experiments: Option<FeatureFlags>,
153 #[serde(default)]
154 pub projects_online_by_default: Option<bool>,
155 #[serde(default)]
156 pub buffer_font_family: Option<String>,
157 #[serde(default)]
158 pub buffer_font_size: Option<f32>,
159 #[serde(default)]
160 pub hover_popover_enabled: Option<bool>,
161 #[serde(default)]
162 pub show_completions_on_input: Option<bool>,
163 #[serde(default)]
164 pub vim_mode: Option<bool>,
165 #[serde(default)]
166 pub autosave: Option<Autosave>,
167 #[serde(flatten)]
168 pub editor: EditorSettings,
169 #[serde(default)]
170 pub terminal: TerminalSettings,
171 #[serde(default)]
172 #[serde(alias = "language_overrides")]
173 pub languages: HashMap<Arc<str>, EditorSettings>,
174 #[serde(default)]
175 pub lsp: HashMap<Arc<str>, LspSettings>,
176 #[serde(default)]
177 pub theme: Option<String>,
178}
179
180#[derive(Clone, Debug, Deserialize, PartialEq, Eq, JsonSchema)]
181#[serde(rename_all = "snake_case")]
182pub struct LspSettings {
183 pub initialization_options: Option<Value>,
184}
185
186impl Settings {
187 pub fn defaults(
188 assets: impl AssetSource,
189 font_cache: &FontCache,
190 themes: &ThemeRegistry,
191 ) -> Self {
192 fn required<T>(value: Option<T>) -> Option<T> {
193 assert!(value.is_some(), "missing default setting value");
194 value
195 }
196
197 let defaults: SettingsFileContent = parse_json_with_comments(
198 str::from_utf8(assets.load("settings/default.json").unwrap().as_ref()).unwrap(),
199 )
200 .unwrap();
201
202 Self {
203 experiments: FeatureFlags::default(),
204 buffer_font_family: font_cache
205 .load_family(&[defaults.buffer_font_family.as_ref().unwrap()])
206 .unwrap(),
207 buffer_font_size: defaults.buffer_font_size.unwrap(),
208 default_buffer_font_size: defaults.buffer_font_size.unwrap(),
209 hover_popover_enabled: defaults.hover_popover_enabled.unwrap(),
210 show_completions_on_input: defaults.show_completions_on_input.unwrap(),
211 projects_online_by_default: defaults.projects_online_by_default.unwrap(),
212 vim_mode: defaults.vim_mode.unwrap(),
213 autosave: defaults.autosave.unwrap(),
214 editor_defaults: EditorSettings {
215 tab_size: required(defaults.editor.tab_size),
216 hard_tabs: required(defaults.editor.hard_tabs),
217 soft_wrap: required(defaults.editor.soft_wrap),
218 preferred_line_length: required(defaults.editor.preferred_line_length),
219 format_on_save: required(defaults.editor.format_on_save),
220 enable_language_server: required(defaults.editor.enable_language_server),
221 },
222 editor_overrides: Default::default(),
223 terminal_defaults: Default::default(),
224 terminal_overrides: Default::default(),
225 language_defaults: defaults.languages,
226 language_overrides: Default::default(),
227 lsp: defaults.lsp.clone(),
228 theme: themes.get(&defaults.theme.unwrap()).unwrap(),
229 }
230 }
231
232 pub fn set_user_settings(
233 &mut self,
234 data: SettingsFileContent,
235 theme_registry: &ThemeRegistry,
236 font_cache: &FontCache,
237 ) {
238 if let Some(value) = &data.buffer_font_family {
239 if let Some(id) = font_cache.load_family(&[value]).log_err() {
240 self.buffer_font_family = id;
241 }
242 }
243 if let Some(value) = &data.theme {
244 if let Some(theme) = theme_registry.get(value).log_err() {
245 self.theme = theme;
246 }
247 }
248
249 merge(
250 &mut self.projects_online_by_default,
251 data.projects_online_by_default,
252 );
253 merge(&mut self.buffer_font_size, data.buffer_font_size);
254 merge(&mut self.default_buffer_font_size, data.buffer_font_size);
255 merge(&mut self.hover_popover_enabled, data.hover_popover_enabled);
256 merge(
257 &mut self.show_completions_on_input,
258 data.show_completions_on_input,
259 );
260 merge(&mut self.vim_mode, data.vim_mode);
261 merge(&mut self.autosave, data.autosave);
262 merge(&mut self.experiments, data.experiments);
263
264 // Ensure terminal font is loaded, so we can request it in terminal_element layout
265 if let Some(terminal_font) = &data.terminal.font_family {
266 font_cache.load_family(&[terminal_font]).log_err();
267 }
268
269 self.editor_overrides = data.editor;
270 self.terminal_defaults.font_size = data.terminal.font_size;
271 self.terminal_overrides = data.terminal;
272 self.language_overrides = data.languages;
273 self.lsp = data.lsp;
274 }
275
276 pub fn with_language_defaults(
277 mut self,
278 language_name: impl Into<Arc<str>>,
279 overrides: EditorSettings,
280 ) -> Self {
281 self.language_defaults
282 .insert(language_name.into(), overrides);
283 self
284 }
285
286 pub fn tab_size(&self, language: Option<&str>) -> NonZeroU32 {
287 self.language_setting(language, |settings| settings.tab_size)
288 }
289
290 pub fn hard_tabs(&self, language: Option<&str>) -> bool {
291 self.language_setting(language, |settings| settings.hard_tabs)
292 }
293
294 pub fn soft_wrap(&self, language: Option<&str>) -> SoftWrap {
295 self.language_setting(language, |settings| settings.soft_wrap)
296 }
297
298 pub fn preferred_line_length(&self, language: Option<&str>) -> u32 {
299 self.language_setting(language, |settings| settings.preferred_line_length)
300 }
301
302 pub fn format_on_save(&self, language: Option<&str>) -> FormatOnSave {
303 self.language_setting(language, |settings| settings.format_on_save.clone())
304 }
305
306 pub fn enable_language_server(&self, language: Option<&str>) -> bool {
307 self.language_setting(language, |settings| settings.enable_language_server)
308 }
309
310 fn language_setting<F, R>(&self, language: Option<&str>, f: F) -> R
311 where
312 F: Fn(&EditorSettings) -> Option<R>,
313 {
314 None.or_else(|| language.and_then(|l| self.language_overrides.get(l).and_then(&f)))
315 .or_else(|| f(&self.editor_overrides))
316 .or_else(|| language.and_then(|l| self.language_defaults.get(l).and_then(&f)))
317 .or_else(|| f(&self.editor_defaults))
318 .expect("missing default")
319 }
320
321 #[cfg(any(test, feature = "test-support"))]
322 pub fn test(cx: &gpui::AppContext) -> Settings {
323 Settings {
324 experiments: FeatureFlags::default(),
325 buffer_font_family: cx.font_cache().load_family(&["Monaco"]).unwrap(),
326 buffer_font_size: 14.,
327 default_buffer_font_size: 14.,
328 hover_popover_enabled: true,
329 show_completions_on_input: true,
330 vim_mode: false,
331 autosave: Autosave::Off,
332 editor_defaults: EditorSettings {
333 tab_size: Some(4.try_into().unwrap()),
334 hard_tabs: Some(false),
335 soft_wrap: Some(SoftWrap::None),
336 preferred_line_length: Some(80),
337 format_on_save: Some(FormatOnSave::LanguageServer),
338 enable_language_server: Some(true),
339 },
340 editor_overrides: Default::default(),
341 terminal_defaults: Default::default(),
342 terminal_overrides: Default::default(),
343 language_defaults: Default::default(),
344 language_overrides: Default::default(),
345 lsp: Default::default(),
346 projects_online_by_default: true,
347 theme: gpui::fonts::with_font_cache(cx.font_cache().clone(), Default::default),
348 }
349 }
350
351 #[cfg(any(test, feature = "test-support"))]
352 pub fn test_async(cx: &mut gpui::TestAppContext) {
353 cx.update(|cx| {
354 let settings = Self::test(cx);
355 cx.set_global(settings);
356 });
357 }
358}
359
360pub fn settings_file_json_schema(
361 theme_names: Vec<String>,
362 language_names: &[String],
363) -> serde_json::Value {
364 let settings = SchemaSettings::draft07().with(|settings| {
365 settings.option_add_null_type = false;
366 });
367 let generator = SchemaGenerator::new(settings);
368 let mut root_schema = generator.into_root_schema_for::<SettingsFileContent>();
369
370 // Create a schema for a theme name.
371 let theme_name_schema = SchemaObject {
372 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::String))),
373 enum_values: Some(theme_names.into_iter().map(Value::String).collect()),
374 ..Default::default()
375 };
376
377 // Create a schema for a 'languages overrides' object, associating editor
378 // settings with specific langauges.
379 assert!(root_schema.definitions.contains_key("EditorSettings"));
380 let languages_object_schema = SchemaObject {
381 instance_type: Some(SingleOrVec::Single(Box::new(InstanceType::Object))),
382 object: Some(Box::new(ObjectValidation {
383 properties: language_names
384 .iter()
385 .map(|name| {
386 (
387 name.clone(),
388 Schema::new_ref("#/definitions/EditorSettings".into()),
389 )
390 })
391 .collect(),
392 ..Default::default()
393 })),
394 ..Default::default()
395 };
396
397 // Add these new schemas as definitions, and modify properties of the root
398 // schema to reference them.
399 root_schema.definitions.extend([
400 ("ThemeName".into(), theme_name_schema.into()),
401 ("Languages".into(), languages_object_schema.into()),
402 ]);
403 root_schema
404 .schema
405 .object
406 .as_mut()
407 .unwrap()
408 .properties
409 .extend([
410 (
411 "theme".to_owned(),
412 Schema::new_ref("#/definitions/ThemeName".into()),
413 ),
414 (
415 "languages".to_owned(),
416 Schema::new_ref("#/definitions/Languages".into()),
417 ),
418 // For backward compatibility
419 (
420 "language_overrides".to_owned(),
421 Schema::new_ref("#/definitions/Languages".into()),
422 ),
423 ]);
424
425 serde_json::to_value(root_schema).unwrap()
426}
427
428fn merge<T: Copy>(target: &mut T, value: Option<T>) {
429 if let Some(value) = value {
430 *target = value;
431 }
432}
433
434pub fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
435 Ok(serde_json::from_reader(
436 json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
437 )?)
438}