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