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