Rework everything to use SharedString

This commit contains a large update to ec4rs that involves major breakages.
Of particular note:

- Almost everything that returned a T<RawValue> now returns an Option<T<SharedString>>.
- The PropertyValue trait was changed to put most of its functionality in supertraits, one of which is new.
- SpellingLanguage is now available without a feature flag, but has been changed.
- Removed feature allow-empty-values as empty values are now allowed by default.
- Removed functionality of feature language-tags for now. Plan to eventually depend on unic-locale.

Author: TheDaemoness

Cargo.toml

@@ -20,12 +20,11 @@ version = "1.2.0"
 members = ["glob", "tools"]
 
 [features]
-allow-empty-values = []
 track-source = []
+language-tags = []
 
 [dependencies]
 ec4rs_glob = { version = "0.1.0", path = "glob" }
-language-tags = { version = "0.3.2", optional = true }
 
 [package.metadata.docs.rs]
 all-features = true

rustdoc.md

@@ -35,27 +35,21 @@ let indent_style: IndentStyle = cfg.get::<IndentStyle>()
     .unwrap_or(IndentStyle::Tabs);
 
 // Get a string value, with a default.
-let charset: &str = cfg.get_raw::<Charset>()
-    .filter_unset() // Handle the special "unset" value.
-    .into_option()
-    .unwrap_or("utf-8");
+// ec4rs has a string type designed for immutability and minimal allocations.
+let charset = cfg.get_raw::<Charset>()
+    .cloned()
+    .unwrap_or(ec4rs::string::SharedString::new_static("utf-8"));
 
 // Parse a non-standard property.
 let hard_wrap = cfg.get_raw_for_key("max_line_length")
