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