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