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