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