Refactor toml::Value->Theme conversion

The `From<Value>` implementation for `Theme` converted the Value to a
string and re-parsed the string to convert it to
`HashMap<String, Value>` which feels a bit wasteful. This change uses
the underlying `toml::map::Map` directly when the value is a table and
warns about the unexpected `Value` shape otherwise.

This is necessary because toml 0.6.0 changes the Display implementation
for Value::Table so that the `to_string` no longer encodes the value as
a Document, just a Value. So the parse of the Value fails to be decoded
as a HashMap.

The behavior for returning `Default::default` matches the previous
code's behavior except that it did not warn when the input Value was
failed to parse.

helix-view/src/theme.rs

@@ -4,7 +4,7 @@ use std::{
     str,
 };
 
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, Result};
 use helix_core::hashmap;
 use helix_loader::merge_toml_values;
 use log::warn;
@@ -209,10 +209,8 @@ pub struct Theme {
 
 impl From<Value> for Theme {
     fn from(value: Value) -> Self {
-        let values: Result<HashMap<String, Value>> =
+        if let Value::Table(table) = value {
-            toml::from_str(&value.to_string()).context("Failed to load theme");
+            let (styles, scopes, highlights) = build_theme_values(table);
-
-        let (styles, scopes, highlights) = build_theme_values(values);
 
             Self {
                 styles,
@@ -220,6 +218,10 @@ impl From<Value> for Theme {
                 highlights,
                 ..Default::default()
             }
+        } else {
+            warn!("Expected theme TOML value to be a table, found {:?}", value);
+            Default::default()
+        }
     }
 }
 
@@ -228,9 +230,9 @@ impl<'de> Deserialize<'de> for Theme {
     where
         D: Deserializer<'de>,
     {
-        let values = HashMap::<String, Value>::deserialize(deserializer)?;
+        let values = Map::<String, Value>::deserialize(deserializer)?;
 
-        let (styles, scopes, highlights) = build_theme_values(Ok(values));
+        let (styles, scopes, highlights) = build_theme_values(values);
 
         Ok(Self {
             styles,
@@ -242,15 +244,14 @@ impl<'de> Deserialize<'de> for Theme {
 }
 
 fn build_theme_values(
-    values: Result<HashMap<String, Value>>,
+    mut values: Map<String, Value>,
 ) -> (HashMap<String, Style>, Vec<String>, Vec<Style>) {
     let mut styles = HashMap::new();
     let mut scopes = Vec::new();
     let mut highlights = Vec::new();
 
-    if let Ok(mut colors) = values {
     // TODO: alert user of parsing failures in editor
-        let palette = colors
+    let palette = values
         .remove("palette")
         .map(|value| {
             ThemePalette::try_from(value).unwrap_or_else(|err| {
@@ -260,11 +261,11 @@ fn build_theme_values(
         })
         .unwrap_or_default();
     // remove inherits from value to prevent errors
-        let _ = colors.remove("inherits");
+    let _ = values.remove("inherits");
-        styles.reserve(colors.len());
+    styles.reserve(values.len());
-        scopes.reserve(colors.len());
+    scopes.reserve(values.len());
-        highlights.reserve(colors.len());
+    highlights.reserve(values.len());
-        for (name, style_value) in colors {
+    for (name, style_value) in values {
         let mut style = Style::default();
         if let Err(err) = palette.parse_style(&mut style, style_value) {
             warn!("{}", err);
@@ -275,7 +276,6 @@ fn build_theme_values(
         scopes.push(name);
         highlights.push(style);
     }
-    }
 
     (styles, scopes, highlights)
 }