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