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