@@ -1,5 +1,6 @@
use anyhow::{anyhow, Result};
use collections::{hash_map, BTreeMap, HashMap, HashSet};
+use lazy_static::lazy_static;
use schemars::JsonSchema;
use serde::{de::DeserializeOwned, Deserialize as _, Serialize};
use smallvec::SmallVec;
@@ -7,10 +8,12 @@ use std::{
any::{type_name, Any, TypeId},
fmt::Debug,
mem,
+ ops::Range,
path::Path,
+ str,
sync::Arc,
};
-use util::{merge_non_null_json_value_into, ResultExt as _};
+use util::{merge_non_null_json_value_into, RangeExt, ResultExt as _};
/// A value that can be defined as a user setting.
///
@@ -22,7 +25,7 @@ pub trait Setting: 'static + Debug {
const KEY: Option<&'static str> = None;
/// The type that is stored in an individual JSON file.
- type FileContent: Serialize + DeserializeOwned + JsonSchema;
+ type FileContent: Clone + Serialize + DeserializeOwned + JsonSchema;
/// The logic for combining together values from one or more JSON files into the
/// final value for this setting.
@@ -37,7 +40,6 @@ pub trait Setting: 'static + Debug {
) -> Self
where
Self: DeserializeOwned,
- Self::FileContent: Serialize,
{
let mut merged = serde_json::Value::Null;
for value in [default_value].iter().chain(user_values) {
@@ -55,6 +57,7 @@ pub struct SettingsStore {
user_deserialized_settings: Option<DeserializedSettingMap>,
local_deserialized_settings: BTreeMap<Arc<Path>, DeserializedSettingMap>,
changed_setting_types: HashSet<TypeId>,
+ tab_size_callback: Option<(TypeId, Box<dyn Fn(&dyn Any) -> Option<usize>>)>,
}
#[derive(Debug)]
@@ -129,6 +132,81 @@ impl SettingsStore {
.unwrap()
}
+ /// Update the value of a setting.
+ ///
+ /// Returns a list of edits to apply to the JSON file.
+ pub fn update<T: Setting>(
+ &self,
+ text: &str,
+ update: impl Fn(&mut T::FileContent),
+ ) -> Vec<(Range<usize>, String)> {
+ let setting_type_id = TypeId::of::<T>();
+ let old_content = self
+ .user_deserialized_settings
+ .as_ref()
+ .unwrap()
+ .typed
+ .get(&setting_type_id)
+ .unwrap()
+ .0
+ .downcast_ref::<T::FileContent>()
+ .unwrap()
+ .clone();
+ let mut new_content = old_content.clone();
+ update(&mut new_content);
+
+ let mut parser = tree_sitter::Parser::new();
+ parser.set_language(tree_sitter_json::language()).unwrap();
+ let tree = parser.parse(text, None).unwrap();
+
+ let old_value = &serde_json::to_value(old_content).unwrap();
+ let new_value = &serde_json::to_value(new_content).unwrap();
+
+ let mut key_path = Vec::new();
+ if let Some(key) = T::KEY {
+ key_path.push(key);
+ }
+
+ let mut edits = Vec::new();
+ let tab_size = self.json_tab_size();
+ update_value_in_json_text(
+ &text,
+ &tree,
+ &mut key_path,
+ tab_size,
+ &old_value,
+ &new_value,
+ &mut edits,
+ );
+ edits.sort_unstable_by_key(|e| e.0.start);
+ return edits;
+ }
+
+ /// Configure the tab sized when updating JSON files.
+ pub fn set_json_tab_size_callback<T: Setting>(
+ &mut self,
+ get_tab_size: fn(&T) -> Option<usize>,
+ ) {
+ self.tab_size_callback = Some((
+ TypeId::of::<T>(),
+ Box::new(move |value| get_tab_size(value.downcast_ref::<T>().unwrap())),
+ ));
+ }
+
+ fn json_tab_size(&self) -> usize {
+ const DEFAULT_JSON_TAB_SIZE: usize = 2;
+
+ if let Some((setting_type_id, callback)) = &self.tab_size_callback {
+ let setting_value = self.setting_values.get(setting_type_id).unwrap();
+ let value = setting_value.value_for_path(None);
+ if let Some(value) = callback(value) {
+ return value;
+ }
+ }
+
+ DEFAULT_JSON_TAB_SIZE
+ }
+
/// Set the default settings via a JSON string.
///
/// The string should contain a JSON object with a default value for every setting.
@@ -277,8 +355,8 @@ impl SettingsStore {
/// Returns an error if the string doesn't contain a valid JSON object.
fn load_setting_map(&self, json: &str) -> Result<DeserializedSettingMap> {
let mut map = DeserializedSettingMap {
+ untyped: parse_json_with_comments(json)?,
typed: HashMap::default(),
- untyped: serde_json::from_str(json)?,
};
for (setting_type_id, setting_value) in self.setting_values.iter() {
Self::load_setting_in_map(*setting_type_id, setting_value, &mut map);
@@ -374,10 +452,231 @@ impl Debug for SettingsStore {
}
}
+fn update_value_in_json_text<'a>(
+ text: &str,
+ syntax_tree: &tree_sitter::Tree,
+ key_path: &mut Vec<&'a str>,
+ tab_size: usize,
+ old_value: &'a serde_json::Value,
+ new_value: &'a serde_json::Value,
+ edits: &mut Vec<(Range<usize>, String)>,
+) {
+ // If the old and new values are both objects, then compare them key by key,
+ // preserving the comments and formatting of the unchanged parts. Otherwise,
+ // replace the old value with the new value.
+ if let (serde_json::Value::Object(old_object), serde_json::Value::Object(new_object)) =
+ (old_value, new_value)
+ {
+ for (key, old_sub_value) in old_object.iter() {
+ key_path.push(key);
+ let new_sub_value = new_object.get(key).unwrap_or(&serde_json::Value::Null);
+ update_value_in_json_text(
+ text,
+ syntax_tree,
+ key_path,
+ tab_size,
+ old_sub_value,
+ new_sub_value,
+ edits,
+ );
+ key_path.pop();
+ }
+ for (key, new_sub_value) in new_object.iter() {
+ key_path.push(key);
+ if !old_object.contains_key(key) {
+ update_value_in_json_text(
+ text,
+ syntax_tree,
+ key_path,
+ tab_size,
+ &serde_json::Value::Null,
+ new_sub_value,
+ edits,
+ );
+ }
+ key_path.pop();
+ }
+ } else if old_value != new_value {
+ let (range, replacement) =
+ replace_value_in_json_text(text, syntax_tree, &key_path, tab_size, &new_value);
+ edits.push((range, replacement));
+ }
+}
+
+lazy_static! {
+ static ref PAIR_QUERY: tree_sitter::Query = tree_sitter::Query::new(
+ tree_sitter_json::language(),
+ "(pair key: (string) @key value: (_) @value)",
+ )
+ .unwrap();
+}
+
+fn replace_value_in_json_text(
+ text: &str,
+ syntax_tree: &tree_sitter::Tree,
+ key_path: &[&str],
+ tab_size: usize,
+ new_value: impl Serialize,
+) -> (Range<usize>, String) {
+ const LANGUAGE_OVERRIDES: &'static str = "language_overrides";
+ const LANGUAGES: &'static str = "languages";
+
+ let mut cursor = tree_sitter::QueryCursor::new();
+
+ let has_language_overrides = text.contains(LANGUAGE_OVERRIDES);
+
+ let mut depth = 0;
+ let mut last_value_range = 0..0;
+ let mut first_key_start = None;
+ let mut existing_value_range = 0..text.len();
+ let matches = cursor.matches(&PAIR_QUERY, syntax_tree.root_node(), text.as_bytes());
+ for mat in matches {
+ if mat.captures.len() != 2 {
+ continue;
+ }
+
+ let key_range = mat.captures[0].node.byte_range();
+ let value_range = mat.captures[1].node.byte_range();
+
+ // Don't enter sub objects until we find an exact
+ // match for the current keypath
+ if last_value_range.contains_inclusive(&value_range) {
+ continue;
+ }
+
+ last_value_range = value_range.clone();
+
+ if key_range.start > existing_value_range.end {
+ break;
+ }
+
+ first_key_start.get_or_insert_with(|| key_range.start);
+
+ let found_key = text
+ .get(key_range.clone())
+ .map(|key_text| {
+ if key_path[depth] == LANGUAGES && has_language_overrides {
+ return key_text == format!("\"{}\"", LANGUAGE_OVERRIDES);
+ } else {
+ return key_text == format!("\"{}\"", key_path[depth]);
+ }
+ })
+ .unwrap_or(false);
+
+ if found_key {
+ existing_value_range = value_range;
+ // Reset last value range when increasing in depth
+ last_value_range = existing_value_range.start..existing_value_range.start;
+ depth += 1;
+
+ if depth == key_path.len() {
+ break;
+ } else {
+ first_key_start = None;
+ }
+ }
+ }
+
+ // We found the exact key we want, insert the new value
+ if depth == key_path.len() {
+ let new_val = to_pretty_json(&new_value, tab_size, tab_size * depth);
+ (existing_value_range, new_val)
+ } else {
+ // We have key paths, construct the sub objects
+ let new_key = if has_language_overrides && key_path[depth] == LANGUAGES {
+ LANGUAGE_OVERRIDES
+ } else {
+ key_path[depth]
+ };
+
+ // We don't have the key, construct the nested objects
+ let mut new_value = serde_json::to_value(new_value).unwrap();
+ for key in key_path[(depth + 1)..].iter().rev() {
+ if has_language_overrides && key == &LANGUAGES {
+ new_value = serde_json::json!({ LANGUAGE_OVERRIDES.to_string(): new_value });
+ } else {
+ new_value = serde_json::json!({ key.to_string(): new_value });
+ }
+ }
+
+ if let Some(first_key_start) = first_key_start {
+ let mut row = 0;
+ let mut column = 0;
+ for (ix, char) in text.char_indices() {
+ if ix == first_key_start {
+ break;
+ }
+ if char == '\n' {
+ row += 1;
+ column = 0;
+ } else {
+ column += char.len_utf8();
+ }
+ }
+
+ if row > 0 {
+ // depth is 0 based, but division needs to be 1 based.
+ let new_val = to_pretty_json(&new_value, column / (depth + 1), column);
+ let space = ' ';
+ let content = format!("\"{new_key}\": {new_val},\n{space:width$}", width = column);
+ (first_key_start..first_key_start, content)
+ } else {
+ let new_val = serde_json::to_string(&new_value).unwrap();
+ let mut content = format!(r#""{new_key}": {new_val},"#);
+ content.push(' ');
+ (first_key_start..first_key_start, content)
+ }
+ } else {
+ new_value = serde_json::json!({ new_key.to_string(): new_value });
+ let indent_prefix_len = 4 * depth;
+ let mut new_val = to_pretty_json(&new_value, 4, indent_prefix_len);
+ if depth == 0 {
+ new_val.push('\n');
+ }
+
+ (existing_value_range, new_val)
+ }
+ }
+}
+
+fn to_pretty_json(value: &impl Serialize, indent_size: usize, indent_prefix_len: usize) -> String {
+ const SPACES: [u8; 32] = [b' '; 32];
+
+ debug_assert!(indent_size <= SPACES.len());
+ debug_assert!(indent_prefix_len <= SPACES.len());
+
+ let mut output = Vec::new();
+ let mut ser = serde_json::Serializer::with_formatter(
+ &mut output,
+ serde_json::ser::PrettyFormatter::with_indent(&SPACES[0..indent_size.min(SPACES.len())]),
+ );
+
+ value.serialize(&mut ser).unwrap();
+ let text = String::from_utf8(output).unwrap();
+
+ let mut adjusted_text = String::new();
+ for (i, line) in text.split('\n').enumerate() {
+ if i > 0 {
+ adjusted_text.push_str(str::from_utf8(&SPACES[0..indent_prefix_len]).unwrap());
+ }
+ adjusted_text.push_str(line);
+ adjusted_text.push('\n');
+ }
+ adjusted_text.pop();
+ adjusted_text
+}
+
+fn parse_json_with_comments<T: DeserializeOwned>(content: &str) -> Result<T> {
+ Ok(serde_json::from_reader(
+ json_comments::CommentSettings::c_style().strip_comments(content.as_bytes()),
+ )?)
+}
+
#[cfg(test)]
mod tests {
use super::*;
use serde_derive::Deserialize;
+ use unindent::Unindent;
#[test]
fn test_settings_store_basic() {
@@ -518,7 +817,7 @@ mod tests {
}
#[test]
- fn test_setting_store_load_before_register() {
+ fn test_setting_store_assign_json_before_register() {
let mut store = SettingsStore::default();
store
.set_default_settings(
@@ -529,7 +828,7 @@ mod tests {
"age": 30,
"staff": false
},
- "key1": "x
+ "key1": "x"
}"#,
)
.unwrap();
@@ -557,6 +856,86 @@ mod tests {
);
}
+ #[test]
+ fn test_setting_store_update() {
+ let mut store = SettingsStore::default();
+ store.register_setting::<UserSettings>();
+ store.register_setting::<LanguageSettings>();
+
+ // entries added and updated
+ check_settings_update::<LanguageSettings>(
+ &mut store,
+ r#"{
+ "languages": {
+ "JSON": {
+ "is_enabled": true
+ }
+ }
+ }"#
+ .unindent(),
+ |settings| {
+ settings.languages.get_mut("JSON").unwrap().is_enabled = false;
+ settings
+ .languages
+ .insert("Rust".into(), LanguageSettingEntry { is_enabled: true });
+ },
+ r#"{
+ "languages": {
+ "Rust": {
+ "is_enabled": true
+ },
+ "JSON": {
+ "is_enabled": false
+ }
+ }
+ }"#
+ .unindent(),
+ );
+
+ // weird formatting
+ check_settings_update::<UserSettings>(
+ &mut store,
+ r#"{
+ "user": { "age": 36, "name": "Max", "staff": true }
+ }"#
+ .unindent(),
+ |settings| settings.age = Some(37),
+ r#"{
+ "user": { "age": 37, "name": "Max", "staff": true }
+ }"#
+ .unindent(),
+ );
+
+ // no content
+ check_settings_update::<UserSettings>(
+ &mut store,
+ r#""#.unindent(),
+ |settings| settings.age = Some(37),
+ r#"{
+ "user": {
+ "age": 37
+ }
+ }
+ "#
+ .unindent(),
+ );
+ }
+
+ fn check_settings_update<T: Setting>(
+ store: &mut SettingsStore,
+ old_json: String,
+ update: fn(&mut T::FileContent),
+ expected_new_json: String,
+ ) {
+ store.set_user_settings(&old_json).ok();
+ let edits = store.update::<T>(&old_json, update);
+ let mut new_json = old_json;
+ for (range, replacement) in edits.into_iter().rev() {
+ new_json.replace_range(range, &replacement);
+ }
+ pretty_assertions::assert_eq!(new_json, expected_new_json);
+ }
+
#[derive(Debug, PartialEq, Deserialize)]
struct UserSettings {
name: String,
@@ -564,7 +943,7 @@ mod tests {
staff: bool,
}
- #[derive(Serialize, Deserialize, JsonSchema)]
+ #[derive(Clone, Serialize, Deserialize, JsonSchema)]
struct UserSettingsJson {
name: Option<String>,
age: Option<u32>,
@@ -600,7 +979,7 @@ mod tests {
key2: String,
}
- #[derive(Serialize, Deserialize, JsonSchema)]
+ #[derive(Clone, Serialize, Deserialize, JsonSchema)]
struct MultiKeySettingsJson {
key1: Option<String>,
key2: Option<String>,
@@ -645,4 +1024,25 @@ mod tests {
Self::load_via_json_merge(default_value, user_values)
}
}
+
+ #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+ struct LanguageSettings {
+ #[serde(default)]
+ languages: HashMap<String, LanguageSettingEntry>,
+ }
+
+ #[derive(Clone, Debug, Serialize, Deserialize, JsonSchema)]
+ struct LanguageSettingEntry {
+ is_enabled: bool,
+ }
+
+ impl Setting for LanguageSettings {
+ const KEY: Option<&'static str> = None;
+
+ type FileContent = Self;
+
+ fn load(default_value: &Self, user_values: &[&Self]) -> Self {
+ Self::load_via_json_merge(default_value, user_values)
+ }
+ }
}