lael-labs/gitoxide

Cargo.lock+7−2

  "serde",
 ]
+[[package]]
+name = "byteyarn"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7534301c0ea17abb4db06d75efc7b4b0fa360fce8e175a4330d721c71c942ff"
 [[package]]
 name = "cassowary"
 version = "0.3.0"
 version = "0.18.0"
 dependencies = [
  "bstr",
+ "byteyarn",
  "document-features",
  "gix-fs 0.6.0",
  "gix-glob 0.12.0",
  "gix-quote 0.4.7",
  "gix-testtools",
  "gix-trace 0.1.3",
- "kstring",
  "serde",
  "smallvec",
  "thiserror",
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec3066350882a1cd6d950d055997f379ac37fd39f81cd4d8ed186032eb3c5747"
 dependencies = [
- "serde",
  "static_assertions",
 ]

gitoxide-core/src/repository/index/entries.rs+16−3

         Ok((pathspec.into_parts().0, index, cache))
     }
-    #[cfg_attr(feature = "serde", derive(serde::Serialize))]
+    #[cfg(feature = "serde")]
+    #[derive(serde::Serialize)]
+    struct AttrsForSerde {
+        is_excluded: bool,
+        attributes: Vec<String>,
+    }
     struct Attrs {
         is_excluded: bool,
         attributes: Vec<gix::attrs::Assignment>,
             flags: u32,
             mode: u32,
             path: std::borrow::Cow<'a, str>,
-            meta: Option<Attrs>,
+            meta: Option<AttrsForSerde>,
         }
         serde_json::to_writer(
                     path.extend_from_slice(entry.path(index));
                     path.to_string().into()
                 },
-                meta: attrs,
+                meta: attrs.map(|attrs| AttrsForSerde {
+                    is_excluded: attrs.is_excluded,
+                    attributes: attrs
+                        .attributes
+                        .into_iter()
+                        .map(|attr| attr.as_ref().to_string())
+                        .collect(),
+                }),
             },
         )?;

gix-attributes/Cargo.toml+2−2

@@ -14,7 +14,7 @@ doctest = false · 13 unmodified lines
14		14
15	[features]	15	[features]
16	## Data structures implement `serde::Serialize` and `serde::Deserialize`.	16	## Data structures implement `serde::Serialize` and `serde::Deserialize`.
17	serde = ["dep:serde", "bstr/serde", "gix-glob/serde", "kstring/serde"]	17	serde = ["dep:serde", "bstr/serde", "gix-glob/serde"]
18		18
19	[dependencies]	19	[dependencies]
20	gix-path = { version = "^0.10.0", path = "../gix-path" }	20	gix-path = { version = "^0.10.0", path = "../gix-path" }
@@ -24,7 +24,7 @@ gix-trace = { version = "^0.1.3", path = "../gix-trace" } · 3 unmodified lines
24		24
25	bstr = { version = "1.3.0", default-features = false, features = ["std", "unicode"]}	25	bstr = { version = "1.3.0", default-features = false, features = ["std", "unicode"]}
26	smallvec = "1.10.0"	26	smallvec = "1.10.0"
27	kstring = "2.0.0"	27	byteyarn = "0.2.3"
28	unicode-bom = "2.0.2"	28	unicode-bom = "2.0.2"
29	thiserror = "1.0.26"	29	thiserror = "1.0.26"
30	serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}	30	serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}

gix-attributes/src/lib.rs+3−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;
 ///
 ///
 /// 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,
     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,
 ///
 /// 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,
 /// 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) Yarn);
