1use crate::{File, Language};
2use anyhow::Result;
3use collections::HashMap;
4use globset::GlobMatcher;
5use gpui::AppContext;
6use schemars::{
7 schema::{InstanceType, ObjectValidation, Schema, SchemaObject},
8 JsonSchema,
9};
10use serde::{Deserialize, Serialize};
11use std::{num::NonZeroU32, path::Path, sync::Arc};
12
13pub fn init(cx: &mut AppContext) {
14 settings::register::<AllLanguageSettings>(cx);
15}
16
17pub fn language_settings<'a>(
18 language: Option<&Arc<Language>>,
19 file: Option<&Arc<dyn File>>,
20 cx: &'a AppContext,
21) -> &'a LanguageSettings {
22 let language_name = language.map(|l| l.name());
23 all_language_settings(file, cx).language(language_name.as_deref())
24}
25
26pub fn all_language_settings<'a>(
27 file: Option<&Arc<dyn File>>,
28 cx: &'a AppContext,
29) -> &'a AllLanguageSettings {
30 let location = file.map(|f| (f.worktree_id(), f.path().as_ref()));
31 settings::get_local(location, cx)
32}
33
34#[derive(Debug, Clone)]
35pub struct AllLanguageSettings {
36 pub copilot: CopilotSettings,
37 defaults: LanguageSettings,
38 languages: HashMap<Arc<str>, LanguageSettings>,
39}
40
41#[derive(Debug, Clone, Deserialize)]
42pub struct LanguageSettings {
43 pub tab_size: NonZeroU32,
44 pub hard_tabs: bool,
45 pub soft_wrap: SoftWrap,
46 pub preferred_line_length: u32,
47 pub format_on_save: FormatOnSave,
48 pub remove_trailing_whitespace_on_save: bool,
49 pub ensure_final_newline_on_save: bool,
50 pub formatter: Formatter,
51 pub enable_language_server: bool,
52 pub show_copilot_suggestions: bool,
53 pub show_whitespaces: ShowWhitespaceSetting,
54 pub extend_comment_on_newline: bool,
55}
56
57#[derive(Clone, Debug, Default)]
58pub struct CopilotSettings {
59 pub feature_enabled: bool,
60 pub disabled_globs: Vec<GlobMatcher>,
61}
62
63#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
64pub struct AllLanguageSettingsContent {
65 #[serde(default)]
66 pub features: Option<FeaturesContent>,
67 #[serde(default)]
68 pub copilot: Option<CopilotSettingsContent>,
69 #[serde(flatten)]
70 pub defaults: LanguageSettingsContent,
71 #[serde(default, alias = "language_overrides")]
72 pub languages: HashMap<Arc<str>, LanguageSettingsContent>,
73}
74
75#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
76pub struct LanguageSettingsContent {
77 #[serde(default)]
78 pub tab_size: Option<NonZeroU32>,
79 #[serde(default)]
80 pub hard_tabs: Option<bool>,
81 #[serde(default)]
82 pub soft_wrap: Option<SoftWrap>,
83 #[serde(default)]
84 pub preferred_line_length: Option<u32>,
85 #[serde(default)]
86 pub format_on_save: Option<FormatOnSave>,
87 #[serde(default)]
88 pub remove_trailing_whitespace_on_save: Option<bool>,
89 #[serde(default)]
90 pub ensure_final_newline_on_save: Option<bool>,
91 #[serde(default)]
92 pub formatter: Option<Formatter>,
93 #[serde(default)]
94 pub enable_language_server: Option<bool>,
95 #[serde(default)]
96 pub show_copilot_suggestions: Option<bool>,
97 #[serde(default)]
98 pub show_whitespaces: Option<ShowWhitespaceSetting>,
99 #[serde(default)]
100 pub extend_comment_on_newline: Option<bool>,
101}
102
103#[derive(Clone, Debug, Default, Serialize, Deserialize, JsonSchema)]
104pub struct CopilotSettingsContent {
105 #[serde(default)]
106 pub disabled_globs: Option<Vec<String>>,
107}
108
109#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
110#[serde(rename_all = "snake_case")]
111pub struct FeaturesContent {
112 pub copilot: Option<bool>,
113}
114
115#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
116#[serde(rename_all = "snake_case")]
117pub enum SoftWrap {
118 None,
119 EditorWidth,
120 PreferredLineLength,
121}
122
123#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
124#[serde(rename_all = "snake_case")]
125pub enum FormatOnSave {
126 On,
127 Off,
128 LanguageServer,
129 External {
130 command: Arc<str>,
131 arguments: Arc<[String]>,
132 },
133}
134
135#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
136#[serde(rename_all = "snake_case")]
137pub enum ShowWhitespaceSetting {
138 Selection,
139 None,
140 All,
141}
142
143#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, JsonSchema)]
144#[serde(rename_all = "snake_case")]
145pub enum Formatter {
146 LanguageServer,
147 External {
148 command: Arc<str>,
149 arguments: Arc<[String]>,
150 },
151}
152
153impl AllLanguageSettings {
154 pub fn language<'a>(&'a self, language_name: Option<&str>) -> &'a LanguageSettings {
155 if let Some(name) = language_name {
156 if let Some(overrides) = self.languages.get(name) {
157 return overrides;
158 }
159 }
160 &self.defaults
161 }
162
163 pub fn copilot_enabled_for_path(&self, path: &Path) -> bool {
164 !self
165 .copilot
166 .disabled_globs
167 .iter()
168 .any(|glob| glob.is_match(path))
169 }
170
171 pub fn copilot_enabled(&self, language: Option<&Arc<Language>>, path: Option<&Path>) -> bool {
172 if !self.copilot.feature_enabled {
173 return false;
174 }
175
176 if let Some(path) = path {
177 if !self.copilot_enabled_for_path(path) {
178 return false;
179 }
180 }
181
182 self.language(language.map(|l| l.name()).as_deref())
183 .show_copilot_suggestions
184 }
185}
186
187impl settings::Setting for AllLanguageSettings {
188 const KEY: Option<&'static str> = None;
189
190 type FileContent = AllLanguageSettingsContent;
191
192 fn load(
193 default_value: &Self::FileContent,
194 user_settings: &[&Self::FileContent],
195 _: &AppContext,
196 ) -> Result<Self> {
197 // A default is provided for all settings.
198 let mut defaults: LanguageSettings =
199 serde_json::from_value(serde_json::to_value(&default_value.defaults)?)?;
200
201 let mut languages = HashMap::default();
202 for (language_name, settings) in &default_value.languages {
203 let mut language_settings = defaults.clone();
204 merge_settings(&mut language_settings, &settings);
205 languages.insert(language_name.clone(), language_settings);
206 }
207
208 let mut copilot_enabled = default_value
209 .features
210 .as_ref()
211 .and_then(|f| f.copilot)
212 .ok_or_else(Self::missing_default)?;
213 let mut copilot_globs = default_value
214 .copilot
215 .as_ref()
216 .and_then(|c| c.disabled_globs.as_ref())
217 .ok_or_else(Self::missing_default)?;
218
219 for user_settings in user_settings {
220 if let Some(copilot) = user_settings.features.as_ref().and_then(|f| f.copilot) {
221 copilot_enabled = copilot;
222 }
223 if let Some(globs) = user_settings
224 .copilot
225 .as_ref()
226 .and_then(|f| f.disabled_globs.as_ref())
227 {
228 copilot_globs = globs;
229 }
230
231 // A user's global settings override the default global settings and
232 // all default language-specific settings.
233 merge_settings(&mut defaults, &user_settings.defaults);
234 for language_settings in languages.values_mut() {
235 merge_settings(language_settings, &user_settings.defaults);
236 }
237
238 // A user's language-specific settings override default language-specific settings.
239 for (language_name, user_language_settings) in &user_settings.languages {
240 merge_settings(
241 languages
242 .entry(language_name.clone())
243 .or_insert_with(|| defaults.clone()),
244 &user_language_settings,
245 );
246 }
247 }
248
249 Ok(Self {
250 copilot: CopilotSettings {
251 feature_enabled: copilot_enabled,
252 disabled_globs: copilot_globs
253 .iter()
254 .filter_map(|g| Some(globset::Glob::new(g).ok()?.compile_matcher()))
255 .collect(),
256 },
257 defaults,
258 languages,
259 })
260 }
261
262 fn json_schema(
263 generator: &mut schemars::gen::SchemaGenerator,
264 params: &settings::SettingsJsonSchemaParams,
265 _: &AppContext,
266 ) -> schemars::schema::RootSchema {
267 let mut root_schema = generator.root_schema_for::<Self::FileContent>();
268
269 // Create a schema for a 'languages overrides' object, associating editor
270 // settings with specific languages.
271 assert!(root_schema
272 .definitions
273 .contains_key("LanguageSettingsContent"));
274
275 let languages_object_schema = SchemaObject {
276 instance_type: Some(InstanceType::Object.into()),
277 object: Some(Box::new(ObjectValidation {
278 properties: params
279 .language_names
280 .iter()
281 .map(|name| {
282 (
283 name.clone(),
284 Schema::new_ref("#/definitions/LanguageSettingsContent".into()),
285 )
286 })
287 .collect(),
288 ..Default::default()
289 })),
290 ..Default::default()
291 };
292
293 root_schema
294 .definitions
295 .extend([("Languages".into(), languages_object_schema.into())]);
296
297 root_schema
298 .schema
299 .object
300 .as_mut()
301 .unwrap()
302 .properties
303 .extend([
304 (
305 "languages".to_owned(),
306 Schema::new_ref("#/definitions/Languages".into()),
307 ),
308 // For backward compatibility
309 (
310 "language_overrides".to_owned(),
311 Schema::new_ref("#/definitions/Languages".into()),
312 ),
313 ]);
314
315 root_schema
316 }
317}
318
319fn merge_settings(settings: &mut LanguageSettings, src: &LanguageSettingsContent) {
320 merge(&mut settings.tab_size, src.tab_size);
321 merge(&mut settings.hard_tabs, src.hard_tabs);
322 merge(&mut settings.soft_wrap, src.soft_wrap);
323 merge(
324 &mut settings.preferred_line_length,
325 src.preferred_line_length,
326 );
327 merge(&mut settings.formatter, src.formatter.clone());
328 merge(&mut settings.format_on_save, src.format_on_save.clone());
329 merge(
330 &mut settings.remove_trailing_whitespace_on_save,
331 src.remove_trailing_whitespace_on_save,
332 );
333 merge(
334 &mut settings.ensure_final_newline_on_save,
335 src.ensure_final_newline_on_save,
336 );
337 merge(
338 &mut settings.enable_language_server,
339 src.enable_language_server,
340 );
341 merge(
342 &mut settings.show_copilot_suggestions,
343 src.show_copilot_suggestions,
344 );
345 merge(&mut settings.show_whitespaces, src.show_whitespaces);
346 merge(
347 &mut settings.extend_comment_on_newline,
348 src.extend_comment_on_newline,
349 );
350 fn merge<T>(target: &mut T, value: Option<T>) {
351 if let Some(value) = value {
352 *target = value;
353 }
354 }
355}