feat!: Use yarn for lower memory footprint and better performance.

However, this also removes `serde` support for now.

Author: Byron

Cargo.lock

@@ -14,7 +14,7 @@ doctest = false
 
 [features]
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
-serde = ["dep:serde", "bstr/serde", "gix-glob/serde", "kstring/serde"]
+serde = ["dep:serde", "bstr/serde", "gix-glob/serde"]
 
 [dependencies]
 gix-path = { version = "^0.10.0", path = "../gix-path" }
@@ -24,7 +24,7 @@ gix-trace = { version = "^0.1.3", path = "../gix-trace" }
 
 bstr = { version = "1.3.0", default-features = false, features = ["std", "unicode"]}
 smallvec = "1.10.0"
-kstring = "2.0.0"
+byteyarn = "0.2.3"
 unicode-bom = "2.0.2"
 thiserror = "1.0.26"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}

gix-attributes/Cargo.toml

@@ -8,8 +8,8 @@
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 #![deny(missing_docs, rust_2018_idioms, unsafe_code)]
 
+use byteyarn::{Yarn, YarnRef};
 pub use gix_glob as glob;
-use kstring::{KString, KStringRef};
 
 mod assignment;
 ///
@@ -34,15 +34,13 @@ pub fn parse(bytes: &[u8]) -> parse::Lines<'_> {
 ///
 /// Note that this doesn't contain the name.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum StateRef<'a> {
     /// The attribute is listed, or has the special value 'true'
     Set,
     /// The attribute has the special value 'false', or was prefixed with a `-` sign.
     Unset,
     /// The attribute is set to the given value, which followed the `=` sign.
     /// Note that values can be empty.
-    #[cfg_attr(feature = "serde", serde(borrow))]
     Value(state::ValueRef<'a>),
     /// The attribute isn't mentioned with a given path or is explicitly set to `Unspecified` using the `!` sign.
     Unspecified,
@@ -52,7 +50,6 @@ pub enum StateRef<'a> {
 ///
 /// Note that this doesn't contain the name.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum State {
     /// The attribute is listed, or has the special value 'true'
     Set,
@@ -67,16 +64,14 @@ pub enum State {
 
 /// Represents a validated attribute name
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Name(pub(crate) KString);
+pub struct Name(pub(crate) Yarn);
 
 /// Holds a validated attribute name as a reference
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Hash, Ord, PartialOrd)]
-pub struct NameRef<'a>(KStringRef<'a>);
+pub struct NameRef<'a>(YarnRef<'a, str>);
 
 /// Name an attribute and describe it's assigned state.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Assignment {
     /// The validated name of the attribute.
     pub name: Name,

gix-attributes/src/lib.rs

@@ -1,12 +1,16 @@
 use bstr::{BStr, BString, ByteSlice};
-use kstring::KStringRef;
+use byteyarn::YarnRef;
 
 use crate::{Name, NameRef};
 
 impl<'a> NameRef<'a> {
     /// Turn this ref into its owned counterpart.
     pub fn to_owned(self) -> Name {
-        Name(self.0.into())
+        Name(
+            self.0
+                .immortalize()
+                .map_or_else(|| self.0.to_boxed_str().into(), YarnRef::to_box),
+        )
     }
 
     /// Return the inner `str`.
@@ -35,7 +39,7 @@ impl<'a> TryFrom<&'a BStr> for NameRef<'a> {
         }
 
         attr_valid(attr)
-            .then(|| NameRef(KStringRef::from_ref(attr.to_str().expect("no illformed utf8"))))
+            .then(|| NameRef(YarnRef::from(attr.to_str().expect("no illformed utf8"))))
             .ok_or_else(|| Error { attribute: attr.into() })
     }
 }

gix-attributes/src/name.rs

@@ -1,13 +1,12 @@
 use std::borrow::Cow;
 
 use bstr::{BStr, ByteSlice};
-use kstring::KStringRef;
+use byteyarn::YarnRef;
 
 use crate::{name, AssignmentRef, Name, NameRef, StateRef};
 
 /// The kind of attribute that was parsed.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Kind {
     /// A pattern to match paths against
     Pattern(gix_glob::Pattern),
@@ -76,7 +75,7 @@ fn check_attr(attr: &BStr) -> Result<NameRef<'_>, name::Error> {
     }
 
     attr_valid(attr)
-        .then(|| NameRef(KStringRef::from_ref(attr.to_str().expect("no illformed utf8"))))
+        .then(|| NameRef(YarnRef::from(attr.to_str().expect("no illformed utf8"))))
         .ok_or_else(|| name::Error { attribute: attr.into() })
 }
 

gix-attributes/src/parse.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use kstring::KString;
+use byteyarn::Yarn;
 use smallvec::SmallVec;
 
 use crate::{Assignment, AssignmentRef};