-pub struct Name(pub(crate) KString);
 /// 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/name.rs+7−3

 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`.
         }
         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/parse.rs+2−3

 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),
     }
     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/search/mod.rs+3−3

gix-attributes/src/search/outcome.rs+10−7

 use bstr::{BString, ByteSlice};
+use byteyarn::Yarn;
 use gix_glob::Pattern;
-use kstring::{KString, KStringRef};
 use crate::{
     search::{
     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(),
+                Yarn::inlined(name).unwrap_or_else(|| name.to_string().into_boxed_str().into()),
-                collection.name_to_meta.get(name.as_str()).map(|meta| meta.id),
+                collection.name_to_meta.get(name).map(|meta| meta.id),
             )
         }));
         self.reset_remaining();
             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(),
             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/state.rs+13−15

 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(ByteYarn);
-pub struct Value(KString);
 /// 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>(YarnRef<'a, [u8]>);
-pub struct ValueRef<'a>(#[cfg_attr(feature = "serde", serde(borrow))] KStringRef<'a>);
 /// Lifecycle
 impl<'a> ValueRef<'a> {
     /// Keep `input` as our value.
     pub fn from_bytes(input: &'a [u8]) -> Self {
-        Self(KStringRef::from_ref(
+        Self(YarnRef::from(input))
-            // 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)
-            },
-        ))
     }
 }
 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/tests/search/mod.rs+1−1

@@ -270,7 +270,7 @@ fn given_attributes_are_made_available_in_given_order() -> crate::Result { · 269 unmodified lines
270	fn size_of_outcome() {	270	fn size_of_outcome() {
271	assert_eq!(	271	assert_eq!(
272	std::mem::size_of::<Outcome>(),	272	std::mem::size_of::<Outcome>(),
273	904,	273	752,
274	"it's quite big, shouldn't change without us noticing"	274	"it's quite big, shouldn't change without us noticing"
275	)	275	)
276	}	276	}

@@ -1,6 +1,6 @@
1	use std::collections::HashMap;	1	use std::collections::HashMap;
2		2
3	use kstring::KString;	3	use byteyarn::Yarn;
4	use smallvec::SmallVec;	4	use smallvec::SmallVec;
5		5
6	use crate::{Assignment, AssignmentRef};	6	use crate::{Assignment, AssignmentRef};
@@ -99,7 +99,7 @@ pub struct Outcome { · 92 unmodified lines
99	/// A stack of attributes to use for processing attributes of matched patterns and for resolving their macros.	99	/// A stack of attributes to use for processing attributes of matched patterns and for resolving their macros.
100	attrs_stack: SmallVec<[(AttributeId, Assignment, Option<AttributeId>); 8]>,	100	attrs_stack: SmallVec<[(AttributeId, Assignment, Option<AttributeId>); 8]>,
101	/// A set of attributes we should limit ourselves to, or empty if we should fill in all attributes, made of	101	/// A set of attributes we should limit ourselves to, or empty if we should fill in all attributes, made of
102	selected: SmallVec<[(KString, Option<AttributeId>); AVERAGE_NUM_ATTRS]>,	102	selected: SmallVec<[(Yarn, Option<AttributeId>); AVERAGE_NUM_ATTRS]>,
103	/// storage for all patterns we have matched so far (in order to avoid referencing them, we copy them, but only once).	103	/// storage for all patterns we have matched so far (in order to avoid referencing them, we copy them, but only once).
104	patterns: RefMap<gix_glob::Pattern>,	104	patterns: RefMap<gix_glob::Pattern>,
105	/// storage for all assignments we have matched so far (in order to avoid referencing them, we copy them, but only once).	105	/// 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 { · 29 unmodified lines
135	/// A mapping of an attribute or macro name to its order, that is the time when it was first seen.	135	/// A mapping of an attribute or macro name to its order, that is the time when it was first seen.
136	///	136	///
137	/// This is the inverse of the order attributes are searched.	137	/// This is the inverse of the order attributes are searched.
138	name_to_meta: HashMap<KString, Metadata>,	138	name_to_meta: HashMap<Yarn, Metadata>,
139	}	139	}
140		140
141	/// Metadata associated with an attribute or macro name.	141	/// Metadata associated with an attribute or macro name.