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