@@ -99,7 +99,7 @@ pub struct Outcome {
     /// A stack of attributes to use for processing attributes of matched patterns and for resolving their macros.
     attrs_stack: SmallVec<[(AttributeId, Assignment, Option<AttributeId>); 8]>,
     /// A set of attributes we should limit ourselves to, or empty if we should fill in all attributes, made of
-    selected: SmallVec<[(KString, Option<AttributeId>); AVERAGE_NUM_ATTRS]>,
+    selected: SmallVec<[(Yarn, Option<AttributeId>); AVERAGE_NUM_ATTRS]>,
     /// storage for all patterns we have matched so far (in order to avoid referencing them, we copy them, but only once).
     patterns: RefMap<gix_glob::Pattern>,
     /// storage for all assignments we have matched so far (in order to avoid referencing them, we copy them, but only once).
@@ -135,7 +135,7 @@ pub struct MetadataCollection {
     /// A mapping of an attribute or macro name to its order, that is the time when it was *first* seen.
     ///
     /// This is the inverse of the order attributes are searched.
-    name_to_meta: HashMap<KString, Metadata>,
+    name_to_meta: HashMap<Yarn, Metadata>,
 }
 
 /// Metadata associated with an attribute or macro name.

gix-attributes/src/search/mod.rs

@@ -1,6 +1,6 @@
 use bstr::{BString, ByteSlice};
+use byteyarn::Yarn;
 use gix_glob::Pattern;
-use kstring::{KString, KStringRef};
 
 use crate::{
     search::{
@@ -44,23 +44,23 @@ impl Outcome {
     pub fn initialize_with_selection<'a>(
         &mut self,
         collection: &MetadataCollection,
-        attribute_names: impl IntoIterator<Item = impl Into<KStringRef<'a>>>,
+        attribute_names: impl IntoIterator<Item = impl Into<&'a str>>,
     ) {
         self.initialize_with_selection_inner(collection, &mut attribute_names.into_iter().map(Into::into))
     }
 
     fn initialize_with_selection_inner(
         &mut self,
         collection: &MetadataCollection,
-        attribute_names: &mut dyn Iterator<Item = KStringRef<'_>>,
+        attribute_names: &mut dyn Iterator<Item = &str>,
     ) {
         self.initialize(collection);
 
         self.selected.clear();
         self.selected.extend(attribute_names.map(|name| {
             (
-                name.to_owned(),
-                collection.name_to_meta.get(name.as_str()).map(|meta| meta.id),
+                Yarn::inlined(name).unwrap_or_else(|| name.to_string().into_boxed_str().into()),
+                collection.name_to_meta.get(name).map(|meta| meta.id),
             )
         }));
         self.reset_remaining();
@@ -315,7 +315,7 @@ impl MetadataCollection {
             None => {
                 let order = AttributeId(self.name_to_meta.len());
                 self.name_to_meta.insert(
-                    KString::from_ref(name),
+                    Yarn::inlined(name).unwrap_or_else(|| name.to_string().into_boxed_str().into()),
                     Metadata {
                         id: order,
                         macro_attributes: Default::default(),
@@ -335,7 +335,10 @@ impl MetadataCollection {
             Some(meta) => meta.id,
             None => {
                 let order = AttributeId(self.name_to_meta.len());
-                self.name_to_meta.insert(KString::from_ref(name), order.into());
+                self.name_to_meta.insert(
+                    Yarn::inlined(name).unwrap_or_else(|| name.to_string().into_boxed_str().into()),
+                    order.into(),
+                );
                 order
             }
         }

gix-attributes/src/search/outcome.rs

@@ -1,29 +1,21 @@
 use bstr::{BStr, ByteSlice};
-use kstring::{KString, KStringRef};
+use byteyarn::{ByteYarn, YarnRef};
 
 use crate::{State, StateRef};
 
 /// A container to encapsulate a tightly packed and typically unallocated byte value that isn't necessarily UTF8 encoded.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct Value(KString);
+pub struct Value(ByteYarn);
 
 /// A reference container to encapsulate a tightly packed and typically unallocated byte value that isn't necessarily UTF8 encoded.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct ValueRef<'a>(#[cfg_attr(feature = "serde", serde(borrow))] KStringRef<'a>);
+pub struct ValueRef<'a>(YarnRef<'a, [u8]>);
 
 /// Lifecycle
 impl<'a> ValueRef<'a> {
     /// Keep `input` as our value.
     pub fn from_bytes(input: &'a [u8]) -> Self {
-        Self(KStringRef::from_ref(
-            // SAFETY: our API makes accessing that value as `str` impossible, so illformed UTF8 is never exposed as such.
-            #[allow(unsafe_code)]
-            unsafe {
-                std::str::from_utf8_unchecked(input)
-            },
-        ))
+        Self(YarnRef::from(input))
     }
 }
 
@@ -42,19 +34,25 @@ impl ValueRef<'_> {
 
 impl<'a> From<&'a str> for ValueRef<'a> {
     fn from(v: &'a str) -> Self {
-        ValueRef(v.into())
+        ValueRef(v.as_bytes().into())
     }
 }
 
 impl<'a> From<ValueRef<'a>> for Value {
     fn from(v: ValueRef<'a>) -> Self {
-        Value(v.0.into())
+        Value(
+            v.0.immortalize()
+                .map_or_else(|| v.0.to_boxed_bytes().into(), YarnRef::to_box),
+        )
     }
 }
 
 impl From<&str> for Value {
     fn from(v: &str) -> Self {
-        Value(KString::from_ref(v))
+        Value(
+            ByteYarn::inlined(v.as_bytes())
+                .unwrap_or_else(|| ByteYarn::from_boxed_bytes(v.as_bytes().to_vec().into_boxed_slice())),
+        )
     }
 }
 

gix-attributes/src/state.rs

@@ -270,7 +270,7 @@ fn given_attributes_are_made_available_in_given_order() -> crate::Result {
 fn size_of_outcome() {
     assert_eq!(
         std::mem::size_of::<Outcome>(),
-        904,
+        752,
         "it's quite big, shouldn't change without us noticing"
     )
 }