Defer mutation of editor config to the application

Author: khutchens

helix-term/src/application.rs

@@ -376,22 +376,41 @@ impl Application {
         }
     }
 
+    fn update_config(
+        &mut self,
+        pointer: String,
+        new_value: serde_json::Value,
+    ) -> anyhow::Result<()> {
+        let mut app_config = (*self.config.load().clone()).clone();
+        let mut editor_config = serde_json::json!(app_config.editor);
+
+        let old_value = editor_config
+            .pointer_mut(&pointer)
+            .ok_or_else(|| anyhow::anyhow!("Unknown key `{}`", pointer))?;
+        *old_value = new_value;
+
+        app_config.editor = serde_json::from_value(editor_config)
+            .map_err(|_| anyhow::anyhow!("Could not parse field"))?;
+
+        self.terminal.reconfigure((&app_config.editor).into())?;
+        self.config.store(Arc::new(app_config));
+        Ok(())
+    }
+
     pub fn handle_config_events(&mut self, config_event: ConfigEvent) {
         let old_editor_config = self.editor.config();
 
         match config_event {
             ConfigEvent::Refresh => self.refresh_config(),
 
             // Since only the Application can make changes to Editor's config,
-            // the Editor must send up a new copy of a modified config so that
-            // the Application can apply it.
-            ConfigEvent::Update(editor_config) => {
-                let mut app_config = (*self.config.load().clone()).clone();
-                app_config.editor = *editor_config;
-                if let Err(err) = self.terminal.reconfigure((&app_config.editor).into()) {
+            // the Editor must send an update request so that the Application
+            // can apply it. Each update request includes a path to the field
+            // that should be updated and the new value for that field.
+            ConfigEvent::Update(pointer, new_value) => {
+                if let Err(err) = self.update_config(pointer, new_value) {
                     self.editor.set_error(err.to_string());
                 };
-                self.config.store(Arc::new(app_config));
             }
         }
 

helix-term/src/commands/typed.rs

@@ -2060,22 +2060,21 @@ fn set_option(cx: &mut compositor::Context, args: Args, event: PromptEvent) -> a
     let key_error = || anyhow::anyhow!("Unknown key `{}`", key);
     let field_error = |_| anyhow::anyhow!("Could not parse field `{}`", arg);
 
-    let mut config = serde_json::json!(&cx.editor.config().deref());
+    let config = serde_json::json!(&cx.editor.config().deref());
     let pointer = format!("/{}", key.replace('.', "/"));
-    let value = config.pointer_mut(&pointer).ok_or_else(key_error)?;
+    let value = config.pointer(&pointer).ok_or_else(key_error)?;
 
-    *value = if value.is_string() {
+    let value = if value.is_string() {
         // JSON strings require quotes, so we can't .parse() directly
         Value::String(arg.to_string())
     } else {
         arg.parse().map_err(field_error)?
     };
-    let config = serde_json::from_value(config).map_err(field_error)?;
 
     cx.editor
         .config_events
         .0
-        .send(ConfigEvent::Update(config))?;
+        .send(ConfigEvent::Update(pointer, value))?;
     Ok(())
 }
 
@@ -2095,11 +2094,11 @@ fn toggle_option(
 
     let key_error = || anyhow::anyhow!("Unknown key `{}`", key);
 
-    let mut config = serde_json::json!(&cx.editor.config().deref());
+    let config = serde_json::json!(&cx.editor.config().deref());
     let pointer = format!("/{}", key.replace('.', "/"));
-    let value = config.pointer_mut(&pointer).ok_or_else(key_error)?;
+    let value = config.pointer(&pointer).ok_or_else(key_error)?;
 
-    *value = match value {
+    let value = match value {
         Value::Bool(ref value) => {
             ensure!(
                 args.len() == 1,
@@ -2149,7 +2148,7 @@ fn toggle_option(
 
             if let Some(wrongly_typed_value) = values
                 .iter()
-                .find(|v| std::mem::discriminant(*v) != std::mem::discriminant(&*value))
+                .find(|v| std::mem::discriminant(*v) != std::mem::discriminant(value))
             {
                 bail!("value '{wrongly_typed_value}' has a different type than '{value}'");
             }
@@ -2164,13 +2163,11 @@ fn toggle_option(
     };
 
     let status = format!("'{key}' is now set to {value}");
-    let config = serde_json::from_value(config)
-        .map_err(|err| anyhow::anyhow!("Failed to parse config: {err}"))?;
 
     cx.editor
         .config_events
         .0
-        .send(ConfigEvent::Update(config))?;
+        .send(ConfigEvent::Update(pointer, value))?;
     cx.editor.set_status(status);
     Ok(())
 }

helix-view/src/editor.rs

@@ -56,6 +56,7 @@ use helix_lsp::lsp;
 use helix_stdx::path::canonicalize;
 
 use serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};
+use serde_json::Value;
 
 use arc_swap::{
     access::{DynAccess, DynGuard},
@@ -1236,7 +1237,7 @@ pub enum EditorEvent {
 #[derive(Debug, Clone)]
 pub enum ConfigEvent {
     Refresh,
-    Update(Box<Config>),
+    Update(String, Value),
 }
 
 enum ThemeAction {