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