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