-    .into_str()
+    .unwrap_or_default()
     .parse::<usize>();
 ```
 
 ## Features
 
-**allow-empty-values**: Consider lines with a key but no value as valid.
-This is likely to be explicitly allowed in a future version of the
-EditorConfig specification, but `ec4rs` currently by default treats such lines
-as invalid, necessitating this feature flag to reduce behavioral breakage.
+**language-tags**: NYI for 2.0.
 
-**language-tags**: Use the `language-tags` crate, which adds parsing for the
-`spelling_language` property.
-
-**track-source**: Allow [`RawValue`][crate::rawvalue::RawValue]
+**track-source**: Allow [`SharedString`][crate::string::SharedString]
 to store the file and line number it originates from.
 [`ConfigParser`] will add this information where applicable.

src/fallback.rs

@@ -2,22 +2,20 @@ use crate::property as prop;
 
 pub fn add_fallbacks(props: &mut crate::Properties, legacy: bool) {
     let val = props.get_raw::<prop::IndentSize>();
-    if let Some(value) = val.into_option() {
-        if let Ok(prop::IndentSize::UseTabWidth) = val.parse::<prop::IndentSize>() {
+    if let Some(value) = val {
+        if let Ok(prop::IndentSize::UseTabWidth) = value.parse::<prop::IndentSize>() {
             let value = props
                 .get_raw::<prop::TabWidth>()
-                .into_option()
-                .unwrap_or("tab")
-                .to_owned();
+                .cloned()
+                .unwrap_or(crate::string::SharedString::new_static("tab"));
             props.insert_raw::<prop::IndentSize, _>(value);
         } else {
             let value = value.to_owned();
             let _ = props.try_insert_raw::<prop::TabWidth, _>(value);
         }
     } else if let Some(value) = props
         .get_raw::<prop::TabWidth>()
-        .filter_unset()
-        .into_option()
+        .filter(|v| *v != &crate::string::UNSET)
     {
         let _ = props.try_insert_raw::<prop::IndentSize, _>(value.to_owned());
     }

src/lib.rs

@@ -27,7 +27,6 @@ mod linereader;
 mod parser;
 mod properties;
 pub mod property;
-pub mod rawvalue;
 mod section;
 pub mod string;
 #[cfg(test)]
@@ -46,12 +45,6 @@ pub use properties::{Properties, PropertiesSource};
 pub use section::Section;
 pub use traits::*;
 
-#[cfg(feature = "language-tags")]
-pub mod language_tags {
-    //! Re-export of the `language-tags` crate.
-    pub use ::language_tags::*;
-}
-
 /// Retrieves the [`Properties`] for a file at the given path.
 ///
 /// This is the simplest way to use this library in an EditorConfig integration or plugin.

src/linereader.rs

@@ -53,16 +53,7 @@ pub fn parse_line(line: &str) -> LineReadResult<'_> {
         let val = val_raw.trim_start();
         match (key.is_empty(), val.is_empty()) {
             (true, _) => Err(ParseError::InvalidLine),
-            (false, true) => {
-                #[cfg(feature = "allow-empty-values")]
-                {
-                    Ok(Line::Pair(key.trim_end(), val))
-                }
-                #[cfg(not(feature = "allow-empty-values"))]
-                {
-                    Err(ParseError::InvalidLine)
-                }
-            }
+            (false, true) => Ok(Line::Pair(key.trim_end(), val)),
             (false, false) => Ok(Line::Pair(key.trim_end(), val.trim_start())),
         }
     } else {

src/parser.rs

@@ -45,7 +45,7 @@ impl<R: io::BufRead> ConfigParser<R> {
     /// otherwise returns `Err` with the error that occurred during reading.
     ///
     /// If the `track-source` feature is enabled and `path` is `Some`,
-    /// [`RawValue`][crate::rawvalue::RawValue]s produced by this parser will
+    /// [`SharedString`][crate::string::SharedString]s produced by this parser will
     /// have their sources set appropriately.
     /// Otherwise, `path` is unused.
     pub fn new_with_path(
@@ -124,7 +124,7 @@ impl<R: io::BufRead> ConfigParser<R> {
                     Ok(Line::Nothing) => (),
                     Ok(Line::Pair(k, v)) => {
                         #[allow(unused_mut)]
-                        let mut v = crate::rawvalue::RawValue::from(v.to_owned());
+                        let mut v = crate::string::SharedString::new(v);
                         #[cfg(feature = "track-source")]
                         if let Some(path) = self.path.as_ref() {
                             v.set_source(path.clone(), line_no);

src/properties.rs

@@ -2,8 +2,10 @@ mod iter;
 
 pub use iter::*;
 
-use crate::rawvalue::RawValue;
-use crate::{PropertyKey, PropertyValue};
+use crate::{
+    string::{SharedString, ToSharedString},
+    PropertyKey, PropertyValue,
+};
 
 /// Map of property names to property values.
 ///
@@ -14,17 +16,11 @@ use crate::{PropertyKey, PropertyValue};
 /// It's the caller's responsibility to ensure all keys and values are lowercased.
 #[derive(Clone, Default)]
 pub struct Properties {
-    // Don't use Cow<'static, str> here because it's actually less-optimal
-    // for the vastly more-common case of reading parsed properties.
-    // It's a micro-optimization anyway.
     /// Key-value pairs, ordered from oldest to newest.
-    pairs: Vec<(String, RawValue)>,
+    pairs: Vec<(SharedString, SharedString)>,
     /// Indices of `pairs`, ordered matching the key of the pair each index refers to.
     /// This part is what allows logarithmic lookups.
     idxes: Vec<usize>,
-    // Unfortunately, we hand out `&mut RawValue`s all over the place,
-    // so "no empty RawValues in Properties" cannot be made an invariant
-    // without breaking API changes.
 }
 
 // TODO: Deletion.
@@ -53,32 +49,42 @@ impl Properties {
     fn find_idx(&self, key: &str) -> Result<usize, usize> {
         self.idxes
             .as_slice()
-            .binary_search_by_key(&key, |ki| self.pairs[*ki].0.as_str())
+            .binary_search_by_key(&key, |ki| &self.pairs[*ki].0)
             .map(|idx| self.idxes[idx])
     }
 
     /// Returns the unparsed "raw" value for the specified key.
-    ///
-    /// Does not test for the "unset" value. Use [`RawValue::filter_unset`].
-    pub fn get_raw_for_key(&self, key: impl AsRef<str>) -> &RawValue {
+    pub fn get_raw_for_key(&self, key: impl AsRef<str>) -> Option<&SharedString> {
         self.find_idx(key.as_ref())
             .ok()
-            .map_or(&crate::rawvalue::UNSET, |idx| &self.pairs[idx].1)
+            .map(|idx| &self.pairs[idx].1)
     }
 
     /// Returns the unparsed "raw" value for the specified property.
-    ///
-    /// Does not test for the "unset" value. Use [`RawValue::filter_unset`].
-    pub fn get_raw<T: PropertyKey>(&self) -> &RawValue {
+    pub fn get_raw<T: PropertyKey>(&self) -> Option<&SharedString> {
         self.get_raw_for_key(T::key())
     }
 
     /// Returns the parsed value for the specified property.
     ///
-    /// Does not test for the "unset" value if parsing fails. Use [`RawValue::filter_unset`].
-    pub fn get<T: PropertyKey + PropertyValue>(&self) -> Result<T, &RawValue> {
-        let retval = self.get_raw::<T>();
-        retval.parse::<T>().or(Err(retval))
+    /// If `self` does not contain a key matching [`T::key()`][PropertyKey::key()],
+    /// `Err(None)` is returned. Otherwise attempts to parse `T`
+    /// out of the string value, and returns `Err(Some)` if the parse fails.
+    pub fn get<T: PropertyKey + PropertyValue>(
+        &self,
+    ) -> Result<T, Option<crate::string::ParseError<T::Err>>> {
+        // The Option is on the error because all PropertyValues implement Default and the default
+        // should be assumed if the property is unset, meaning handling invalid values and unset
+        // values can be done with just one unwrap_or_default.
+        let Some(raw) = self.get_raw::<T>() else {
+            return Err(None);
+        };
+        raw.parse::<T>().map_err(|error| {
+            Some(crate::string::ParseError {
+                error,
+                string: raw.clone(),
+            })
+        })
     }
 
     /// Returns an iterator over the key-value pairs.
@@ -103,36 +109,48 @@ impl Properties {
         IterMut(self.pairs.iter_mut())
     }
 
-    fn get_at_mut(&mut self, idx: usize) -> &mut RawValue {
+    fn get_at_mut(&mut self, idx: usize) -> &mut SharedString {
+        // PANIC: idx needs to be within the bounds of the pairs vec.
         &mut self.pairs.get_mut(idx).unwrap().1
     }
 
-    fn insert_at(&mut self, idx: usize, key: String, val: RawValue) {
+    fn insert_at(&mut self, idx: usize, key: SharedString, val: SharedString) {
         self.idxes.insert(idx, self.pairs.len());
         self.pairs.push((key, val));
     }
 
     /// Sets the value for a specified key.
-    pub fn insert_raw_for_key(&mut self, key: impl AsRef<str>, val: impl Into<RawValue>) {
-        let key_str = key.as_ref();
-        match self.find_idx(key_str) {
-            Ok(idx) => {
-                *self.get_at_mut(idx) = val.into();
+    pub fn insert_raw_for_key(&mut self, key: impl ToSharedString, val: impl ToSharedString) {
+        if let Some(key_str) = key.try_as_str() {
+            match self.find_idx(key_str) {
+                Ok(idx) => {
+                    *self.get_at_mut(idx) = val.to_shared_string();
+                }
+                Err(idx) => {
+                    self.insert_at(idx, key.to_shared_string(), val.to_shared_string());
+                }
             }
-            Err(idx) => {
-                self.insert_at(idx, key_str.to_owned(), val.into());
+        } else {
+            let key = key.to_shared_string();
+            match self.find_idx(&key) {
+                Ok(idx) => {
+                    *self.get_at_mut(idx) = val.to_shared_string();
+                }
+                Err(idx) => {
+                    self.insert_at(idx, key, val.to_shared_string());
+                }
             }
         }
     }
 
     /// Sets the value for a specified property's key.
-    pub fn insert_raw<K: PropertyKey, V: Into<RawValue>>(&mut self, val: V) {
+    pub fn insert_raw<K: PropertyKey, V: ToSharedString>(&mut self, val: V) {
         self.insert_raw_for_key(K::key(), val)
     }
 
     /// Inserts a specified property into the map.
-    pub fn insert<T: PropertyKey + Into<RawValue>>(&mut self, prop: T) {
-        self.insert_raw_for_key(T::key(), prop.into())
+    pub fn insert<T: PropertyKey + PropertyValue>(&mut self, prop: T) {
+        self.insert_raw_for_key(T::key(), prop)
     }
 
     /// Attempts to add a new key-value pair to the map.
@@ -141,45 +159,49 @@ impl Properties {
     /// returns a mutable reference to the old value and does not update the map.
     pub fn try_insert_raw_for_key(
         &mut self,
-        key: impl AsRef<str>,
-        value: impl Into<RawValue>,
-    ) -> Result<(), &mut RawValue> {
-        let key_str = key.as_ref();
-        #[allow(clippy::unit_arg)]
-        match self.find_idx(key_str) {
-            Ok(idx) => {
-                let valref = self.get_at_mut(idx);
-                if valref.is_unset() {
-                    *valref = value.into();
+        key: impl ToSharedString,
+        val: impl ToSharedString,
+    ) -> Result<(), &mut SharedString> {
+        if let Some(key_str) = key.try_as_str() {
+            match self.find_idx(key_str) {
+                Ok(idx) => Err(self.get_at_mut(idx)),
+                Err(idx) => {
+                    self.insert_at(idx, key.to_shared_string(), val.to_shared_string());
+                    Ok(())
+                }
+            }
+        } else {
+            let key = key.to_shared_string();
+            match self.find_idx(&key) {
+                Ok(idx) => Err(self.get_at_mut(idx)),
+                Err(idx) => {
+                    self.insert_at(idx, key, val.to_shared_string());
                     Ok(())
-                } else {
-                    Err(valref)
                 }
             }
-            Err(idx) => Ok(self.insert_at(idx, key_str.to_owned(), value.into())),
         }
     }
 
     /// Attempts to add a new property to the map with a specified value.
     ///
     /// If the key was already associated with a value,
     /// returns a mutable reference to the old value and does not update the map.
-    pub fn try_insert_raw<K: PropertyKey, V: Into<RawValue>>(
+    pub fn try_insert_raw<K: PropertyKey, V: ToSharedString>(
         &mut self,
         val: V,
-    ) -> Result<(), &mut RawValue> {
+    ) -> Result<(), &mut SharedString> {
         self.try_insert_raw_for_key(K::key(), val)
     }
 
     /// Attempts to add a new property to the map.
     ///
     /// If the key was already associated with a value,
     /// returns a mutable reference to the old value and does not update the map.
-    pub fn try_insert<T: PropertyKey + Into<RawValue>>(
+    pub fn try_insert<T: PropertyKey + PropertyValue>(
         &mut self,
         prop: T,
-    ) -> Result<(), &mut RawValue> {
-        self.try_insert_raw_for_key(T::key(), prop.into())
+    ) -> Result<(), &mut SharedString> {
+        self.try_insert_raw_for_key(T::key(), prop)
     }
 
     /// Adds fallback values for certain common key-value pairs.
@@ -242,22 +264,22 @@ impl<'a> IntoIterator for &'a mut Properties {
     }
 }
 
-impl<K: AsRef<str>, V: Into<RawValue>> FromIterator<(K, V)> for Properties {
+impl<K: Into<SharedString>, V: Into<SharedString>> FromIterator<(K, V)> for Properties {
     fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
         let mut result = Properties::new();
         result.extend(iter);
         result
     }
 }
 
-impl<K: AsRef<str>, V: Into<RawValue>> Extend<(K, V)> for Properties {
+impl<K: Into<SharedString>, V: Into<SharedString>> Extend<(K, V)> for Properties {
     fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
         let iter = iter.into_iter();
         let min_len = iter.size_hint().0;
         self.pairs.reserve(min_len);
         self.idxes.reserve(min_len);
         for (k, v) in iter {
-            let k = k.as_ref();
+            let k = k.into();
             let v = v.into();
             self.insert_raw_for_key(k, v);
         }