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