lael-labs/gitoxide

Cargo.lock+31−1

 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3f6d59c71e7dc3af60f0af9db32364d96a16e9310f3f5db2b55ed642162dd35"
+[[package]]
+name = "compact_str"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0e60dedcb8b23cedf6f23ee35ecf5c7889961e99f26f79ab196aaf4a8b48608"
+dependencies = [
+ "serde",
+]
 [[package]]
 name = "concurrent-queue"
 version = "1.2.2"
 version = "0.1.0"
 dependencies = [
  "bstr",
+ "compact_str",
  "git-features",
  "git-glob",
+ "git-path",
  "git-quote",
  "git-testtools",
  "quick-error",
  "criterion",
  "dirs",
  "git-features",
+ "git-path",
  "git-sec",
  "memchr",
  "nom",
  "pwd",
- "quick-error",
  "serde",
  "serde_derive",
  "serial_test",
  "tempfile",
+ "thiserror",
  "unicode-bom",
 ]
  "git-hash",
  "git-object",
  "git-pack",
+ "git-path",
  "git-quote",
  "git-testtools",
  "parking_lot 0.12.0",
  "git-hash",
  "git-object",
  "git-odb",
+ "git-path",
  "git-tempfile",
  "git-testtools",
  "git-traverse",
  "serde",
 ]
+[[package]]
+name = "git-path"
+version = "0.1.0"
+dependencies = [
+ "bstr",
+]
 [[package]]
 name = "git-pathspec"
 version = "0.0.0"
  "git-lock",
  "git-object",
  "git-odb",
+ "git-path",
  "git-tempfile",
  "git-testtools",
  "git-validate",
  "clru",
  "document-features",
  "git-actor",
+ "git-attributes",
  "git-config",
  "git-credentials",
  "git-diff",
  "git-object",
  "git-odb",
  "git-pack",
+ "git-path",
  "git-protocol",
  "git-ref",
  "git-revision",
  "git-url",
  "git-validate",
  "git-worktree",
+ "is_ci",
  "log",
  "signal-hook",
  "tempfile",
  "libc",
  "serde",
  "tempfile",
+ "thiserror",
  "windows",
 ]
 dependencies = [
  "bstr",
  "git-features",
+ "git-path",
  "home",
  "quick-error",
  "serde",
 dependencies = [
  "bstr",
  "document-features",
+ "git-attributes",
  "git-features",
+ "git-glob",
  "git-hash",
  "git-index",
  "git-object",
  "git-odb",
+ "git-path",
  "git-testtools",
  "io-close",
  "serde",

Cargo.toml+1−0

@@ -161,6 +161,7 @@ members = [ · 160 unmodified lines
161	"git-lock",	161	"git-lock",
162	"git-attributes",	162	"git-attributes",
163	"git-pathspec",	163	"git-pathspec",
		164	"git-path",
164	"git-repository",	165	"git-repository",
165	"gitoxide-core",	166	"gitoxide-core",
166	"git-tui",	167	"git-tui",

README.md+3−0

     * **mailmap**
       * [x] **verify** - check entries of a mailmap file for parse errors and display them
     * **repository**
+      * **exclude**
+         * [x] **query** - check if path specs are excluded via gits exclusion rules like `.gitignore`.
       * **verify** - validate a whole repository, for now only the object database.
       * **commit**
          * [x] **describe** - identify a commit by its closest tag in its past
   * [git-bitmap](https://github.com/Byron/gitoxide/blob/main/crate-status.md#git-bitmap)
   * [git-revision](https://github.com/Byron/gitoxide/blob/main/crate-status.md#git-revision)
   * [git-attributes](https://github.com/Byron/gitoxide/blob/main/crate-status.md#git-attributes)
+  * [git-path](https://github.com/Byron/gitoxide/blob/main/crate-status.md#git-path)
 * **idea**
   * [git-note](https://github.com/Byron/gitoxide/blob/main/crate-status.md#git-note)
   * [git-filter](https://github.com/Byron/gitoxide/blob/main/crate-status.md#git-filter)

crate-status.md+9−1

 * [x] parsing
 * [x] lookup and mapping of author names
+### git-path
+* [x] transformations to and from bytes
+* [x] conversions between different platforms
+* **spec**
+    * [ ] parse
+    * [ ] check for match
 ### git-pathspec
 * [ ] parse
 * [ ] check for match
   * **refs**
     * [ ] run transaction hooks and handle special repository states like quarantine
     * [ ] support for different backends like `files` and `reftable`
-  * [ ] worktrees
+  * **worktrees**
+    * [ ] open a repository with worktrees
   * [ ] remotes with push and pull
   * [x] mailmap
   * [x] object replacements (`git replace`)

etc/check-package-size.sh+2−1

 (enter cargo-smart-release && indent cargo diet -n --package-size-limit 90KB)
 (enter git-actor && indent cargo diet -n --package-size-limit 5KB)
 (enter git-pathspec && indent cargo diet -n --package-size-limit 5KB)
+(enter git-path && indent cargo diet -n --package-size-limit 10KB)
 (enter git-attributes && indent cargo diet -n --package-size-limit 10KB)
 (enter git-index && indent cargo diet -n --package-size-limit 30KB)
 (enter git-worktree && indent cargo diet -n --package-size-limit 25KB)
 (enter git-odb && indent cargo diet -n --package-size-limit 120KB)
 (enter git-protocol && indent cargo diet -n --package-size-limit 50KB)
 (enter git-packetline && indent cargo diet -n --package-size-limit 35KB)
-(enter git-repository && indent cargo diet -n --package-size-limit 90KB)
+(enter git-repository && indent cargo diet -n --package-size-limit 100KB)
 (enter git-transport && indent cargo diet -n --package-size-limit 50KB)
 (enter gitoxide-core && indent cargo diet -n --package-size-limit 70KB)

git-attributes/Cargo.toml+3−1

 [features]
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
-serde1 = ["serde", "bstr/serde1", "git-glob/serde1"]
+serde1 = ["serde", "bstr/serde1", "git-glob/serde1", "compact_str/serde"]
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [dependencies]
 git-features = { version = "^0.20.0", path = "../git-features" }
+git-path = { version = "^0.1.0", path = "../git-path" }
 git-quote = { version = "^0.2.0", path = "../git-quote" }
 git-glob = { version = "^0.2.0", path = "../git-glob" }
 unicode-bom = "1.1.4"
 quick-error = "2.0.0"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}
+compact_str = "0.3.2"
 [dev-dependencies]
 git-testtools = { path = "../tests/tools"}

git-attributes/src/lib.rs+61−66

 #![deny(rust_2018_idioms)]
 use bstr::{BStr, BString};
+use compact_str::CompactStr;
+use std::path::PathBuf;
+pub use git_glob as glob;
+/// The state an attribute can be in, referencing the value.
+///
+/// Note that this doesn't contain the name.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
-pub enum State<'a> {
+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.
     Unspecified,
 }
-/// A grouping of lists of patterns while possibly keeping associated to their base path.
+/// The state an attribute can be in, owning the value.
 ///
-/// Patterns with base path are queryable relative to that base, otherwise they are relative to the repository root.
+/// Note that this doesn't contain the name.
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
+pub enum State {
+    /// 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.
+    Value(compact_str::CompactStr),
+    /// The attribute isn't mentioned with a given path or is explicitly set to `Unspecified` using the `!` sign.
+    Unspecified,
+}
+/// Name an attribute and describe it's assigned state.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
-pub struct MatchGroup<T: match_group::Tag> {
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
+pub struct Assignment {
+    /// The name of the attribute.
+    pub name: CompactStr,
+    /// The state of the attribute.
+    pub state: State,
+}
+/// A grouping of lists of patterns while possibly keeping associated to their base path.
+///
+/// Pattern lists with base path are queryable relative to that base, otherwise they are relative to the repository root.
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Default)]
+pub struct MatchGroup<T: match_group::Pattern = Attributes> {
     /// A list of pattern lists, each representing a patterns from a file or specified by hand, in the order they were
     /// specified in.
     ///
     pub patterns: Vec<PatternList<T>>,
 }
-/// A list of patterns with an optional names, for matching against it.
+/// A list of patterns which optionally know where they were loaded from and what their base is.
-#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
+///
-pub struct PatternList<T: match_group::Tag> {
+/// Knowing their base which is relative to a source directory, it will ignore all path to match against
-    /// Patterns and their associated data in the order they were loaded in or specified.
+/// that don't also start with said base.
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Default)]
+pub struct PatternList<T: match_group::Pattern> {
+    /// Patterns and their associated data in the order they were loaded in or specified,
+    /// the line number in its source file or its sequence number (_`(pattern, value, line_number)`_).
     ///
     /// During matching, this order is reversed.
-    pub patterns: Vec<(git_glob::Pattern, T::Value)>,
+    pub patterns: Vec<PatternMapping<T::Value>>,
-    /// The path at which the patterns are located in a format suitable for matches, or `None` if the patterns
+    /// The path from which the patterns were read, or `None` if the patterns
-    /// are relative to the worktree root.
+    /// don't originate in a file on disk.
-    base: Option<BString>,
+    pub source: Option<PathBuf>,
-}
-mod match_group {
-    use crate::{MatchGroup, PatternList};
-    use std::ffi::OsString;
-    use std::path::PathBuf;
-    /// A marker trait to identify the type of a description.
-    pub trait Tag: Clone + PartialEq + Eq + std::fmt::Debug + std::hash::Hash + Ord + PartialOrd {
-        /// The value associated with a pattern.
-        type Value: PartialEq + Eq + std::fmt::Debug + std::hash::Hash + Ord + PartialOrd + Clone;
-    }
-    /// Identify ignore patterns.
-    #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
-    pub struct Ignore;
-    impl Tag for Ignore {
-        type Value = ();
-    }
-    /// Identify patterns with attributes.
+    /// The parent directory of source, or `None` if the patterns are _global_ to match against the repository root.
-    #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
+    /// It's processed to contain slashes only and to end with a trailing slash, and is relative to the repository root.
-    pub struct Attributes;
+    pub base: Option<BString>,
-    impl Tag for Attributes {
+}
-        /// TODO: identify the actual value, should be name/State pairs, but there is the question of storage.
-        type Value = ();
-    }
-    impl MatchGroup<Ignore> {
-        /// See [PatternList::<Ignore>::from_overrides()] for details.
-        pub fn from_overrides(patterns: impl IntoIterator<Item = impl Into<OsString>>) -> Self {
-            MatchGroup {
-                patterns: vec![PatternList::<Ignore>::from_overrides(patterns)],
-            }
-        }
-    }
-    impl PatternList<Ignore> {
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
-        /// Parse a list of patterns, using slashes as path separators
+pub struct PatternMapping<T> {
-        pub fn from_overrides(patterns: impl IntoIterator<Item = impl Into<OsString>>) -> Self {
+    pub pattern: git_glob::Pattern,
-            PatternList {
+    pub value: T,
-                patterns: patterns
+    pub sequence_number: usize,
-                    .into_iter()
-                    .map(Into::into)
-                    .filter_map(|pattern| {
-                        let pattern = git_features::path::into_bytes(PathBuf::from(pattern)).ok()?;
-                        git_glob::parse(pattern.as_ref()).map(|p| (p, ()))
-                    })
-                    .collect(),
-                base: None,
-            }
-        }
-    }
 }
-pub use match_group::{Attributes, Ignore, Tag};
-pub type Files = MatchGroup<Attributes>;
+mod match_group;
-pub type IgnoreFiles = MatchGroup<Ignore>;
+pub use match_group::{Attributes, Ignore, Match, Pattern};
 pub mod parse;

git-attributes/src/match_group.rs+354−0

@@ -0,0 +1,354 @@
	1	use crate::{Assignment, MatchGroup, PatternList, PatternMapping, State, StateRef};
	2	use bstr::{BStr, BString, ByteSlice, ByteVec};
	3	use std::ffi::OsString;
	4	use std::io::Read;
	5	use std::path::{Path, PathBuf};
	6
	7	impl<'a> From<StateRef<'a>> for State {
	8	fn from(s: StateRef<'a>) -> Self {
	9	match s {
	10	StateRef::Value(v) => State::Value(v.to_str().expect("no illformed unicode").into()),
	11	StateRef::Set => State::Set,
	12	StateRef::Unset => State::Unset,
	13	StateRef::Unspecified => State::Unspecified,
	14	}
	15	}
	16	}
	17
	18	fn attrs_to_assignments<'a>(
	19	attrs: impl Iterator<Item = Result<(&'a BStr, StateRef<'a>), crate::parse::Error>>,
	20	) -> Result<Vec<Assignment>, crate::parse::Error> {
	21	attrs
	22	.map(\|res\| {
	23	res.map(\|(name, state)\| Assignment {
	24	name: name.to_str().expect("no illformed unicode").into(),
	25	state: state.into(),
	26	})
	27	})
	28	.collect()
	29	}
	30
	31	/// A marker trait to identify the type of a description.
	32	pub trait Pattern: Clone + PartialEq + Eq + std::fmt::Debug + std::hash::Hash + Ord + PartialOrd + Default {
	33	/// The value associated with a pattern.
	34	type Value: PartialEq + Eq + std::fmt::Debug + std::hash::Hash + Ord + PartialOrd + Clone;
	35
	36	/// Parse all patterns in `bytes` line by line, ignoring lines with errors, and collect them.
	37	fn bytes_to_patterns(bytes: &[u8]) -> Vec<PatternMapping<Self::Value>>;
	38
	39	fn use_pattern(pattern: &git_glob::Pattern) -> bool;
	40	}
	41
	42	/// Identify ignore patterns.
	43	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Default)]
	44	pub struct Ignore;
	45
	46	impl Pattern for Ignore {
	47	type Value = ();
	48
	49	fn bytes_to_patterns(bytes: &[u8]) -> Vec<PatternMapping<Self::Value>> {
	50	crate::parse::ignore(bytes)
	51	.map(\|(pattern, line_number)\| PatternMapping {
	52	pattern,
	53	value: (),
	54	sequence_number: line_number,
	55	})
	56	.collect()
	57	}
	58
	59	fn use_pattern(_pattern: &git_glob::Pattern) -> bool {
	60	true
	61	}
	62	}
	63
	64	/// A value of an attribute pattern, which is either a macro definition or
	65	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
	66	pub enum Value {
	67	MacroAttributes(Vec<Assignment>),
	68	Attributes(Vec<Assignment>),
	69	}
	70
	71	/// Identify patterns with attributes.
	72	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Default)]
	73	pub struct Attributes;
	74
	75	impl Pattern for Attributes {
	76	type Value = Value;
	77
	78	fn bytes_to_patterns(bytes: &[u8]) -> Vec<PatternMapping<Self::Value>> {
	79	crate::parse(bytes)
	80	.filter_map(Result::ok)
	81	.filter_map(\|(pattern_kind, attrs, line_number)\| {
	82	let (pattern, value) = match pattern_kind {
	83	crate::parse::Kind::Macro(macro_name) => (
	84	git_glob::Pattern {
	85	text: macro_name,
	86	mode: git_glob::pattern::Mode::all(),
	87	first_wildcard_pos: None,
	88	},
	89	Value::MacroAttributes(attrs_to_assignments(attrs).ok()?),
	90	),
	91	crate::parse::Kind::Pattern(p) => (
	92	(!p.is_negative()).then(\|\| p)?,
	93	Value::Attributes(attrs_to_assignments(attrs).ok()?),
	94	),
	95	};
	96	PatternMapping {
	97	pattern,
	98	value,
	99	sequence_number: line_number,
	100	}
	101	.into()
	102	})
	103	.collect()
	104	}
	105
	106	fn use_pattern(pattern: &git_glob::Pattern) -> bool {
	107	pattern.mode != git_glob::pattern::Mode::all()
	108	}
	109	}
	110
	111	/// Describes a matching value within a [`MatchGroup`].
	112	#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
	113	pub struct Match<'a, T> {
	114	pub pattern: &'a git_glob::Pattern,
	115	/// The value associated with the pattern.
	116	pub value: &'a T,
	117	/// The path to the source from which the pattern was loaded, or `None` if it was specified by other means.
	118	pub source: Option<&'a Path>,
	119	/// The line at which the pattern was found in its `source` file, or the occurrence in which it was provided.
	120	pub sequence_number: usize,
	121	}
	122
	123	impl<T> MatchGroup<T>
	124	where
	125	T: Pattern,
	126	{
	127	/// Match `relative_path`, a path relative to the repository containing all patterns, and return the first match if available.
	128	// TODO: better docs
	129	pub fn pattern_matching_relative_path<'a>(
	130	&self,
	131	relative_path: impl Into<&'a BStr>,
	132	is_dir: Option<bool>,
	133	case: git_glob::pattern::Case,
	134	) -> Option<Match<'_, T::Value>> {
	135	let relative_path = relative_path.into();
	136	let basename_pos = relative_path.rfind(b"/").map(\|p\| p + 1);
	137	self.patterns
	138	.iter()
	139	.rev()
	140	.find_map(\|pl\| pl.pattern_matching_relative_path(relative_path, basename_pos, is_dir, case))
	141	}
	142	}
	143
	144	impl MatchGroup<Ignore> {
	145	/// Given `git_dir`, a `.git` repository, load ignore patterns from `info/exclude` and from `excludes_file` if it
	146	/// is provided.
	147	/// Note that it's not considered an error if the provided `excludes_file` does not exist.
	148	pub fn from_git_dir(
	149	git_dir: impl AsRef<Path>,
	150	excludes_file: Option<PathBuf>,
	151	buf: &mut Vec<u8>,
	152	) -> std::io::Result<Self> {
	153	let mut group = Self::default();
	154
	155	let follow_symlinks = true;
	156	// order matters! More important ones first.
	157	group.patterns.extend(
	158	excludes_file
	159	.map(\|file\| PatternList::<Ignore>::from_file(file, None, follow_symlinks, buf))
	160	.transpose()?
	161	.flatten(),
	162	);
	163	group.patterns.extend(PatternList::<Ignore>::from_file(
	164	git_dir.as_ref().join("info").join("exclude"),
	165	None,
	166	follow_symlinks,
	167	buf,
	168	)?);
	169	Ok(group)
	170	}
	171
	172	/// See [PatternList::<Ignore>::from_overrides()] for details.
	173	pub fn from_overrides(patterns: impl IntoIterator<Item = impl Into<OsString>>) -> Self {
	174	MatchGroup {
	175	patterns: vec![PatternList::<Ignore>::from_overrides(patterns)],
	176	}
	177	}
	178
	179	/// Add the given file at `source` if it exists, otherwise do nothing. If a `root` is provided, it's not considered a global file anymore.
	180	/// Returns true if the file was added, or false if it didn't exist.
	181	pub fn add_patterns_file(
	182	&mut self,
	183	source: impl Into<PathBuf>,
	184	follow_symlinks: bool,
	185	root: Option<&Path>,
	186	buf: &mut Vec<u8>,
	187	) -> std::io::Result<bool> {
	188	let previous_len = self.patterns.len();
	189	self.patterns.extend(PatternList::<Ignore>::from_file(
	190	source.into(),
	191	root,
	192	follow_symlinks,
	193	buf,
	194	)?);
	195	Ok(self.patterns.len() != previous_len)
	196	}
	197
	198	pub fn add_patterns_buffer(&mut self, bytes: &[u8], source: impl Into<PathBuf>, root: Option<&Path>) {
	199	self.patterns
	200	.push(PatternList::<Ignore>::from_bytes(bytes, source.into(), root));
	201	}
	202	}
	203
	204	fn read_in_full_ignore_missing(path: &Path, follow_symlinks: bool, buf: &mut Vec<u8>) -> std::io::Result<bool> {
	205	buf.clear();
	206	let file = if follow_symlinks {
	207	std::fs::File::open(path)
	208	} else {
	209	git_features::fs::open_options_no_follow().read(true).open(path)
	210	};
	211	Ok(match file {
	212	Ok(mut file) => {
	213	file.read_to_end(buf)?;
	214	true
	215	}
	216	Err(err) if err.kind() == std::io::ErrorKind::NotFound => false,
	217	Err(err) => return Err(err),
	218	})
	219	}
	220
	221	impl<T> PatternList<T>
	222	where
	223	T: Pattern,
	224	{
	225	/// `source` is the location of the `bytes` which represent a list of patterns line by line.
	226	pub fn from_bytes(bytes: &[u8], source: impl Into<PathBuf>, root: Option<&Path>) -> Self {
	227	let source = source.into();
	228	let patterns = T::bytes_to_patterns(bytes);
	229
	230	let base = root
	231	.and_then(\|root\| source.parent().expect("file").strip_prefix(root).ok())
	232	.and_then(\|base\| {
	233	(!base.as_os_str().is_empty()).then(\|\| {
	234	let mut base: BString =
	235	git_path::to_unix_separators_on_windows(git_path::into_bstr(base)).into_owned();
	236
	237	base.push_byte(b'/');
	238	base
	239	})
	240	});
	241	PatternList {
	242	patterns,
	243	source: Some(source),
	244	base,
	245	}
	246	}
	247	pub fn from_file(
	248	source: impl Into<PathBuf>,
	249	root: Option<&Path>,
	250	follow_symlinks: bool,
	251	buf: &mut Vec<u8>,
	252	) -> std::io::Result<Option<Self>> {
	253	let source = source.into();
	254	Ok(read_in_full_ignore_missing(&source, follow_symlinks, buf)?.then(\|\| Self::from_bytes(buf, source, root)))
	255	}
	256	}
	257
	258	impl<T> PatternList<T>
	259	where
	260	T: Pattern,
	261	{
	262	pub fn pattern_matching_relative_path(
	263	&self,
	264	relative_path: &BStr,
	265	basename_pos: Option<usize>,
	266	is_dir: Option<bool>,
	267	case: git_glob::pattern::Case,
	268	) -> Option<Match<'_, T::Value>> {
	269	let (relative_path, basename_start_pos) =
	270	self.strip_base_handle_recompute_basename_pos(relative_path, basename_pos)?;
	271	self.patterns
	272	.iter()
	273	.rev()
	274	.filter(\|pm\| T::use_pattern(&pm.pattern))
	275	.find_map(
	276	\|PatternMapping {
	277	pattern,
	278	value,
	279	sequence_number,
	280	}\| {
	281	pattern
	282	.matches_repo_relative_path(relative_path, basename_start_pos, is_dir, case)
	283	.then(\|\| Match {
	284	pattern,
	285	value,
	286	source: self.source.as_deref(),
	287	sequence_number: *sequence_number,
	288	})
	289	},
	290	)
	291	}
	292
	293	pub fn pattern_idx_matching_relative_path(
	294	&self,
	295	relative_path: &BStr,
	296	basename_pos: Option<usize>,
	297	is_dir: Option<bool>,
	298	case: git_glob::pattern::Case,
	299	) -> Option<usize> {
	300	let (relative_path, basename_start_pos) =
	301	self.strip_base_handle_recompute_basename_pos(relative_path, basename_pos)?;
	302	self.patterns
	303	.iter()
	304	.enumerate()
	305	.rev()
	306	.filter(\|(_, pm)\| T::use_pattern(&pm.pattern))
	307	.find_map(\|(idx, pm)\| {
	308	pm.pattern
	309	.matches_repo_relative_path(relative_path, basename_start_pos, is_dir, case)
	310	.then(\|\| idx)
	311	})
	312	}
	313
	314	fn strip_base_handle_recompute_basename_pos<'a>(
	315	&self,
	316	relative_path: &'a BStr,
	317	basename_pos: Option<usize>,
	318	) -> Option<(&'a BStr, Option<usize>)> {
	319	match self.base.as_deref() {
	320	Some(base) => (
	321	relative_path.strip_prefix(base.as_slice())?.as_bstr(),
	322	basename_pos.and_then(\|pos\| {
	323	let pos = pos - base.len();
	324	(pos != 0).then(\|\| pos)
	325	}),
	326	),
	327	None => (relative_path, basename_pos),
	328	}
	329	.into()
	330	}
	331	}
	332
	333	impl PatternList<Ignore> {
	334	/// Parse a list of patterns, using slashes as path separators
	335	pub fn from_overrides(patterns: impl IntoIterator<Item = impl Into<OsString>>) -> Self {
	336	PatternList {
	337	patterns: patterns
	338	.into_iter()
	339	.map(Into::into)
	340	.enumerate()
	341	.filter_map(\|(seq_id, pattern)\| {
	342	let pattern = git_path::try_into_bstr(PathBuf::from(pattern)).ok()?;
	343	git_glob::parse(pattern.as_ref()).map(\|p\| PatternMapping {
	344	pattern: p,
	345	value: (),
	346	sequence_number: seq_id,
	347	})
	348	})
	349	.collect(),
	350	source: None,
	351	base: None,
	352	}
	353	}
	354	}

git-attributes/src/parse/attribute.rs+6−6

@@ -56,20 +56,20 @@ impl<'a> Iter<'a> { · 55 unmodified lines
56	}	56	}
57	}	57	}
58		58
59	fn parse_attr(&self, attr: &'a [u8]) -> Result<(&'a BStr, crate::State<'a>), Error> {	59	fn parse_attr(&self, attr: &'a [u8]) -> Result<(&'a BStr, crate::StateRef<'a>), Error> {
60	let mut tokens = attr.splitn(2, \|b\| *b == b'=');	60	let mut tokens = attr.splitn(2, \|b\| *b == b'=');
61	let attr = tokens.next().expect("attr itself").as_bstr();	61	let attr = tokens.next().expect("attr itself").as_bstr();
62	let possibly_value = tokens.next();	62	let possibly_value = tokens.next();
63	let (attr, state) = if attr.first() == Some(&b'-') {	63	let (attr, state) = if attr.first() == Some(&b'-') {
64	(&attr[1..], crate::State::Unset)	64	(&attr[1..], crate::StateRef::Unset)
65	} else if attr.first() == Some(&b'!') {	65	} else if attr.first() == Some(&b'!') {
66	(&attr[1..], crate::State::Unspecified)	66	(&attr[1..], crate::StateRef::Unspecified)
67	} else {	67	} else {
68	(	68	(
69	attr,	69	attr,
70	possibly_value	70	possibly_value
71	.map(\|v\| crate::State::Value(v.as_bstr()))	71	.map(\|v\| crate::StateRef::Value(v.as_bstr()))
72	.unwrap_or(crate::State::Set),	72	.unwrap_or(crate::StateRef::Set),
73	)	73	)
74	};	74	};
75	Ok((check_attr(attr, self.line_no)?, state))	75	Ok((check_attr(attr, self.line_no)?, state))
@@ -95,7 +95,7 @@ fn check_attr(attr: &BStr, line_number: usize) -> Result<&BStr, Error> { · 19 unmodified lines
95	}	95	}
96		96
97	impl<'a> Iterator for Iter<'a> {	97	impl<'a> Iterator for Iter<'a> {
98	type Item = Result<(&'a BStr, crate::State<'a>), Error>;	98	type Item = Result<(&'a BStr, crate::StateRef<'a>), Error>;
99		99
100	fn next(&mut self) -> Option<Self::Item> {	100	fn next(&mut self) -> Option<Self::Item> {
101	let attr = self.attrs.next().filter(\|a\| !a.is_empty())?;	101	let attr = self.attrs.next().filter(\|a\| !a.is_empty())?;

git-attributes/tests/attributes.rs+1−0

@@ -1,2 +1,3 @@
		1	pub use git_testtools::Result;
1	mod match_group;	2	mod match_group;
2	mod parse;	3	mod parse;

git-attributes/tests/fixtures/make_global_and_external_and_dir_ignores.sh+77−0

@@ -0,0 +1,77 @@
	1	#!/bin/bash
	2	set -eu -o pipefail
	3
	4	cat <<EOF >user.exclude
	5	# a custom exclude configured per user
	6	user-file-anywhere
	7	/user-file-from-top
	8
	9	user-dir-anywhere/
	10	/user-dir-from-top
	11
	12	user-subdir/file
	13	**/user-subdir-anywhere/file
	14	EOF
	15
	16	mkdir repo;
	17	(cd repo
	18	git init -q
	19	git config core.excludesFile ../user.exclude
	20
	21	cat <<EOF >.git/info/exclude
	22	# a sample .git/info/exclude
	23	file-anywhere
	24	/file-from-top
	25
	26	dir-anywhere/
	27	/dir-from-top
	28
	29	subdir/file
	30	**/subdir-anywhere/file
	31	EOF
	32
	33	cat <<EOF >.gitignore
	34	# a sample .gitignore
	35	top-level-local-file-anywhere
	36	EOF
	37
	38	mkdir dir-with-ignore
	39	cat <<EOF >dir-with-ignore/.gitignore
	40	# a sample .gitignore
	41	sub-level-local-file-anywhere
	42	EOF
	43
	44	git add .gitignore dir-with-ignore
	45	git commit --allow-empty -m "init"
	46
	47	mkdir user-dir-anywhere user-dir-from-top dir-anywhere dir-from-top
	48	mkdir -p dir/user-dir-anywhere dir/dir-anywhere
	49
	50	git check-ignore -vn --stdin 2>&1 <<EOF >git-check-ignore.baseline \|\| :
	51	user-file-anywhere
	52	dir/user-file-anywhere
	53	user-file-from-top
	54	no-match/user-file-from-top
	55	user-dir-anywhere
	56	user-dir-from-top
	57	no-match/user-dir-from-top
	58	user-subdir/file
	59	subdir/user-subdir-anywhere/file
	60	file-anywhere
	61	dir/file-anywhere
	62	file-from-top
	63	no-match/file-from-top
	64	dir-anywhere
	65	dir/dir-anywhere
	66	dir-from-top
	67	no-match/dir-from-top
	68	subdir/file
	69	subdir/subdir-anywhere/file
	70	top-level-local-file-anywhere
	71	dir/top-level-local-file-anywhere
	72	no-match/sub-level-local-file-anywhere
	73	dir-with-ignore/sub-level-local-file-anywhere
	74	dir-with-ignore/sub-dir/sub-level-local-file-anywhere
	75	EOF
	76
	77	)

git-attributes/tests/match_group/mod.rs+108−5

@@ -1,14 +1,117 @@
1	mod ignore {	1	mod ignore {
2	use git_attributes::Ignore;	2	use bstr::{BStr, ByteSlice};
		3	use git_attributes::{Ignore, Match, MatchGroup};
		4	use git_glob::pattern::Case;
		5	use std::io::Read;
		6
		7	struct Expectations<'a> {
		8	lines: bstr::Lines<'a>,
		9	}
		10
		11	impl<'a> Iterator for Expectations<'a> {
		12	type Item = (&'a BStr, Option<(&'a BStr, usize, &'a BStr)>);
		13
		14	fn next(&mut self) -> Option<Self::Item> {
		15	let line = self.lines.next()?;
		16	let (left, value) = line.split_at(line.find_byte(b'\t').unwrap());
		17	let value = value[1..].as_bstr();
		18
		19	let source_and_line = if left == b"::" {
		20	None
		21	} else {
		22	let mut tokens = left.split(\|b\| *b == b':');
		23	let source = tokens.next().unwrap().as_bstr();
		24	let line_number: usize = tokens.next().unwrap().to_str_lossy().parse().ok().unwrap();
		25	let pattern = tokens.next().unwrap().as_bstr();
		26	Some((source, line_number, pattern))
		27	};
		28	Some((value, source_and_line))
		29	}
		30	}
		31
		32	#[test]
		33	fn from_git_dir() -> crate::Result {
		34	let dir = git_testtools::scripted_fixture_repo_read_only("make_global_and_external_and_dir_ignores.sh")?;
		35	let repo_dir = dir.join("repo");
		36	let git_dir = repo_dir.join(".git");
		37	let baseline = std::fs::read(git_dir.parent().unwrap().join("git-check-ignore.baseline"))?;
		38	let mut buf = Vec::new();
		39	let mut group = MatchGroup::from_git_dir(git_dir, Some(dir.join("user.exclude")), &mut buf)?;
		40
		41	assert!(
		42	!group.add_patterns_file("not-a-file", false, None, &mut buf)?,
		43	"missing files are no problem and cause a negative response"
		44	);
		45	assert!(
		46	group.add_patterns_file(repo_dir.join(".gitignore"), true, repo_dir.as_path().into(), &mut buf)?,
		47	"existing files return true"
		48	);
		49
		50	buf.clear();
		51	let ignore_file = repo_dir.join("dir-with-ignore").join(".gitignore");
		52	std::fs::File::open(&ignore_file)?.read_to_end(&mut buf)?;
		53	group.add_patterns_buffer(&buf, ignore_file, repo_dir.as_path().into());
		54
		55	for (path, source_and_line) in (Expectations {
		56	lines: baseline.lines(),
		57	}) {
		58	let actual = group.pattern_matching_relative_path(
		59	path,
		60	repo_dir
		61	.join(path.to_str_lossy().as_ref())
		62	.metadata()
		63	.ok()
		64	.map(\|m\| m.is_dir()),
		65	Case::Sensitive,
		66	);
		67	match (actual, source_and_line) {
		68	(
		69	Some(Match {
		70	sequence_number,
		71	pattern: _,
		72	source,
		73	value: _,
		74	}),
		75	Some((expected_source, line, _expected_pattern)),
		76	) => {
		77	assert_eq!(sequence_number, line, "our counting should match the one used in git");
		78	assert_eq!(
		79	source.map(\|p\| p.canonicalize().unwrap()),
		80	Some(repo_dir.join(expected_source.to_str_lossy().as_ref()).canonicalize()?)
		81	);
		82	}
		83	(None, None) => {}
		84	(actual, expected) => panic!("actual {:?} should match {:?} with path '{}'", actual, expected, path),
		85	}
		86	}
		87	Ok(())
		88	}
3		89
4	#[test]	90	#[test]
5	fn init_from_overrides() {	91	fn from_overrides() {
6	let input = ["simple", "pattern/"];	92	let input = ["simple", "pattern/"];
7	let patterns = git_attributes::MatchGroup::<Ignore>::from_overrides(input).patterns;	93	let group = git_attributes::MatchGroup::<Ignore>::from_overrides(input);
8	assert_eq!(patterns.len(), 1);	94	assert_eq!(
		95	group.pattern_matching_relative_path("Simple", None, git_glob::pattern::Case::Fold),
		96	Some(pattern_to_match(&git_glob::parse("simple").unwrap(), 0))
		97	);
		98	assert_eq!(
		99	group.pattern_matching_relative_path("pattern", Some(true), git_glob::pattern::Case::Sensitive),
		100	Some(pattern_to_match(&git_glob::parse("pattern/").unwrap(), 1))
		101	);
		102	assert_eq!(group.patterns.len(), 1);
9	assert_eq!(	103	assert_eq!(
10	git_attributes::PatternList::<Ignore>::from_overrides(input),	104	git_attributes::PatternList::<Ignore>::from_overrides(input),
11	patterns.into_iter().next().unwrap()	105	group.patterns.into_iter().next().unwrap()
12	);	106	);
13	}	107	}
		108
		109	fn pattern_to_match(pattern: &git_glob::Pattern, sequence_number: usize) -> Match<'_, ()> {
		110	Match {
		111	pattern,
		112	value: &(),
		113	source: None,
		114	sequence_number,
		115	}
		116	}
14	}	117	}

git-attributes/tests/parse/attribute.rs+11−11

@@ -1,5 +1,5 @@
1	use bstr::{BStr, ByteSlice};	1	use bstr::{BStr, ByteSlice};
2	use git_attributes::{parse, State};	2	use git_attributes::{parse, StateRef};
3	use git_glob::pattern::Mode;	3	use git_glob::pattern::Mode;
4	use git_testtools::fixture_bytes;	4	use git_testtools::fixture_bytes;
5		5
@@ -30,7 +30,7 @@ fn line_numbers_are_counted_correctly() { · 24 unmodified lines
30	(pattern(r"!foo.html", Mode::NO_SUB_DIR, None), vec![set("x")], 8),	30	(pattern(r"!foo.html", Mode::NO_SUB_DIR, None), vec![set("x")], 8),
31	(pattern(r"#a/path", Mode::empty(), None), vec![unset("a")], 10),	31	(pattern(r"#a/path", Mode::empty(), None), vec![unset("a")], 10),
32	(	32	(
33	pattern(r"/*", Mode::ABSOLUTE \| Mode::NO_SUB_DIR \| Mode::ENDS_WITH, Some(1)),	33	pattern(r"*", Mode::ABSOLUTE \| Mode::NO_SUB_DIR \| Mode::ENDS_WITH, Some(0)),
34	vec![unspecified("b")],	34	vec![unspecified("b")],
35	11	35	11
36	),	36	),
@@ -249,22 +249,22 @@ fn trailing_whitespace_in_attributes_is_ignored() { · 212 unmodified lines
249	);	249	);
250	}	250	}
251		251
252	type ExpandedAttribute<'a> = (parse::Kind, Vec<(&'a BStr, git_attributes::State<'a>)>, usize);	252	type ExpandedAttribute<'a> = (parse::Kind, Vec<(&'a BStr, git_attributes::StateRef<'a>)>, usize);
253		253
254	fn set(attr: &str) -> (&BStr, State) {	254	fn set(attr: &str) -> (&BStr, StateRef) {
255	(attr.as_bytes().as_bstr(), State::Set)	255	(attr.as_bytes().as_bstr(), StateRef::Set)
256	}	256	}
257		257
258	fn unset(attr: &str) -> (&BStr, State) {	258	fn unset(attr: &str) -> (&BStr, StateRef) {
259	(attr.as_bytes().as_bstr(), State::Unset)	259	(attr.as_bytes().as_bstr(), StateRef::Unset)
260	}	260	}
261		261
262	fn unspecified(attr: &str) -> (&BStr, State) {	262	fn unspecified(attr: &str) -> (&BStr, StateRef) {
263	(attr.as_bytes().as_bstr(), State::Unspecified)	263	(attr.as_bytes().as_bstr(), StateRef::Unspecified)
264	}	264	}
265		265
266	fn value<'a, 'b>(attr: &'a str, value: &'b str) -> (&'a BStr, State<'b>) {	266	fn value<'a, 'b>(attr: &'a str, value: &'b str) -> (&'a BStr, StateRef<'b>) {
267	(attr.as_bytes().as_bstr(), State::Value(value.as_bytes().as_bstr()))	267	(attr.as_bytes().as_bstr(), StateRef::Value(value.as_bytes().as_bstr()))
268	}	268	}
269		269
270	fn pattern(name: &str, flags: git_glob::pattern::Mode, first_wildcard_pos: Option<usize>) -> parse::Kind {	270	fn pattern(name: &str, flags: git_glob::pattern::Mode, first_wildcard_pos: Option<usize>) -> parse::Kind {

git-attributes/tests/parse/ignore.rs+4−4

@@ -20,10 +20,10 @@ fn line_numbers_are_counted_correctly() { · 19 unmodified lines
20	("*.[oa]".into(), Mode::NO_SUB_DIR, 2),	20	("*.[oa]".into(), Mode::NO_SUB_DIR, 2),
21	("*.html".into(), Mode::NO_SUB_DIR \| Mode::ENDS_WITH, 5),	21	("*.html".into(), Mode::NO_SUB_DIR \| Mode::ENDS_WITH, 5),
22	("foo.html".into(), Mode::NO_SUB_DIR \| Mode::NEGATIVE, 8),	22	("foo.html".into(), Mode::NO_SUB_DIR \| Mode::NEGATIVE, 8),
23	("/*".into(), Mode::NO_SUB_DIR \| Mode::ENDS_WITH \| Mode::ABSOLUTE, 11),	23	("*".into(), Mode::NO_SUB_DIR \| Mode::ENDS_WITH \| Mode::ABSOLUTE, 11),
24	("/foo".into(), Mode::NEGATIVE \| Mode::NO_SUB_DIR \| Mode::ABSOLUTE, 12),	24	("foo".into(), Mode::NEGATIVE \| Mode::NO_SUB_DIR \| Mode::ABSOLUTE, 12),
25	("/foo/*".into(), Mode::ABSOLUTE, 13),	25	("foo/*".into(), Mode::ABSOLUTE, 13),
26	("/foo/bar".into(), Mode::ABSOLUTE \| Mode::NEGATIVE, 14)	26	("foo/bar".into(), Mode::ABSOLUTE \| Mode::NEGATIVE, 14)
27	]	27	]
28	);	28	);
29	}	29	}

git-config/Cargo.toml+2−1

 [dependencies]
 git-features = { version = "^0.20.0", path = "../git-features"}
+git-path = { version = "^0.1.0", path = "../git-path" }
 git-sec = { version = "^0.1.0", path = "../git-sec" }
 dirs = "4"
 memchr = "2"
 serde_crate = { version = "1", package = "serde", optional = true }
 pwd = "1.3.1"
-quick-error = "2.0.0"
+thiserror = "1.0.26"
 unicode-bom = "1.1.4"
 bstr = { version = "0.2.13", default-features = false, features = ["std"] }

git-config/src/file/error.rs+0−35

@@ -1,35 +0,0 @@
1	use std::{error::Error, fmt::Display};
2
3	use crate::parser::SectionHeaderName;
4	// TODO Consider replacing with quick_error
5	/// All possible error types that may occur from interacting with
6	/// [`GitConfig`](super::GitConfig).
7	#[allow(clippy::module_name_repetitions)]
8	#[derive(PartialEq, Eq, Hash, Clone, PartialOrd, Ord, Debug)]
9	pub enum GitConfigError<'a> {
10	/// The requested section does not exist.
11	SectionDoesNotExist(SectionHeaderName<'a>),
12	/// The requested subsection does not exist.
13	SubSectionDoesNotExist(Option<&'a str>),
14	/// The key does not exist in the requested section.
15	KeyDoesNotExist,
16	/// The conversion into the provided type for methods such as
17	/// [`GitConfig::value`](super::GitConfig::value) failed.
18	FailedConversion,
19	}
20
21	impl Display for GitConfigError<'_> {
22	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
23	match self {
24	Self::SectionDoesNotExist(s) => write!(f, "Section '{}' does not exist.", s),
25	Self::SubSectionDoesNotExist(s) => match s {
26	Some(s) => write!(f, "Subsection '{}' does not exist.", s),
27	None => write!(f, "Top level section does not exist."),
28	},
29	Self::KeyDoesNotExist => write!(f, "The name for a value provided does not exist."),
30	Self::FailedConversion => write!(f, "Failed to convert to specified type."),
31	}
32	}
33	}
34
35	impl Error for GitConfigError<'_> {}

git-config/src/file/git_config.rs+191−171

+use bstr::BStr;
 use std::{
     borrow::Cow,
     collections::{HashMap, VecDeque},
 use crate::{
     file::{
-        error::GitConfigError,
         section::{MutableSection, SectionBody},
         value::{EntryData, MutableMultiValue, MutableValue},
         Index, Size,
     },
-    parser,
+    lookup, parser,
     parser::{
         parse_from_bytes, parse_from_path, parse_from_str, Error, Event, Key, ParsedSectionHeader, Parser,
         SectionHeaderName,
     },
-    values,
+    value, values,
 };
 /// The section ID is a monotonically increasing ID used to refer to sections.
 ///
 /// `git` is flexible enough to allow users to set a key multiple times in
 /// any number of identically named sections. When this is the case, the key
-/// is known as a "multivar". In this case, `get_raw_value` follows the
+/// is known as a "multivar". In this case, `raw_value` follows the
 /// "last one wins" approach that `git-config` internally uses for multivar
 /// resolution.
 ///
 ///     e = f g h
 /// ```
 ///
-/// Calling methods that fetch or set only one value (such as [`get_raw_value`])
+/// Calling methods that fetch or set only one value (such as [`raw_value`])
 /// key `a` with the above config will fetch `d` or replace `d`, since the last
 /// valid config key/value pair is `a = d`:
 ///
 /// # use std::borrow::Cow;
 /// # use std::convert::TryFrom;
 /// # let git_config = GitConfig::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
-/// assert_eq!(git_config.get_raw_value("core", None, "a"), Ok(Cow::Borrowed("d".as_bytes())));
+/// assert_eq!(git_config.raw_value("core", None, "a").unwrap(), Cow::Borrowed("d".as_bytes()));
 /// ```
 ///
 /// Consider the `multi` variants of the methods instead, if you want to work
 /// with all values instead.
 ///
 /// [`ResolvedGitConfig`]: crate::file::ResolvedGitConfig
-/// [`get_raw_value`]: Self::get_raw_value
+/// [`raw_value`]: Self::raw_value
 #[derive(PartialEq, Eq, Clone, Debug, Default)]
 pub struct GitConfig<'event> {
     /// The list of events that occur before an actual section. Since a
 pub mod from_paths {
     use std::borrow::Cow;
-    use quick_error::quick_error;
     use crate::{parser, values::path::interpolate};
-    quick_error! {
+    /// The error returned by [`GitConfig::from_paths()`][super::GitConfig::from_paths()] and [`GitConfig::from_env_paths()`][super::GitConfig::from_env_paths()].
-        #[derive(Debug)]
+    #[derive(Debug, thiserror::Error)]
-        /// The error returned by [`GitConfig::from_paths()`][super::GitConfig::from_paths()] and [`GitConfig::from_env_paths()`][super::GitConfig::from_env_paths()].
+    #[allow(missing_docs)]
-        #[allow(missing_docs)]
+    pub enum Error {
-        pub enum Error {
+        #[error(transparent)]
-            ParserOrIoError(err: parser::ParserOrIoError<'static>) {
+        ParserOrIoError(#[from] parser::ParserOrIoError<'static>),
-                display("Could not read config")
+        #[error(transparent)]
-                source(err)
+        Interpolate(#[from] interpolate::Error),
-                from()
+        #[error("The maximum allowed length {} of the file include chain built by following nested includes is exceeded", .max_depth)]
-            }
+        IncludeDepthExceeded { max_depth: u8 },
-            Interpolate(err: interpolate::Error) {
+        #[error("Include paths from environment variables must not be relative")]
-                display("Could not interpolate path")
+        MissingConfigPath,
-                source(err)
-                from()
-            }
-            IncludeDepthExceeded { max_depth: u8 } {
-                display("The maximum allowed length {} of the file include chain built by following nested includes is exceeded", max_depth)
-            }
-            MissingConfigPath {
-                display("Include paths from environment variables must not be relative.")
-            }
-        }
     }
     /// Options when loading git config using [`GitConfig::from_paths()`][super::GitConfig::from_paths()].
 }
 pub mod from_env {
-    use quick_error::quick_error;
     use super::from_paths;
     use crate::values::path::interpolate;
-    quick_error! {
+    /// Represents the errors that may occur when calling [`GitConfig::from_env`][crate::file::GitConfig::from_env()].
-        #[derive(Debug)]
+    #[derive(Debug, thiserror::Error)]
-        /// Represents the errors that may occur when calling [`GitConfig::from_env`][crate::file::GitConfig::from_env()].
+    #[allow(missing_docs)]
-        #[allow(missing_docs)]
+    pub enum Error {
-        pub enum Error {
+        #[error("GIT_CONFIG_COUNT was not a positive integer: {}", .input)]
-            ParseError (err: String) {
+        ParseError { input: String },
-                display("GIT_CONFIG_COUNT was not a positive integer: {}", err)
+        #[error("GIT_CONFIG_KEY_{} was not set", .key_id)]
-            }
+        InvalidKeyId { key_id: usize },
-            InvalidKeyId (key_id: usize) {
+        #[error("GIT_CONFIG_KEY_{} was set to an invalid value: {}", .key_id, .key_val)]
-                display("GIT_CONFIG_KEY_{} was not set.", key_id)
+        InvalidKeyValue { key_id: usize, key_val: String },
-            }
+        #[error("GIT_CONFIG_VALUE_{} was not set", .value_id)]
-            InvalidKeyValue (key_id: usize, key_val: String) {
+        InvalidValueId { value_id: usize },
-                display("GIT_CONFIG_KEY_{} was set to an invalid value: {}", key_id, key_val)
+        #[error(transparent)]
-            }
+        PathInterpolationError(#[from] interpolate::Error),
-            InvalidValueId (value_id: usize) {
+        #[error(transparent)]
-                display("GIT_CONFIG_VALUE_{} was not set.", value_id)
+        FromPathsError(#[from] from_paths::Error),
-            }
-            PathInterpolationError (err: interpolate::Error) {
-                display("Could not interpolate path while loading a config file.")
-                source(err)
-                from()
-            }
-            FromPathsError (err: from_paths::Error) {
-                display("Could not load config from a file")
-                source(err)
-                from()
-            }
-        }
     }
 }
 impl<'event> GitConfig<'event> {
     /// Constructs an empty `git-config` file.
-    #[inline]
     #[must_use]
     pub fn new() -> Self {
         Self::default()
     ///
     /// Returns an error if there was an IO error or if the file wasn't a valid
     /// git-config file.
-    #[inline]
     pub fn open<P: AsRef<Path>>(path: P) -> Result<Self, parser::ParserOrIoError<'static>> {
         parse_from_path(path).map(Self::from)
     }
     /// git-config file.
     ///
     /// [`git-config`'s documentation]: https://git-scm.com/docs/git-config#Documentation/git-config.txt-FILES
-    #[inline]
     pub fn from_paths(paths: Vec<PathBuf>, options: &from_paths::Options) -> Result<Self, from_paths::Error> {
         let mut target = Self::new();
         for path in paths {
     pub fn from_env(options: &from_paths::Options) -> Result<Option<Self>, from_env::Error> {
         use std::env;
         let count: usize = match env::var("GIT_CONFIG_COUNT") {
-            Ok(v) => v.parse().map_err(|_| from_env::Error::ParseError(v))?,
+            Ok(v) => v.parse().map_err(|_| from_env::Error::ParseError { input: v })?,
             Err(_) => return Ok(None),
         };
         let mut config = Self::new();
         for i in 0..count {
-            let key = env::var(format!("GIT_CONFIG_KEY_{}", i)).map_err(|_| from_env::Error::InvalidKeyId(i))?;
+            let key =
-            let value = env::var(format!("GIT_CONFIG_VALUE_{}", i)).map_err(|_| from_env::Error::InvalidValueId(i))?;
+                env::var(format!("GIT_CONFIG_KEY_{}", i)).map_err(|_| from_env::Error::InvalidKeyId { key_id: i })?;
+            let value = env::var(format!("GIT_CONFIG_VALUE_{}", i))
+                .map_err(|_| from_env::Error::InvalidValueId { value_id: i })?;
             if let Some((section_name, maybe_subsection)) = key.split_once('.') {
                 let (subsection, key) = if let Some((subsection, key)) = maybe_subsection.rsplit_once('.') {
                     (Some(subsection), key)
                     Cow::Owned(value.into_bytes()),
                 );
             } else {
-                return Err(from_env::Error::InvalidKeyValue(i, key.to_string()));
+                return Err(from_env::Error::InvalidKeyValue {
+                    key_id: i,
+                    key_val: key.to_string(),
+                });
             }
         }
     /// # Examples
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use git_config::values::{Integer, Boolean};
     /// # use std::borrow::Cow;
     /// # use std::convert::TryFrom;
     ///
     /// [`values`]: crate::values
     /// [`TryFrom`]: std::convert::TryFrom
-    #[inline]
+    pub fn value<T: TryFrom<Cow<'event, [u8]>>>(
-    pub fn value<'lookup, T: TryFrom<Cow<'event, [u8]>>>(
         &'event self,
-        section_name: &'lookup str,
+        section_name: &str,
-        subsection_name: Option<&'lookup str>,
+        subsection_name: Option<&str>,
-        key: &'lookup str,
+        key: &str,
-    ) -> Result<T, GitConfigError<'lookup>> {
+    ) -> Result<T, lookup::Error<T::Error>> {
-        T::try_from(self.get_raw_value(section_name, subsection_name, key)?)
+        T::try_from(self.raw_value(section_name, subsection_name, key)?).map_err(lookup::Error::FailedConversion)
-            .map_err(|_| GitConfigError::FailedConversion)
+    }
+    /// Like [`value()`][GitConfig::value()], but returning an `Option` if the value wasn't found.
+    pub fn try_value<T: TryFrom<Cow<'event, [u8]>>>(
+        &'event self,
+        section_name: &str,
+        subsection_name: Option<&str>,
+        key: &str,
+    ) -> Option<Result<T, T::Error>> {
+        self.raw_value(section_name, subsection_name, key).ok().map(T::try_from)
+    }
+    /// Like [`value()`][GitConfig::value()], but returning an `Option` if the string wasn't found.
+    ///
+    /// As strings perform no conversions, this will never fail.
+    pub fn string(
+        &'event self,
+        section_name: &str,
+        subsection_name: Option<&str>,
+        key: &str,
+    ) -> Option<Cow<'event, BStr>> {
+        self.raw_value(section_name, subsection_name, key)
+            .ok()
+            .map(|v| values::String::from(v).value)
+    }
+    /// Like [`value()`][GitConfig::value()], but returning an `Option` if the path wasn't found.
+    ///
+    /// Note that this path is not vetted and should only point to resources which can't be used
+    /// to pose a security risk.
+    ///
+    /// As paths perform no conversions, this will never fail.
+    // TODO: add `secure_path()` or similar to make use of our knowledge of the trust associated with each configuration
+    //       file, maybe even remove the insecure version to force every caller to ask themselves if the resource can
+    //       be used securely or not.
+    pub fn path(
+        &'event self,
+        section_name: &str,
+        subsection_name: Option<&str>,
+        key: &str,
+    ) -> Option<values::Path<'event>> {
+        self.raw_value(section_name, subsection_name, key)
+            .ok()
+            .map(values::Path::from)
+    }
+    /// Like [`value()`][GitConfig::value()], but returning an `Option` if the boolean wasn't found.
+    pub fn boolean(
+        &'event self,
+        section_name: &str,
+        subsection_name: Option<&str>,
+        key: &str,
+    ) -> Option<Result<bool, value::parse::Error>> {
+        self.raw_value(section_name, subsection_name, key)
+            .ok()
+            .map(|v| values::Boolean::try_from(v).map(|b| b.to_bool()))
     }
     /// Returns all interpreted values given a section, an optional subsection
     /// # Examples
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use git_config::values::{Integer, Bytes, Boolean, TrueVariant};
     /// # use std::borrow::Cow;
     /// # use std::convert::TryFrom;
     /// // ... or explicitly declare the type to avoid the turbofish
     /// let c_value: Vec<Bytes> = git_config.multi_value("core", None, "c")?;
     /// assert_eq!(c_value, vec![Bytes { value: Cow::Borrowed(b"g") }]);
-    /// # Ok::<(), GitConfigError>(())
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
     ///
     /// # Errors
     ///
     /// [`values`]: crate::values
     /// [`TryFrom`]: std::convert::TryFrom
-    #[inline]
     pub fn multi_value<'lookup, T: TryFrom<Cow<'event, [u8]>>>(
         &'event self,
         section_name: &'lookup str,
         subsection_name: Option<&'lookup str>,
         key: &'lookup str,
-    ) -> Result<Vec<T>, GitConfigError<'lookup>> {
+    ) -> Result<Vec<T>, lookup::Error<T::Error>> {
-        self.get_raw_multi_value(section_name, subsection_name, key)?
+        self.raw_multi_value(section_name, subsection_name, key)?
             .into_iter()
             .map(T::try_from)
             .collect::<Result<Vec<_>, _>>()
-            .map_err(|_| GitConfigError::FailedConversion)
+            .map_err(lookup::Error::FailedConversion)
     }
     /// Returns an immutable section reference.
         &mut self,
         section_name: &'lookup str,
         subsection_name: Option<&'lookup str>,
-    ) -> Result<&SectionBody<'event>, GitConfigError<'lookup>> {
+    ) -> Result<&SectionBody<'event>, lookup::existing::Error> {
-        let section_ids = self.get_section_ids_by_name_and_subname(section_name, subsection_name)?;
+        let section_ids = self.section_ids_by_name_and_subname(section_name, subsection_name)?;
-        let id = section_ids
+        let id = section_ids.last().expect("BUG: Section lookup vec was empty");
-            .last()
+        Ok(self.sections.get(id).expect("BUG: Section did not have id from lookup"))
-            .expect("Section lookup vec was empty, internal invariant violated");
-        Ok(self
-            .sections
-            .get(id)
-            .expect("Section did not have id from lookup, internal invariant violated"))
     }
     /// Returns an mutable section reference.
         &mut self,
         section_name: &'lookup str,
         subsection_name: Option<&'lookup str>,
-    ) -> Result<MutableSection<'_, 'event>, GitConfigError<'lookup>> {
+    ) -> Result<MutableSection<'_, 'event>, lookup::existing::Error> {
-        let section_ids = self.get_section_ids_by_name_and_subname(section_name, subsection_name)?;
+        let section_ids = self.section_ids_by_name_and_subname(section_name, subsection_name)?;
-        let id = section_ids
+        let id = section_ids.last().expect("BUG: Section lookup vec was empty");
-            .last()
+        Ok(MutableSection::new(
-            .expect("Section lookup vec was empty, internal invariant violated");
+            self.sections
-        Ok(MutableSection::new(self.sections.get_mut(id).expect(
+                .get_mut(id)
-            "Section did not have id from lookup, internal invariant violated",
+                .expect("BUG: Section did not have id from lookup"),
-        )))
+        ))
     }
     /// Gets all sections that match the provided name, ignoring any subsections.
     /// Calling this method will yield all sections:
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use git_config::values::{Integer, Boolean, TrueVariant};
     /// # use std::borrow::Cow;
     /// # use std::convert::TryFrom;
     /// ```
     #[must_use]
     pub fn sections_by_name<'lookup>(&self, section_name: &'lookup str) -> Vec<&SectionBody<'event>> {
-        self.get_section_ids_by_name(section_name)
+        self.section_ids_by_name(section_name)
             .unwrap_or_default()
             .into_iter()
             .map(|id| {
     /// Calling this method will yield all section bodies and their header:
     ///
     /// ```rust
-    /// use git_config::file::{GitConfig, GitConfigError};
+    /// use git_config::file::{GitConfig};
     /// use git_config::parser::Key;
     /// use std::borrow::Cow;
     /// use std::convert::TryFrom;
         &self,
         section_name: &'lookup str,
     ) -> Vec<(&ParsedSectionHeader<'event>, &SectionBody<'event>)> {
-        self.get_section_ids_by_name(section_name)
+        self.section_ids_by_name(section_name)
             .unwrap_or_default()
             .into_iter()
             .map(|id| {
     /// Creating a new empty section:
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use std::convert::TryFrom;
     /// let mut git_config = GitConfig::new();
     /// let _section = git_config.new_section("hello", Some("world".into()));
     /// Creating a new empty section and adding values to it:
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use std::convert::TryFrom;
     /// let mut git_config = GitConfig::new();
     /// let mut section = git_config.new_section("hello", Some("world".into()));
     /// Creating and removing a section:
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use std::convert::TryFrom;
     /// let mut git_config = GitConfig::try_from(
     /// r#"[hello "world"]
     /// Precedence example for removing sections with the same name:
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use std::convert::TryFrom;
     /// let mut git_config = GitConfig::try_from(
     /// r#"[hello "world"]
         subsection_name: impl Into<Option<&'lookup str>>,
     ) -> Option<SectionBody> {
         let id = self
-            .get_section_ids_by_name_and_subname(section_name, subsection_name.into())
+            .section_ids_by_name_and_subname(section_name, subsection_name.into())
             .ok()?
             .pop()?;
         self.section_order.remove(
         subsection_name: impl Into<Option<&'lookup str>>,
         new_section_name: impl Into<SectionHeaderName<'event>>,
         new_subsection_name: impl Into<Option<Cow<'event, str>>>,
-    ) -> Result<(), GitConfigError<'lookup>> {
+    ) -> Result<(), lookup::existing::Error> {
-        let id = self.get_section_ids_by_name_and_subname(section_name, subsection_name.into())?;
+        let id = self.section_ids_by_name_and_subname(section_name, subsection_name.into())?;
         let id = id
             .last()
             .expect("list of sections were empty, which violates invariant");
     /// Returns an uninterpreted value given a section, an optional subsection
     /// and key.
     ///
-    /// Consider [`Self::get_raw_multi_value`] if you want to get all values of
+    /// Consider [`Self::raw_multi_value`] if you want to get all values of
     /// a multivar instead.
     ///
     /// # Errors
     ///
     /// This function will return an error if the key is not in the requested
     /// section and subsection, or if the section and subsection do not exist.
-    pub fn get_raw_value<'lookup>(
+    pub fn raw_value<'lookup>(
         &self,
         section_name: &'lookup str,
         subsection_name: Option<&'lookup str>,
         key: &'lookup str,
-    ) -> Result<Cow<'_, [u8]>, GitConfigError<'lookup>> {
+    ) -> Result<Cow<'_, [u8]>, lookup::existing::Error> {
         // Note: cannot wrap around the raw_multi_value method because we need
         // to guarantee that the highest section id is used (so that we follow
         // the "last one wins" resolution strategy by `git-config`).
         let key = Key(key.into());
         for section_id in self
-            .get_section_ids_by_name_and_subname(section_name, subsection_name)?
+            .section_ids_by_name_and_subname(section_name, subsection_name)?
             .iter()
             .rev()
         {
             }
         }
-        Err(GitConfigError::KeyDoesNotExist)
+        Err(lookup::existing::Error::KeyMissing)
     }
     /// Returns a mutable reference to an uninterpreted value given a section,
     /// an optional subsection and key.
     ///
-    /// Consider [`Self::get_raw_multi_value_mut`] if you want to get mutable
+    /// Consider [`Self::raw_multi_value_mut`] if you want to get mutable
     /// references to all values of a multivar instead.
     ///
     /// # Errors
     ///
     /// This function will return an error if the key is not in the requested
     /// section and subsection, or if the section and subsection do not exist.
-    pub fn get_raw_value_mut<'lookup>(
+    pub fn raw_value_mut<'lookup>(
         &mut self,
         section_name: &'lookup str,
         subsection_name: Option<&'lookup str>,
         key: &'lookup str,
-    ) -> Result<MutableValue<'_, 'lookup, 'event>, GitConfigError<'lookup>> {
+    ) -> Result<MutableValue<'_, 'lookup, 'event>, lookup::existing::Error> {
-        let section_ids = self.get_section_ids_by_name_and_subname(section_name, subsection_name)?;
+        let section_ids = self.section_ids_by_name_and_subname(section_name, subsection_name)?;
         let key = Key(key.into());
         for section_id in section_ids.iter().rev() {
             ));
         }
-        Err(GitConfigError::KeyDoesNotExist)
+        Err(lookup::existing::Error::KeyMissing)
     }
     /// Returns all uninterpreted values given a section, an optional subsection
     /// # use std::convert::TryFrom;
     /// # let git_config = GitConfig::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
     /// assert_eq!(
-    ///     git_config.get_raw_multi_value("core", None, "a"),
+    ///     git_config.raw_multi_value("core", None, "a").unwrap(),
-    ///     Ok(vec![
+    ///     vec![
     ///         Cow::<[u8]>::Borrowed(b"b"),
     ///         Cow::<[u8]>::Borrowed(b"c"),
     ///         Cow::<[u8]>::Borrowed(b"d"),
-    ///     ]),
+    ///     ],
     /// );
     /// ```
     ///
-    /// Consider [`Self::get_raw_value`] if you want to get the resolved single
+    /// Consider [`Self::raw_value`] if you want to get the resolved single
     /// value for a given key, if your key does not support multi-valued values.
     ///
     /// # Errors
     /// This function will return an error if the key is not in any requested
     /// section and subsection, or if no instance of the section and subsections
     /// exist.
-    pub fn get_raw_multi_value<'lookup>(
+    pub fn raw_multi_value(
         &self,
-        section_name: &'lookup str,
+        section_name: &str,
-        subsection_name: Option<&'lookup str>,
+        subsection_name: Option<&str>,
-        key: &'lookup str,
+        key: &str,
-    ) -> Result<Vec<Cow<'_, [u8]>>, GitConfigError<'lookup>> {
+    ) -> Result<Vec<Cow<'_, [u8]>>, lookup::existing::Error> {
         let mut values = vec![];
-        for section_id in self.get_section_ids_by_name_and_subname(section_name, subsection_name)? {
+        for section_id in self.section_ids_by_name_and_subname(section_name, subsection_name)? {
             values.extend(
                 self.sections
                     .get(&section_id)
         }
         if values.is_empty() {
-            Err(GitConfigError::KeyDoesNotExist)
+            Err(lookup::existing::Error::KeyMissing)
         } else {
             Ok(values)
         }
     /// Attempting to get all values of `a` yields the following:
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use std::borrow::Cow;
     /// # use std::convert::TryFrom;
     /// # let mut git_config = GitConfig::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
     /// assert_eq!(
-    ///     git_config.get_raw_multi_value("core", None, "a")?,
+    ///     git_config.raw_multi_value("core", None, "a")?,
     ///     vec![
     ///         Cow::Borrowed(b"b"),
     ///         Cow::Borrowed(b"c"),
     ///     ]
     /// );
     ///
-    /// git_config.get_raw_multi_value_mut("core", None, "a")?.set_str_all("g");
+    /// git_config.raw_multi_value_mut("core", None, "a")?.set_str_all("g");
     ///
     /// assert_eq!(
-    ///     git_config.get_raw_multi_value("core", None, "a")?,
+    ///     git_config.raw_multi_value("core", None, "a")?,
     ///     vec![
     ///         Cow::Borrowed(b"g"),
     ///         Cow::Borrowed(b"g"),
     ///         Cow::Borrowed(b"g")
     ///     ],
     /// );
-    /// # Ok::<(), GitConfigError>(())
+    /// # Ok::<(), git_config::lookup::existing::Error>(())
     /// ```
     ///
-    /// Consider [`Self::get_raw_value`] if you want to get the resolved single
+    /// Consider [`Self::raw_value`] if you want to get the resolved single
     /// value for a given key, if your key does not support multi-valued values.
     ///
     /// Note that this operation is relatively expensive, requiring a full
     /// This function will return an error if the key is not in any requested
     /// section and subsection, or if no instance of the section and subsections
     /// exist.
-    pub fn get_raw_multi_value_mut<'lookup>(
+    pub fn raw_multi_value_mut<'lookup>(
         &mut self,
         section_name: &'lookup str,
         subsection_name: Option<&'lookup str>,
         key: &'lookup str,
-    ) -> Result<MutableMultiValue<'_, 'lookup, 'event>, GitConfigError<'lookup>> {
+    ) -> Result<MutableMultiValue<'_, 'lookup, 'event>, lookup::existing::Error> {
-        let section_ids = self.get_section_ids_by_name_and_subname(section_name, subsection_name)?;
+        let section_ids = self.section_ids_by_name_and_subname(section_name, subsection_name)?;
         let key = Key(key.into());
         let mut offsets = HashMap::new();
         entries.sort();
         if entries.is_empty() {
-            Err(GitConfigError::KeyDoesNotExist)
+            Err(lookup::existing::Error::KeyMissing)
         } else {
             Ok(MutableMultiValue::new(&mut self.sections, key, entries, offsets))
         }
     /// Setting a new value to the key `core.a` will yield the following:
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use std::borrow::Cow;
     /// # use std::convert::TryFrom;
     /// # let mut git_config = GitConfig::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
     /// git_config.set_raw_value("core", None, "a", vec![b'e'])?;
-    /// assert_eq!(git_config.get_raw_value("core", None, "a")?, Cow::Borrowed(b"e"));
+    /// assert_eq!(git_config.raw_value("core", None, "a")?, Cow::Borrowed(b"e"));
-    /// # Ok::<(), GitConfigError>(())
+    /// # Ok::<(), Box<dyn std::error::Error>>(())
     /// ```
     ///
     /// # Errors
         subsection_name: Option<&'lookup str>,
         key: &'lookup str,
         new_value: Vec<u8>,
-    ) -> Result<(), GitConfigError<'lookup>> {
+    ) -> Result<(), lookup::existing::Error> {
-        self.get_raw_value_mut(section_name, subsection_name, key)
+        self.raw_value_mut(section_name, subsection_name, key)
             .map(|mut entry| entry.set_bytes(new_value))
     }
     ///
     /// **Note**: Mutation order is _not_ guaranteed and is non-deterministic.
     /// If you need finer control over which values of the multivar are set,
-    /// consider using [`get_raw_multi_value_mut`], which will let you iterate
+    /// consider using [`raw_multi_value_mut`], which will let you iterate
     /// and check over the values instead. This is best used as a convenience
     /// function for setting multivars whose values should be treated as an
     /// unordered set.
     /// Setting an equal number of values:
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use std::borrow::Cow;
     /// # use std::convert::TryFrom;
     /// # let mut git_config = GitConfig::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
     ///     Cow::Borrowed(b"z"),
     /// ];
     /// git_config.set_raw_multi_value("core", None, "a", new_values.into_iter())?;
-    /// let fetched_config = git_config.get_raw_multi_value("core", None, "a")?;
+    /// let fetched_config = git_config.raw_multi_value("core", None, "a")?;
     /// assert!(fetched_config.contains(&Cow::Borrowed(b"x")));
     /// assert!(fetched_config.contains(&Cow::Borrowed(b"y")));
     /// assert!(fetched_config.contains(&Cow::Borrowed(b"z")));
-    /// # Ok::<(), GitConfigError>(())
+    /// # Ok::<(), git_config::lookup::existing::Error>(())
     /// ```
     ///
     /// Setting less than the number of present values sets the first ones found:
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use std::borrow::Cow;
     /// # use std::convert::TryFrom;
     /// # let mut git_config = GitConfig::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
     ///     Cow::Borrowed(b"y"),
     /// ];
     /// git_config.set_raw_multi_value("core", None, "a", new_values.into_iter())?;
-    /// let fetched_config = git_config.get_raw_multi_value("core", None, "a")?;
+    /// let fetched_config = git_config.raw_multi_value("core", None, "a")?;
     /// assert!(fetched_config.contains(&Cow::Borrowed(b"x")));
     /// assert!(fetched_config.contains(&Cow::Borrowed(b"y")));
-    /// # Ok::<(), GitConfigError>(())
+    /// # Ok::<(), git_config::lookup::existing::Error>(())
     /// ```
     ///
     /// Setting more than the number of present values discards the rest:
     ///
     /// ```
-    /// # use git_config::file::{GitConfig, GitConfigError};
+    /// # use git_config::file::{GitConfig};
     /// # use std::borrow::Cow;
     /// # use std::convert::TryFrom;
     /// # let mut git_config = GitConfig::try_from("[core]a=b\n[core]\na=c\na=d").unwrap();
     ///     Cow::Borrowed(b"discarded"),
     /// ];
     /// git_config.set_raw_multi_value("core", None, "a", new_values.into_iter())?;
-    /// assert!(!git_config.get_raw_multi_value("core", None, "a")?.contains(&Cow::Borrowed(b"discarded")));
+    /// assert!(!git_config.raw_multi_value("core", None, "a")?.contains(&Cow::Borrowed(b"discarded")));
-    /// # Ok::<(), GitConfigError>(())
+    /// # Ok::<(), git_config::lookup::existing::Error>(())
     /// ```
     ///
     /// # Errors
     ///
     /// This errors if any lookup input (section, subsection, and key value) fails.
     ///
-    /// [`get_raw_multi_value_mut`]: Self::get_raw_multi_value_mut
+    /// [`raw_multi_value_mut`]: Self::raw_multi_value_mut
     pub fn set_raw_multi_value<'lookup>(
         &mut self,
         section_name: &'lookup str,
         subsection_name: Option<&'lookup str>,
         key: &'lookup str,
         new_values: impl Iterator<Item = Cow<'event, [u8]>>,
-    ) -> Result<(), GitConfigError<'lookup>> {
+    ) -> Result<(), lookup::existing::Error> {
-        self.get_raw_multi_value_mut(section_name, subsection_name, key)
+        self.raw_multi_value_mut(section_name, subsection_name, key)
             .map(|mut v| v.set_values(new_values))
     }
 }
     }
     /// Returns the mapping between section and subsection name to section ids.
-    fn get_section_ids_by_name_and_subname<'lookup>(
+    fn section_ids_by_name_and_subname<'lookup>(
         &self,
         section_name: impl Into<SectionHeaderName<'lookup>>,
         subsection_name: Option<&'lookup str>,
-    ) -> Result<Vec<SectionId>, GitConfigError<'lookup>> {
+    ) -> Result<Vec<SectionId>, lookup::existing::Error> {
         let section_name = section_name.into();
         let section_ids = self
             .section_lookup_tree
             .get(&section_name)
-            .ok_or(GitConfigError::SectionDoesNotExist(section_name))?;
+            .ok_or(lookup::existing::Error::SectionMissing)?;
         let mut maybe_ids = None;
         // Don't simplify if and matches here -- the for loop currently needs
         // `n + 1` checks, while the if and matches will result in the for loop
         }
         maybe_ids
             .map(Vec::to_owned)
-            .ok_or(GitConfigError::SubSectionDoesNotExist(subsection_name))
+            .ok_or(lookup::existing::Error::SubSectionMissing)
     }
-    fn get_section_ids_by_name<'lookup>(
+    fn section_ids_by_name<'lookup>(
         &self,
         section_name: impl Into<SectionHeaderName<'lookup>>,
-    ) -> Result<Vec<SectionId>, GitConfigError<'lookup>> {
+    ) -> Result<Vec<SectionId>, lookup::existing::Error> {
         let section_name = section_name.into();
         self.section_lookup_tree
             .get(&section_name)
                     })
                     .collect()
             })
-            .ok_or(GitConfigError::SectionDoesNotExist(section_name))
+            .ok_or(lookup::existing::Error::SectionMissing)
     }
 }
     /// [`GitConfig`]. See [`parse_from_str`] for more information.
     ///
     /// [`parse_from_str`]: crate::parser::parse_from_str
-    #[inline]
     fn try_from(s: &'a str) -> Result<GitConfig<'a>, Self::Error> {
         parse_from_str(s).map(Self::from)
     }
     //// a [`GitConfig`]. See [`parse_from_bytes`] for more information.
     ///
     /// [`parse_from_bytes`]: crate::parser::parse_from_bytes
-    #[inline]
     fn try_from(value: &'a [u8]) -> Result<GitConfig<'a>, Self::Error> {
         parse_from_bytes(value).map(GitConfig::from)
     }
     //// a [`GitConfig`]. See [`parse_from_bytes`] for more information.
     ///
     /// [`parse_from_bytes`]: crate::parser::parse_from_bytes
-    #[inline]
     fn try_from(value: &'a Vec<u8>) -> Result<GitConfig<'a>, Self::Error> {
         parse_from_bytes(value).map(GitConfig::from)
     }
 }
 impl From<GitConfig<'_>> for Vec<u8> {
-    #[inline]
     fn from(c: GitConfig) -> Self {
         c.into()
     }

git-config/src/file/mod.rs+0−2

 //! This module provides a high level wrapper around a single `git-config` file.
-mod error;
 mod git_config;
 mod resolved;
 mod section;
 use std::ops::{Add, AddAssign};
-pub use error::*;
 pub use resolved::*;
 pub use section::*;
 pub use value::*;

git-config/src/file/resolved.rs+0−3

     ///
     /// This returns an error if an IO error occurs, or if the file is not a
     /// valid `git-config` file.
-    #[inline]
     pub fn open<P: AsRef<Path>>(path: P) -> Result<Self, parser::ParserOrIoError<'static>> {
         GitConfig::open(path.as_ref()).map(Self::from)
     }
 impl TryFrom<&Path> for ResolvedGitConfig<'static> {
     type Error = parser::ParserOrIoError<'static>;
-    #[inline]
     fn try_from(path: &Path) -> Result<Self, Self::Error> {
         Self::open(path)
     }
 }
 impl<'data> From<GitConfig<'data>> for ResolvedGitConfig<'data> {
-    #[inline]
     fn from(config: GitConfig<'data>) -> Self {
         Self::from_config(config)
     }

git-config/src/file/section.rs+13−27

 };
 use crate::{
-    file::{error::GitConfigError, Index},
+    file::Index,
+    lookup,
     parser::{Event, Key},
     values::{normalize_cow, normalize_vec},
 };
     /// Returns the previous value if it replaced a value, or None if it adds
     /// the value.
     pub fn set(&mut self, key: Key<'event>, value: Cow<'event, [u8]>) -> Option<Cow<'event, [u8]>> {
-        let range = self.get_value_range_by_key(&key);
+        let range = self.value_range_by_key(&key);
         if range.is_empty() {
             self.push(key, value);
             return None;
     /// Removes the latest value by key and returns it, if it exists.
     pub fn remove(&mut self, key: &Key<'event>) -> Option<Cow<'event, [u8]>> {
-        let range = self.get_value_range_by_key(key);
+        let range = self.value_range_by_key(key);
         if range.is_empty() {
             return None;
         }
     /// Adds a new line event. Note that you don't need to call this unless
     /// you've disabled implicit newlines.
-    #[inline]
     pub fn push_newline(&mut self) {
         self.section.0.push(Event::Newline("\n".into()));
     }
     /// Enables or disables automatically adding newline events after adding
     /// a value. This is enabled by default.
-    #[inline]
     pub fn implicit_newline(&mut self, on: bool) {
         self.implicit_newline = on;
     }
     /// Sets the number of spaces before the start of a key value. By default,
     /// this is set to two. Set to 0 to disable adding whitespace before a key
     /// value.
-    #[inline]
     pub fn set_whitespace(&mut self, num: usize) {
         self.whitespace = num;
     }
     /// Returns the number of whitespace this section will insert before the
     /// beginning of a key.
-    #[inline]
     #[must_use]
     pub const fn whitespace(&self) -> usize {
         self.whitespace
 // Internal methods that may require exact indices for faster operations.
 impl<'borrow, 'event> MutableSection<'borrow, 'event> {
-    #[inline]
     pub(super) fn new(section: &'borrow mut SectionBody<'event>) -> Self {
         Self {
             section,
         key: &Key<'key>,
         start: Index,
         end: Index,
-    ) -> Result<Cow<'_, [u8]>, GitConfigError<'key>> {
+    ) -> Result<Cow<'_, [u8]>, lookup::existing::Error> {
         let mut found_key = false;
         let mut latest_value = None;
         let mut partial_value = None;
         latest_value
             .map(normalize_cow)
             .or_else(|| partial_value.map(normalize_vec))
-            .ok_or(GitConfigError::KeyDoesNotExist)
+            .ok_or(lookup::existing::Error::KeyMissing)
     }
-    #[inline]
     pub(super) fn delete(&mut self, start: Index, end: Index) {
         self.section.0.drain(start.0..=end.0);
     }
 impl<'event> Deref for MutableSection<'_, 'event> {
     type Target = SectionBody<'event>;
-    #[inline]
     fn deref(&self) -> &Self::Target {
         self.section
     }
     }
     /// Constructs a new empty section body.
-    #[inline]
     pub(super) fn new() -> Self {
         Self::default()
     }
     #[allow(clippy::missing_panics_doc)]
     #[must_use]
     pub fn value(&self, key: &Key) -> Option<Cow<'event, [u8]>> {
-        let range = self.get_value_range_by_key(key);
+        let range = self.value_range_by_key(key);
         if range.is_empty() {
             return None;
         }
     /// # Errors
     ///
     /// Returns an error if the key was not found, or if the conversion failed.
-    #[inline]
+    pub fn value_as<T: TryFrom<Cow<'event, [u8]>>>(&self, key: &Key) -> Result<T, lookup::Error<T::Error>> {
-    pub fn value_as<T: TryFrom<Cow<'event, [u8]>>>(&self, key: &Key) -> Result<T, GitConfigError<'event>> {
+        T::try_from(self.value(key).ok_or(lookup::existing::Error::KeyMissing)?)
-        T::try_from(self.value(key).ok_or(GitConfigError::KeyDoesNotExist)?)
+            .map_err(lookup::Error::FailedConversion)
-            .map_err(|_| GitConfigError::FailedConversion)
     }
     /// Retrieves all values that have the provided key name. This may return
     /// # Errors
     ///
     /// Returns an error if the conversion failed.
-    #[inline]
+    pub fn values_as<T: TryFrom<Cow<'event, [u8]>>>(&self, key: &Key) -> Result<Vec<T>, lookup::Error<T::Error>> {
-    pub fn values_as<T: TryFrom<Cow<'event, [u8]>>>(&self, key: &Key) -> Result<Vec<T>, GitConfigError<'event>> {
         self.values(key)
             .into_iter()
             .map(T::try_from)
             .collect::<Result<Vec<T>, _>>()
-            .map_err(|_| GitConfigError::FailedConversion)
+            .map_err(lookup::Error::FailedConversion)
     }
     /// Returns an iterator visiting all keys in order.
-    #[inline]
     pub fn keys(&self) -> impl Iterator<Item = &Key<'event>> {
         self.0
             .iter()
     }
     /// Returns the number of entries in the section.
-    #[inline]
     #[must_use]
     pub fn len(&self) -> usize {
         self.0.iter().filter(|e| matches!(e, Event::Key(_))).count()
     }
     /// Returns if the section is empty.
-    #[inline]
     #[must_use]
     pub fn is_empty(&self) -> bool {
         self.0.is_empty()
     /// Returns the the range containing the value events for the section.
     /// If the value is not found, then this returns an empty range.
-    fn get_value_range_by_key(&self, key: &Key<'event>) -> Range<usize> {
+    fn value_range_by_key(&self, key: &Key<'event>) -> Range<usize> {
         let mut values_start = 0;
         // value end needs to be offset by one so that the last value's index
         // is included in the range
     type IntoIter = SectionBodyIter<'event>;
-    #[inline]
     fn into_iter(self) -> Self::IntoIter {
         SectionBodyIter(self.0.into())
     }
 impl FusedIterator for SectionBodyIter<'_> {}
 impl<'event> From<Vec<Event<'event>>> for SectionBody<'event> {
-    #[inline]
     fn from(e: Vec<Event<'event>>) -> Self {
         Self(e)
     }

git-config/src/file/value.rs+9−21

 use crate::{
     file::{
-        error::GitConfigError,
         git_config::SectionId,
         section::{MutableSection, SectionBody},
         Index, Size,
     },
+    lookup,
     parser::{Event, Key},
     values::{normalize_bytes, normalize_vec},
 };
     /// # Errors
     ///
     /// Returns an error if the lookup failed.
-    #[inline]
+    pub fn get(&self) -> Result<Cow<'_, [u8]>, lookup::existing::Error> {
-    pub fn get(&self) -> Result<Cow<'_, [u8]>, GitConfigError> {
         self.section.get(&self.key, self.index, self.index + self.size)
     }
     /// Update the value to the provided one. This modifies the value such that
     /// the Value event(s) are replaced with a single new event containing the
     /// new value.
-    #[inline]
     pub fn set_string(&mut self, input: String) {
         self.set_bytes(input.into_bytes());
     }
     /// # Errors
     ///
     /// Returns an error if the lookup failed.
-    pub fn get(&self) -> Result<Vec<Cow<'_, [u8]>>, GitConfigError> {
+    pub fn get(&self) -> Result<Vec<Cow<'_, [u8]>>, lookup::existing::Error> {
         let mut found_key = false;
         let mut values = vec![];
         let mut partial_value = None;
             offset_index,
         } in &self.indices_and_sizes
         {
-            let (offset, size) = MutableMultiValue::get_index_and_size(&self.offsets, *section_id, *offset_index);
+            let (offset, size) = MutableMultiValue::index_and_size(&self.offsets, *section_id, *offset_index);
             for event in &self
                 .section
                 .get(section_id)
         }
         if values.is_empty() {
-            return Err(GitConfigError::KeyDoesNotExist);
+            return Err(lookup::existing::Error::KeyMissing);
         }
         Ok(values)
     }
     /// Returns the size of values the multivar has.
-    #[inline]
     #[must_use]
     pub fn len(&self) -> usize {
         self.indices_and_sizes.len()
     /// Returns if the multivar has any values. This might occur if the value
     /// was deleted but not set with a new value.
-    #[inline]
     #[must_use]
     pub fn is_empty(&self) -> bool {
         self.indices_and_sizes.is_empty()
     /// # Safety
     ///
     /// This will panic if the index is out of range.
-    #[inline]
     pub fn set_string(&mut self, index: usize, input: String) {
         self.set_bytes(index, input.into_bytes());
     }
     /// # Safety
     ///
     /// This will panic if the index is out of range.
-    #[inline]
     pub fn set_bytes(&mut self, index: usize, input: Vec<u8>) {
         self.set_value(index, Cow::Owned(input));
     }
     /// remaining values are ignored.
     ///
     /// [`zip`]: std::iter::Iterator::zip
-    #[inline]
     pub fn set_values<'a: 'event>(&mut self, input: impl Iterator<Item = Cow<'a, [u8]>>) {
         for (
             EntryData {
     /// Sets all values in this multivar to the provided one by copying the
     /// input for all values.
-    #[inline]
     pub fn set_str_all(&mut self, input: &str) {
         self.set_owned_values_all(input.as_bytes());
     }
     /// Sets all values in this multivar to the provided one by copying the
     /// input bytes for all values.
-    #[inline]
     pub fn set_owned_values_all(&mut self, input: &[u8]) {
         for EntryData {
             section_id,
     /// need for a more ergonomic interface.
     ///
     /// [`GitConfig`]: super::GitConfig
-    #[inline]
     pub fn set_values_all<'a: 'event>(&mut self, input: &'a [u8]) {
         for EntryData {
             section_id,
         offset_index: usize,
         input: Cow<'a, [u8]>,
     ) {
-        let (offset, size) = MutableMultiValue::get_index_and_size(offsets, section_id, offset_index);
+        let (offset, size) = MutableMultiValue::index_and_size(offsets, section_id, offset_index);
         section.as_mut().drain(offset..offset + size);
         MutableMultiValue::set_offset(offsets, section_id, offset_index, 3);
             section_id,
             offset_index,
         } = &self.indices_and_sizes[index];
-        let (offset, size) = MutableMultiValue::get_index_and_size(&self.offsets, *section_id, *offset_index);
+        let (offset, size) = MutableMultiValue::index_and_size(&self.offsets, *section_id, *offset_index);
         if size > 0 {
             self.section
                 .get_mut(section_id)
             offset_index,
         } in &self.indices_and_sizes
         {
-            let (offset, size) = MutableMultiValue::get_index_and_size(&self.offsets, *section_id, *offset_index);
+            let (offset, size) = MutableMultiValue::index_and_size(&self.offsets, *section_id, *offset_index);
             if size > 0 {
                 self.section
                     .get_mut(section_id)
     // SectionId is the same size as a reference, which means it's just as
     // efficient passing in a value instead of a reference.
-    #[inline]
+    fn index_and_size(
-    fn get_index_and_size(
         offsets: &'lookup HashMap<SectionId, Vec<usize>>,
         section_id: SectionId,
         offset_index: usize,
     //
     // SectionId is the same size as a reference, which means it's just as
     // efficient passing in a value instead of a reference.
-    #[inline]
     fn set_offset(
         offsets: &mut HashMap<SectionId, Vec<usize>>,
         section_id: SectionId,

git-config/src/fs.rs+6−8

     path::{Path, PathBuf},
 };
-use crate::file::{from_paths, GitConfig, GitConfigError};
+use crate::file::{from_paths, GitConfig};
+use crate::lookup;
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
 pub enum ConfigSource {
 impl ConfigBuilder {
     /// Constructs a new builder that finds the default location
-    #[inline]
     #[must_use]
     pub fn new() -> Self {
         Self {
 }
 impl<'config> Config<'config> {
-    #[inline]
     #[must_use]
     pub fn value<T: TryFrom<Cow<'config, [u8]>>>(
         &'config self,
         None
     }
-    #[inline]
     pub fn try_value<'lookup, T: TryFrom<Cow<'config, [u8]>>>(
         &'config self,
         section_name: &'lookup str,
         subsection_name: Option<&'lookup str>,
         key: &'lookup str,
-    ) -> Result<Option<T>, GitConfigError<'lookup>> {
+    ) -> Result<Option<T>, lookup::Error<T::Error>> {
         self.try_value_with_source(section_name, subsection_name, key)
             .map(|res| res.map(|(value, _)| value))
     }
         section_name: &'lookup str,
         subsection_name: Option<&'lookup str>,
         key: &'lookup str,
-    ) -> Result<Option<(T, ConfigSource)>, GitConfigError<'lookup>> {
+    ) -> Result<Option<(T, ConfigSource)>, lookup::Error<T::Error>> {
         let mapping = self.mapping();
         for (conf, source) in mapping.iter() {
     /// Retrieves the underlying [`GitConfig`] object, if one was found during
     /// initialization.
     #[must_use]
-    pub fn get_config(&self, source: ConfigSource) -> Option<&GitConfig<'config>> {
+    pub fn config(&self, source: ConfigSource) -> Option<&GitConfig<'config>> {
         match source {
             ConfigSource::System => self.system_conf.as_ref(),
             ConfigSource::Global => self.global_conf.as_ref(),
     /// Retrieves the underlying [`GitConfig`] object as a mutable reference,
     /// if one was found during initialization.
     #[must_use]
-    pub fn get_config_mut(&mut self, source: ConfigSource) -> Option<&mut GitConfig<'config>> {
+    pub fn config_mut(&mut self, source: ConfigSource) -> Option<&mut GitConfig<'config>> {
         match source {
             ConfigSource::System => self.system_conf.as_mut(),
             ConfigSource::Global => self.global_conf.as_mut(),

git-config/src/lib.rs+57−0

@@ -54,10 +54,67 @@ · 53 unmodified lines
54	#[cfg(feature = "serde")]	54	#[cfg(feature = "serde")]
55	extern crate serde_crate as serde;	55	extern crate serde_crate as serde;
56		56
		57	pub mod lookup {
		58
		59	/// The error when looking up a value.
		60	#[derive(Debug, thiserror::Error)]
		61	pub enum Error<E> {
		62	#[error(transparent)]
		63	ValueMissing(#[from] crate::lookup::existing::Error),
		64	#[error(transparent)]
		65	FailedConversion(E),
		66	}
		67
		68	pub mod existing {
		69	/// The error when looking up a value that doesn't exist.
		70	#[derive(Debug, thiserror::Error)]
		71	pub enum Error {
		72	#[error("The requested section does not exist")]
		73	SectionMissing,
		74	#[error("The requested subsection does not exist")]
		75	SubSectionMissing,
		76	#[error("The key does not exist in the requested section")]
		77	KeyMissing,
		78	}
		79	}
		80	}
		81
57	pub mod file;	82	pub mod file;
58	pub mod fs;	83	pub mod fs;
59	pub mod parser;	84	pub mod parser;
60	pub mod values;	85	pub mod values;
		86	/// The future home of the `values` module (TODO).
		87	pub mod value {
		88	pub mod parse {
		89	use bstr::BString;
		90
		91	/// The error returned when creating `Integer` from byte string.
		92	#[derive(Debug, thiserror::Error, Eq, PartialEq)]
		93	#[allow(missing_docs)]
		94	#[error("Could not decode '{}': {}", .input, .message)]
		95	pub struct Error {
		96	pub message: &'static str,
		97	pub input: BString,
		98	#[source]
		99	pub utf8_err: Option<std::str::Utf8Error>,
		100	}
		101
		102	impl Error {
		103	pub(crate) fn new(message: &'static str, input: impl Into<BString>) -> Self {
		104	Error {
		105	message,
		106	input: input.into(),
		107	utf8_err: None,
		108	}
		109	}
		110
		111	pub(crate) fn with_err(mut self, err: std::str::Utf8Error) -> Self {
		112	self.utf8_err = Some(err);
		113	self
		114	}
		115	}
		116	}
		117	}
61		118
62	mod permissions {	119	mod permissions {
63	use crate::Permissions;	120	use crate::Permissions;

git-config/src/parser.rs+0−36

     /// Generates a byte representation of the value. This should be used when
     /// non-UTF-8 sequences are present or a UTF-8 representation can't be
     /// guaranteed.
-    #[inline]
     #[must_use]
     pub fn to_vec(&self) -> Vec<u8> {
         self.into()
     /// not.
     ///
     /// [`clone`]: Self::clone
-    #[inline]
     #[must_use]
     pub fn to_owned(&self) -> Event<'static> {
         match self {
     /// Note that this is a best-effort attempt at printing an `Event`. If
     /// there are non UTF-8 values in your config, this will _NOT_ render
     /// as read.
-    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Value(e) | Self::ValueNotDone(e) | Self::ValueDone(e) => match std::str::from_utf8(e) {
 }
 impl From<Event<'_>> for Vec<u8> {
-    #[inline]
     fn from(event: Event) -> Self {
         event.into()
     }
 }
 impl From<&Event<'_>> for Vec<u8> {
-    #[inline]
     fn from(event: &Event) -> Self {
         match event {
             Event::Value(e) | Event::ValueNotDone(e) | Event::ValueDone(e) => e.to_vec(),
     /// not.
     ///
     /// [`clone`]: Self::clone
-    #[inline]
     #[must_use]
     pub fn to_owned(&self) -> ParsedSection<'static> {
         ParsedSection {
             /// while `clone` does not.
             ///
             /// [`clone`]: Self::clone
-            #[inline]
             #[must_use]
             pub fn to_owned(&self) -> $name<'static> {
                 $name(Cow::Owned(self.0.clone().into_owned()))
         }
         impl PartialEq for $name<'_> {
-            #[inline]
             fn eq(&self, other: &Self) -> bool {
                 self.0.eq_ignore_ascii_case(&other.0)
             }
         }
         impl Display for $name<'_> {
-            #[inline]
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                 self.0.fmt(f)
             }
         }
         impl PartialOrd for $name<'_> {
-            #[inline]
             fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
                 self.0
                     .to_ascii_lowercase()
         }
         impl std::hash::Hash for $name<'_> {
-            #[inline]
             fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
                 self.0.to_ascii_lowercase().hash(state)
             }
         }
         impl<'a> From<&'a str> for $name<'a> {
-            #[inline]
             fn from(s: &'a str) -> Self {
                 Self(Cow::Borrowed(s))
             }
         }
         impl<'a> From<Cow<'a, str>> for $name<'a> {
-            #[inline]
             fn from(s: Cow<'a, str>) -> Self {
                 Self(s)
             }
         impl<'a> std::ops::Deref for $name<'a> {
             type Target = $cow_inner_type;
-            #[inline]
             fn deref(&self) -> &Self::Target {
                 &self.0
             }
     /// non-UTF-8 sequences are present or a UTF-8 representation can't be
     /// guaranteed.
     #[must_use]
-    #[inline]
     pub fn to_vec(&self) -> Vec<u8> {
         self.into()
     }
     /// not.
     ///
     /// [`clone`]: Self::clone
-    #[inline]
     #[must_use]
     pub fn to_owned(&self) -> ParsedSectionHeader<'static> {
         ParsedSectionHeader {
 }
 impl From<ParsedSectionHeader<'_>> for Vec<u8> {
-    #[inline]
     fn from(header: ParsedSectionHeader) -> Self {
         header.into()
     }
 }
 impl From<&ParsedSectionHeader<'_>> for Vec<u8> {
-    #[inline]
     fn from(header: &ParsedSectionHeader) -> Self {
         header.to_string().into_bytes()
     }
 }
 impl<'a> From<ParsedSectionHeader<'a>> for Event<'a> {
-    #[inline]
     fn from(header: ParsedSectionHeader) -> Event {
         Event::SectionHeader(header)
     }
     /// not.
     ///
     /// [`clone`]: Self::clone
-    #[inline]
     #[must_use]
     pub fn to_owned(&self) -> ParsedComment<'static> {
         ParsedComment {
 }
 impl From<ParsedComment<'_>> for Vec<u8> {
-    #[inline]
     fn from(c: ParsedComment) -> Self {
         c.into()
     }
 }
 impl From<&ParsedComment<'_>> for Vec<u8> {
-    #[inline]
     fn from(c: &ParsedComment) -> Self {
         let mut values = vec![c.comment_tag as u8];
         values.extend(c.comment.iter());
 impl Error<'_> {
     /// The one-indexed line number where the error occurred. This is determined
     /// by the number of newlines that were successfully parsed.
-    #[inline]
     #[must_use]
     pub const fn line_number(&self) -> usize {
         self.line_number + 1
     }
     /// The remaining data that was left unparsed.
-    #[inline]
     #[must_use]
     pub fn remaining_data(&self) -> &[u8] {
         &self.parsed_until
     /// not.
     ///
     /// [`clone`]: std::clone::Clone::clone
-    #[inline]
     #[must_use]
     pub fn to_owned(&self) -> Error<'static> {
         Error {
 }
 impl Display for ParserOrIoError<'_> {
-    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             ParserOrIoError::Parser(e) => e.fmt(f),
 }
 impl From<std::io::Error> for ParserOrIoError<'_> {
-    #[inline]
     fn from(e: std::io::Error) -> Self {
         Self::Io(e)
     }
 }
 impl Display for ParserNode {
-    #[inline]
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::SectionHeader => write!(f, "section header"),
     /// a section) from the parser. Consider [`Parser::take_frontmatter`] if
     /// you need an owned copy only once. If that function was called, then this
     /// will always return an empty slice.
-    #[inline]
     #[must_use]
     pub fn frontmatter(&self) -> &[Event<'a>] {
         &self.frontmatter
     /// a section) from the parser. Subsequent calls will return an empty vec.
     /// Consider [`Parser::frontmatter`] if you only need a reference to the
     /// frontmatter
-    #[inline]
     pub fn take_frontmatter(&mut self) -> Vec<Event<'a>> {
         std::mem::take(&mut self.frontmatter)
     }
     /// Returns the parsed sections from the parser. Consider
     /// [`Parser::take_sections`] if you need an owned copy only once. If that
     /// function was called, then this will always return an empty slice.
-    #[inline]
     #[must_use]
     pub fn sections(&self) -> &[ParsedSection<'a>] {
         &self.sections
     /// Takes the parsed sections from the parser. Subsequent calls will return
     /// an empty vec. Consider [`Parser::sections`] if you only need a reference
     /// to the comments.
-    #[inline]
     pub fn take_sections(&mut self) -> Vec<ParsedSection<'a>> {
         let mut to_return = vec![];
         std::mem::swap(&mut self.sections, &mut to_return);
     }
     /// Consumes the parser to produce a Vec of Events.
-    #[inline]
     #[must_use]
     pub fn into_vec(self) -> Vec<Event<'a>> {
         self.into_iter().collect()
 impl<'a> TryFrom<&'a str> for Parser<'a> {
     type Error = Error<'a>;
-    #[inline]
     fn try_from(value: &'a str) -> Result<Self, Self::Error> {
         parse_from_str(value)
     }
 impl<'a> TryFrom<&'a [u8]> for Parser<'a> {
     type Error = Error<'a>;
-    #[inline]
     fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {
         parse_from_bytes(value)
     }
 /// Returns an error if the string provided is not a valid `git-config`.
 /// This generally is due to either invalid names or if there's extraneous
 /// data succeeding valid `git-config` data.
-#[inline]
 pub fn parse_from_str(input: &str) -> Result<Parser, Error> {
     parse_from_bytes(input.as_bytes())
 }

git-config/src/values.rs+101−148

@@ -2,8 +2,8 @@ · 1 unmodified line
2		2
3	use std::{borrow::Cow, convert::TryFrom, fmt::Display, str::FromStr};	3	use std::{borrow::Cow, convert::TryFrom, fmt::Display, str::FromStr};
4		4
5	use bstr::BStr;	5	use crate::value;
6	use quick_error::quick_error;	6	use bstr::{BStr, BString};
7	#[cfg(feature = "serde")]	7	#[cfg(feature = "serde")]
8	use serde::{Serialize, Serializer};	8	use serde::{Serialize, Serializer};
9		9
@@ -120,21 +120,18 @@ pub fn normalize_cow(input: Cow<'_, [u8]>) -> Cow<'_, [u8]> { · 110 unmodified lines
120	}	120	}
121		121
122	/// `&[u8]` variant of [`normalize_cow`].	122	/// `&[u8]` variant of [`normalize_cow`].
123	#[inline]
124	#[must_use]	123	#[must_use]
125	pub fn normalize_bytes(input: &[u8]) -> Cow<'_, [u8]> {	124	pub fn normalize_bytes(input: &[u8]) -> Cow<'_, [u8]> {
126	normalize_cow(Cow::Borrowed(input))	125	normalize_cow(Cow::Borrowed(input))
127	}	126	}
128		127
129	/// `Vec[u8]` variant of [`normalize_cow`].	128	/// `Vec[u8]` variant of [`normalize_cow`].
130	#[inline]
131	#[must_use]	129	#[must_use]
132	pub fn normalize_vec(input: Vec<u8>) -> Cow<'static, [u8]> {	130	pub fn normalize_vec(input: Vec<u8>) -> Cow<'static, [u8]> {
133	normalize_cow(Cow::Owned(input))	131	normalize_cow(Cow::Owned(input))
134	}	132	}
135		133
136	/// [`str`] variant of [`normalize_cow`].	134	/// [`str`] variant of [`normalize_cow`].
137	#[inline]
138	#[must_use]	135	#[must_use]
139	pub fn normalize_str(input: &str) -> Cow<'_, [u8]> {	136	pub fn normalize_str(input: &str) -> Cow<'_, [u8]> {
140	normalize_bytes(input.as_bytes())	137	normalize_bytes(input.as_bytes())
@@ -149,7 +146,6 @@ pub struct Bytes<'a> { · 8 unmodified lines
149	}	146	}
150		147
151	impl<'a> From<&'a [u8]> for Bytes<'a> {	148	impl<'a> From<&'a [u8]> for Bytes<'a> {
152	#[inline]
153	fn from(s: &'a [u8]) -> Self {	149	fn from(s: &'a [u8]) -> Self {
154	Self {	150	Self {
155	value: Cow::Borrowed(s),	151	value: Cow::Borrowed(s),
@@ -164,7 +160,6 @@ impl From<Vec<u8>> for Bytes<'_> { · 8 unmodified lines
164	}	160	}
165		161
166	impl<'a> From<Cow<'a, [u8]>> for Bytes<'a> {	162	impl<'a> From<Cow<'a, [u8]>> for Bytes<'a> {
167	#[inline]
168	fn from(c: Cow<'a, [u8]>) -> Self {	163	fn from(c: Cow<'a, [u8]>) -> Self {
169	match c {	164	match c {
170	Cow::Borrowed(c) => Self::from(c),	165	Cow::Borrowed(c) => Self::from(c),
@@ -181,7 +176,6 @@ pub struct String<'a> { · 10 unmodified lines
181	}	176	}
182		177
183	impl<'a> From<Cow<'a, [u8]>> for String<'a> {	178	impl<'a> From<Cow<'a, [u8]>> for String<'a> {
184	#[inline]
185	fn from(c: Cow<'a, [u8]>) -> Self {	179	fn from(c: Cow<'a, [u8]>) -> Self {
186	String {	180	String {
187	value: match c {	181	value: match c {
@@ -198,38 +192,28 @@ pub mod path { · 10 unmodified lines
198		192
199	#[cfg(not(any(target_os = "android", target_os = "windows")))]	193	#[cfg(not(any(target_os = "android", target_os = "windows")))]
200	use pwd::Passwd;	194	use pwd::Passwd;
201	use quick_error::ResultExt;
202		195
203	use crate::values::Path;	196	use crate::values::Path;
204		197
205	pub mod interpolate {	198	pub mod interpolate {
206	use quick_error::quick_error;	199	/// The error returned by [`Path::interpolate()`][crate::values::Path::interpolate()].
207		200	#[derive(Debug, thiserror::Error)]
208	quick_error! {	201	#[allow(missing_docs)]
209	#[derive(Debug)]	202	pub enum Error {
210	/// The error returned by [`Path::interpolate()`].	203	#[error("{} is missing", .what)]
211	#[allow(missing_docs)]	204	Missing { what: &'static str },
212	pub enum Error {	205	#[error("Ill-formed UTF-8 in {}", .what)]
213	Missing { what: &'static str } {	206	Utf8Conversion {
214	display("{} is missing", what)	207	what: &'static str,
215	}	208	#[source]
216	Utf8Conversion(what: &'static str, err: git_features::path::Utf8Error) {	209	err: git_path::Utf8Error,
217	display("Ill-formed UTF-8 in {}", what)	210	},
218	context(what: &'static str, err: git_features::path::Utf8Error) -> (what, err)	211	#[error("Ill-formed UTF-8 in username")]
219	source(err)	212	UsernameConversion(#[from] std::str::Utf8Error),
220	}	213	#[error("User home info missing")]
221	UsernameConversion(err: std::str::Utf8Error) {	214	PwdFileQuery,
222	display("Ill-formed UTF-8 in username")	215	#[error("User interpolation is not available on this platform")]
223	source(err)	216	UserInterpolationUnsupported,
224	from()
225	}
226	PwdFileQuery {
227	display("User home info missing")
228	}
229	UserInterpolationUnsupported {
230	display("User interpolation is not available on this platform")
231	}
232	}
233	}	217	}
234	}	218	}
235		219
@@ -261,17 +245,25 @@ pub mod path { · 25 unmodified lines
261	})?;	245	})?;
262	let (_prefix, path_without_trailing_slash) = self.split_at(PREFIX.len());	246	let (_prefix, path_without_trailing_slash) = self.split_at(PREFIX.len());
263	let path_without_trailing_slash =	247	let path_without_trailing_slash =
264	git_features::path::from_byte_vec(path_without_trailing_slash).context("path past %(prefix)")?;	248	git_path::try_from_bstring(path_without_trailing_slash).map_err(\|err\| {
		249	interpolate::Error::Utf8Conversion {
		250	what: "path past %(prefix)",
		251	err,
		252	}
		253	})?;
265	Ok(git_install_dir.join(path_without_trailing_slash).into())	254	Ok(git_install_dir.join(path_without_trailing_slash).into())
266	} else if self.starts_with(USER_HOME) {	255	} else if self.starts_with(USER_HOME) {
267	let home_path = dirs::home_dir().ok_or(interpolate::Error::Missing { what: "home dir" })?;	256	let home_path = dirs::home_dir().ok_or(interpolate::Error::Missing { what: "home dir" })?;
268	let (_prefix, val) = self.split_at(USER_HOME.len());	257	let (_prefix, val) = self.split_at(USER_HOME.len());
269	let val = git_features::path::from_bytes(val).context("path past ~/")?;	258	let val = git_path::try_from_byte_slice(val).map_err(\|err\| interpolate::Error::Utf8Conversion {
		259	what: "path past ~/",
		260	err,
		261	})?;
270	Ok(home_path.join(val).into())	262	Ok(home_path.join(val).into())
271	} else if self.starts_with(b"~") && self.contains(&b'/') {	263	} else if self.starts_with(b"~") && self.contains(&b'/') {
272	self.interpolate_user()	264	self.interpolate_user()
273	} else {	265	} else {
274	Ok(git_features::path::from_bytes(self.value).context("unexpanded path")?)	266	Ok(git_path::from_bstr(self.value))
275	}	267	}
276	}	268	}
277		269
@@ -293,8 +285,13 @@ pub mod path { · 15 unmodified lines
293	.map_err(\|_\| interpolate::Error::PwdFileQuery)?	285	.map_err(\|_\| interpolate::Error::PwdFileQuery)?
294	.ok_or(interpolate::Error::Missing { what: "pwd user info" })?	286	.ok_or(interpolate::Error::Missing { what: "pwd user info" })?
295	.dir;	287	.dir;
296	let path_past_user_prefix = git_features::path::from_byte_slice(&path_with_leading_slash["/".len()..])	288	let path_past_user_prefix =
297	.context("path past ~user/")?;	289	git_path::try_from_byte_slice(&path_with_leading_slash["/".len()..]).map_err(\|err\| {
		290	interpolate::Error::Utf8Conversion {
		291	what: "path past ~user/",
		292	err,
		293	}
		294	})?;
298	Ok(std::path::PathBuf::from(home).join(path_past_user_prefix).into())	295	Ok(std::path::PathBuf::from(home).join(path_past_user_prefix).into())
299	}	296	}
300	}	297	}
@@ -306,11 +303,11 @@ pub mod path { · 5 unmodified lines
306	#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]	303	#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
307	pub struct Path<'a> {	304	pub struct Path<'a> {
308	/// The path string, un-interpolated	305	/// The path string, un-interpolated
309	pub value: Cow<'a, [u8]>,	306	pub value: Cow<'a, BStr>,
310	}	307	}
311		308
312	impl<'a> std::ops::Deref for Path<'a> {	309	impl<'a> std::ops::Deref for Path<'a> {
313	type Target = [u8];	310	type Target = BStr;
314		311
315	fn deref(&self) -> &Self::Target {	312	fn deref(&self) -> &Self::Target {
316	self.value.as_ref()	313	self.value.as_ref()
@@ -323,10 +320,20 @@ impl<'a> AsRef<[u8]> for Path<'a> { · 6 unmodified lines
323	}	320	}
324	}	321	}
325		322
		323	impl<'a> AsRef<BStr> for Path<'a> {
		324	fn as_ref(&self) -> &BStr {
		325	self.value.as_ref()
		326	}
		327	}
		328
326	impl<'a> From<Cow<'a, [u8]>> for Path<'a> {	329	impl<'a> From<Cow<'a, [u8]>> for Path<'a> {
327	#[inline]
328	fn from(value: Cow<'a, [u8]>) -> Self {	330	fn from(value: Cow<'a, [u8]>) -> Self {
329	Path { value }	331	Path {
		332	value: match value {
		333	Cow::Borrowed(v) => Cow::Borrowed(v.into()),
		334	Cow::Owned(v) => Cow::Owned(v.into()),
		335	},
		336	}
330	}	337	}
331	}	338	}
332		339
@@ -354,7 +361,6 @@ impl Boolean<'_> { · 21 unmodified lines
354	/// Generates a byte representation of the value. This should be used when	361	/// Generates a byte representation of the value. This should be used when
355	/// non-UTF-8 sequences are present or a UTF-8 representation can't be	362	/// non-UTF-8 sequences are present or a UTF-8 representation can't be
356	/// guaranteed.	363	/// guaranteed.
357	#[inline]
358	#[must_use]	364	#[must_use]
359	pub fn to_vec(&self) -> Vec<u8> {	365	pub fn to_vec(&self) -> Vec<u8> {
360	self.into()	366	self.into()
@@ -363,26 +369,21 @@ impl Boolean<'_> { · 2 unmodified lines
363	/// Generates a byte representation of the value. This should be used when	369	/// Generates a byte representation of the value. This should be used when
364	/// non-UTF-8 sequences are present or a UTF-8 representation can't be	370	/// non-UTF-8 sequences are present or a UTF-8 representation can't be
365	/// guaranteed.	371	/// guaranteed.
366	#[inline]
367	#[must_use]	372	#[must_use]
368	pub fn as_bytes(&self) -> &[u8] {	373	pub fn as_bytes(&self) -> &[u8] {
369	self.into()	374	self.into()
370	}	375	}
371	}	376	}
372		377
373	quick_error! {	378	fn bool_err(input: impl Into<BString>) -> value::parse::Error {
374	#[derive(Debug, PartialEq)]	379	value::parse::Error::new(
375	/// The error returned when creating `Boolean` from byte string.	380	"Booleans need to be 'no', 'off', 'false', 'zero' or 'yes', 'on', 'true', 'one'",
376	#[allow(missing_docs)]	381	input,
377	pub enum BooleanError {	382	)
378	InvalidFormat {
379	display("Invalid argument format")
380	}
381	}
382	}	383	}
383		384
384	impl<'a> TryFrom<&'a [u8]> for Boolean<'a> {	385	impl<'a> TryFrom<&'a [u8]> for Boolean<'a> {
385	type Error = BooleanError;	386	type Error = value::parse::Error;
386		387
387	fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {	388	fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {
388	if let Ok(v) = TrueVariant::try_from(value) {	389	if let Ok(v) = TrueVariant::try_from(value) {
@@ -400,12 +401,12 @@ impl<'a> TryFrom<&'a [u8]> for Boolean<'a> { · 11 unmodified lines
400	));	401	));
401	}	402	}
402		403
403	Err(BooleanError::InvalidFormat)	404	Err(bool_err(value))
404	}	405	}
405	}	406	}
406		407
407	impl TryFrom<Vec<u8>> for Boolean<'_> {	408	impl TryFrom<Vec<u8>> for Boolean<'_> {
408	type Error = BooleanError;	409	type Error = value::parse::Error;
409		410
410	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {	411	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
411	if value.eq_ignore_ascii_case(b"no")	412	if value.eq_ignore_ascii_case(b"no")
@@ -424,7 +425,7 @@ impl TryFrom<Vec<u8>> for Boolean<'_> { · 12 unmodified lines
424	}	425	}
425		426
426	impl<'a> TryFrom<Cow<'a, [u8]>> for Boolean<'a> {	427	impl<'a> TryFrom<Cow<'a, [u8]>> for Boolean<'a> {
427	type Error = BooleanError;	428	type Error = value::parse::Error;
428	fn try_from(c: Cow<'a, [u8]>) -> Result<Self, Self::Error> {	429	fn try_from(c: Cow<'a, [u8]>) -> Result<Self, Self::Error> {
429	match c {	430	match c {
430	Cow::Borrowed(c) => Self::try_from(c),	431	Cow::Borrowed(c) => Self::try_from(c),
@@ -434,7 +435,6 @@ impl<'a> TryFrom<Cow<'a, [u8]>> for Boolean<'a> { · 3 unmodified lines
434	}	435	}
435		436
436	impl Display for Boolean<'_> {	437	impl Display for Boolean<'_> {
437	#[inline]
438	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	438	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
439	match self {	439	match self {
440	Boolean::True(v) => v.fmt(f),	440	Boolean::True(v) => v.fmt(f),
@@ -444,7 +444,6 @@ impl Display for Boolean<'_> { · 3 unmodified lines
444	}	444	}
445		445
446	impl From<Boolean<'_>> for bool {	446	impl From<Boolean<'_>> for bool {
447	#[inline]
448	fn from(b: Boolean) -> Self {	447	fn from(b: Boolean) -> Self {
449	match b {	448	match b {
450	Boolean::True(_) => true,	449	Boolean::True(_) => true,
@@ -454,7 +453,6 @@ impl From<Boolean<'_>> for bool { · 3 unmodified lines
454	}	453	}
455		454
456	impl<'a, 'b: 'a> From<&'b Boolean<'a>> for &'a [u8] {	455	impl<'a, 'b: 'a> From<&'b Boolean<'a>> for &'a [u8] {
457	#[inline]
458	fn from(b: &'b Boolean) -> Self {	456	fn from(b: &'b Boolean) -> Self {
459	match b {	457	match b {
460	Boolean::True(t) => t.into(),	458	Boolean::True(t) => t.into(),
@@ -464,14 +462,12 @@ impl<'a, 'b: 'a> From<&'b Boolean<'a>> for &'a [u8] { · 3 unmodified lines
464	}	462	}
465		463
466	impl From<Boolean<'_>> for Vec<u8> {	464	impl From<Boolean<'_>> for Vec<u8> {
467	#[inline]
468	fn from(b: Boolean) -> Self {	465	fn from(b: Boolean) -> Self {
469	b.into()	466	b.into()
470	}	467	}
471	}	468	}
472		469
473	impl From<&Boolean<'_>> for Vec<u8> {	470	impl From<&Boolean<'_>> for Vec<u8> {
474	#[inline]
475	fn from(b: &Boolean) -> Self {	471	fn from(b: &Boolean) -> Self {
476	b.to_string().into_bytes()	472	b.to_string().into_bytes()
477	}	473	}
@@ -502,7 +498,7 @@ pub enum TrueVariant<'a> { · 24 unmodified lines
502	}	498	}
503		499
504	impl<'a> TryFrom<&'a [u8]> for TrueVariant<'a> {	500	impl<'a> TryFrom<&'a [u8]> for TrueVariant<'a> {
505	type Error = BooleanError;	501	type Error = value::parse::Error;
506		502
507	fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {	503	fn try_from(value: &'a [u8]) -> Result<Self, Self::Error> {
508	if value.eq_ignore_ascii_case(b"yes")	504	if value.eq_ignore_ascii_case(b"yes")
@@ -516,13 +512,13 @@ impl<'a> TryFrom<&'a [u8]> for TrueVariant<'a> { · 7 unmodified lines
516	} else if value.is_empty() {	512	} else if value.is_empty() {
517	Ok(Self::Implicit)	513	Ok(Self::Implicit)
518	} else {	514	} else {
519	Err(BooleanError::InvalidFormat)	515	Err(bool_err(value))
520	}	516	}
521	}	517	}
522	}	518	}
523		519
524	impl TryFrom<Vec<u8>> for TrueVariant<'_> {	520	impl TryFrom<Vec<u8>> for TrueVariant<'_> {
525	type Error = BooleanError;	521	type Error = value::parse::Error;
526		522
527	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {	523	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
528	if value.eq_ignore_ascii_case(b"yes")	524	if value.eq_ignore_ascii_case(b"yes")
@@ -536,7 +532,7 @@ impl TryFrom<Vec<u8>> for TrueVariant<'_> { · 7 unmodified lines
536	} else if value.is_empty() {	532	} else if value.is_empty() {
537	Ok(Self::Implicit)	533	Ok(Self::Implicit)
538	} else {	534	} else {
539	Err(BooleanError::InvalidFormat)	535	Err(bool_err(value))
540	}	536	}
541	}	537	}
542	}	538	}
@@ -552,7 +548,6 @@ impl Display for TrueVariant<'_> { · 9 unmodified lines
552	}	548	}
553		549
554	impl<'a, 'b: 'a> From<&'b TrueVariant<'a>> for &'a [u8] {	550	impl<'a, 'b: 'a> From<&'b TrueVariant<'a>> for &'a [u8] {
555	#[inline]
556	fn from(t: &'b TrueVariant<'a>) -> Self {	551	fn from(t: &'b TrueVariant<'a>) -> Self {
557	match t {	552	match t {
558	TrueVariant::Explicit(e) => e.as_bytes(),	553	TrueVariant::Explicit(e) => e.as_bytes(),
@@ -641,31 +636,18 @@ impl Serialize for Integer { · 82 unmodified lines
641	}	636	}
642	}	637	}
643		638
644	quick_error! {	639	fn int_err(input: impl Into<BString>) -> value::parse::Error {
645	#[derive(Debug)]	640	value::parse::Error::new(
646	/// The error returned when creating `Integer` from byte string.	641	"Intgers needs to be positive or negative numbers which may have a suffix like 1k, or 50G",
647	#[allow(missing_docs)]	642	input,
648	pub enum IntegerError {	643	)
649	Utf8Conversion(err: std::str::Utf8Error) {
650	display("Ill-formed UTF-8")
651	source(err)
652	from()
653	}
654	InvalidFormat {
655	display("Invalid argument format")
656	}
657	InvalidSuffix {
658	display("Invalid suffix")
659	}
660	}
661	}	644	}
662		645
663	impl TryFrom<&[u8]> for Integer {	646	impl TryFrom<&[u8]> for Integer {
664	type Error = IntegerError;	647	type Error = value::parse::Error;
665		648
666	#[inline]
667	fn try_from(s: &[u8]) -> Result<Self, Self::Error> {	649	fn try_from(s: &[u8]) -> Result<Self, Self::Error> {
668	let s = std::str::from_utf8(s)?;	650	let s = std::str::from_utf8(s).map_err(\|err\| int_err(s).with_err(err))?;
669	if let Ok(value) = s.parse() {	651	if let Ok(value) = s.parse() {
670	return Ok(Self { value, suffix: None });	652	return Ok(Self { value, suffix: None });
671	}	653	}
@@ -673,7 +655,7 @@ impl TryFrom<&[u8]> for Integer { · 1 unmodified line
673	// Assume we have a prefix at this point.	655	// Assume we have a prefix at this point.
674		656
675	if s.len() <= 1 {	657	if s.len() <= 1 {
676	return Err(IntegerError::InvalidFormat);	658	return Err(int_err(s));
677	}	659	}
678		660
679	let (number, suffix) = s.split_at(s.len() - 1);	661	let (number, suffix) = s.split_at(s.len() - 1);
@@ -683,24 +665,22 @@ impl TryFrom<&[u8]> for Integer { · 3 unmodified lines
683	suffix: Some(suffix),	665	suffix: Some(suffix),
684	})	666	})
685	} else {	667	} else {
686	Err(IntegerError::InvalidFormat)	668	Err(int_err(s))
687	}	669	}
688	}	670	}
689	}	671	}
690		672
691	impl TryFrom<Vec<u8>> for Integer {	673	impl TryFrom<Vec<u8>> for Integer {
692	type Error = IntegerError;	674	type Error = value::parse::Error;
693		675
694	#[inline]
695	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {	676	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
696	Self::try_from(value.as_ref())	677	Self::try_from(value.as_ref())
697	}	678	}
698	}	679	}
699		680
700	impl TryFrom<Cow<'_, [u8]>> for Integer {	681	impl TryFrom<Cow<'_, [u8]>> for Integer {
701	type Error = IntegerError;	682	type Error = value::parse::Error;
702		683
703	#[inline]
704	fn try_from(c: Cow<'_, [u8]>) -> Result<Self, Self::Error> {	684	fn try_from(c: Cow<'_, [u8]>) -> Result<Self, Self::Error> {
705	match c {	685	match c {
706	Cow::Borrowed(c) => Self::try_from(c),	686	Cow::Borrowed(c) => Self::try_from(c),
@@ -710,14 +690,12 @@ impl TryFrom<Cow<'_, [u8]>> for Integer { · 3 unmodified lines
710	}	690	}
711		691
712	impl From<Integer> for Vec<u8> {	692	impl From<Integer> for Vec<u8> {
713	#[inline]
714	fn from(i: Integer) -> Self {	693	fn from(i: Integer) -> Self {
715	i.into()	694	i.into()
716	}	695	}
717	}	696	}
718		697
719	impl From<&Integer> for Vec<u8> {	698	impl From<&Integer> for Vec<u8> {
720	#[inline]
721	fn from(i: &Integer) -> Self {	699	fn from(i: &Integer) -> Self {
722	i.to_string().into_bytes()	700	i.to_string().into_bytes()
723	}	701	}
@@ -736,7 +714,6 @@ pub enum IntegerSuffix { · 12 unmodified lines
736		714
737	impl IntegerSuffix {	715	impl IntegerSuffix {
738	/// Returns the number of bits that the suffix shifts left by.	716	/// Returns the number of bits that the suffix shifts left by.
739	#[inline]
740	#[must_use]	717	#[must_use]
741	pub const fn bitwise_offset(self) -> usize {	718	pub const fn bitwise_offset(self) -> usize {
742	match self {	719	match self {
@@ -748,7 +725,6 @@ impl IntegerSuffix { · 5 unmodified lines
748	}	725	}
749		726
750	impl Display for IntegerSuffix {	727	impl Display for IntegerSuffix {
751	#[inline]
752	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	728	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
753	match self {	729	match self {
754	Self::Kibi => write!(f, "k"),	730	Self::Kibi => write!(f, "k"),
@@ -773,32 +749,29 @@ impl Serialize for IntegerSuffix { · 18 unmodified lines
773	}	749	}
774		750
775	impl FromStr for IntegerSuffix {	751	impl FromStr for IntegerSuffix {
776	type Err = IntegerError;	752	type Err = ();
777		753
778	#[inline]
779	fn from_str(s: &str) -> Result<Self, Self::Err> {	754	fn from_str(s: &str) -> Result<Self, Self::Err> {
780	match s {	755	match s {
781	"k" \| "K" => Ok(Self::Kibi),	756	"k" \| "K" => Ok(Self::Kibi),
782	"m" \| "M" => Ok(Self::Mebi),	757	"m" \| "M" => Ok(Self::Mebi),
783	"g" \| "G" => Ok(Self::Gibi),	758	"g" \| "G" => Ok(Self::Gibi),
784	_ => Err(IntegerError::InvalidSuffix),	759	_ => Err(()),
785	}	760	}
786	}	761	}
787	}	762	}
788		763
789	impl TryFrom<&[u8]> for IntegerSuffix {	764	impl TryFrom<&[u8]> for IntegerSuffix {
790	type Error = IntegerError;	765	type Error = ();
791		766
792	#[inline]
793	fn try_from(s: &[u8]) -> Result<Self, Self::Error> {	767	fn try_from(s: &[u8]) -> Result<Self, Self::Error> {
794	Self::from_str(std::str::from_utf8(s)?)	768	Self::from_str(std::str::from_utf8(s).map_err(\|_\| ())?)
795	}	769	}
796	}	770	}
797		771
798	impl TryFrom<Vec<u8>> for IntegerSuffix {	772	impl TryFrom<Vec<u8>> for IntegerSuffix {
799	type Error = IntegerError;	773	type Error = ();
800		774
801	#[inline]
802	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {	775	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
803	Self::try_from(value.as_ref())	776	Self::try_from(value.as_ref())
804	}	777	}
@@ -825,7 +798,6 @@ impl Color { · 20 unmodified lines
825	/// Generates a byte representation of the value. This should be used when	798	/// Generates a byte representation of the value. This should be used when
826	/// non-UTF-8 sequences are present or a UTF-8 representation can't be	799	/// non-UTF-8 sequences are present or a UTF-8 representation can't be
827	/// guaranteed.	800	/// guaranteed.
828	#[inline]
829	#[must_use]	801	#[must_use]
830	pub fn to_vec(&self) -> Vec<u8> {	802	pub fn to_vec(&self) -> Vec<u8> {
831	self.into()	803	self.into()
@@ -861,31 +833,18 @@ impl Serialize for Color { · 29 unmodified lines
861	}	833	}
862	}	834	}
863		835
864	quick_error! {	836	fn color_err(input: impl Into<BString>) -> value::parse::Error {
865	#[derive(Debug, PartialEq)]	837	value::parse::Error::new(
866	///	838	"Colors are specific color values and their attributes, like 'brightred', or 'blue'",
867	#[allow(missing_docs)]	839	input,
868	pub enum ColorError {	840	)
869	Utf8Conversion(err: std::str::Utf8Error) {
870	display("Ill-formed UTF-8")
871	source(err)
872	from()
873	}
874	InvalidColorItem {
875	display("Invalid color item")
876	}
877	InvalidFormat {
878	display("Invalid argument format")
879	}
880	}
881	}	841	}
882		842
883	impl TryFrom<&[u8]> for Color {	843	impl TryFrom<&[u8]> for Color {
884	type Error = ColorError;	844	type Error = value::parse::Error;
885		845
886	#[inline]
887	fn try_from(s: &[u8]) -> Result<Self, Self::Error> {	846	fn try_from(s: &[u8]) -> Result<Self, Self::Error> {
888	let s = std::str::from_utf8(s)?;	847	let s = std::str::from_utf8(s).map_err(\|err\| color_err(s).with_err(err))?;
889	enum ColorItem {	848	enum ColorItem {
890	Value(ColorValue),	849	Value(ColorValue),
891	Attr(ColorAttribute),	850	Attr(ColorAttribute),
@@ -913,12 +872,12 @@ impl TryFrom<&[u8]> for Color { · 21 unmodified lines
913	} else if new_self.background.is_none() {	872	} else if new_self.background.is_none() {
914	new_self.background = Some(v);	873	new_self.background = Some(v);
915	} else {	874	} else {
916	return Err(ColorError::InvalidColorItem);	875	return Err(color_err(s));
917	}	876	}
918	}	877	}
919	ColorItem::Attr(a) => new_self.attributes.push(a),	878	ColorItem::Attr(a) => new_self.attributes.push(a),
920	},	879	},
921	Err(_) => return Err(ColorError::InvalidColorItem),	880	Err(_) => return Err(color_err(s)),
922	}	881	}
923	}	882	}
924		883
@@ -927,18 +886,16 @@ impl TryFrom<&[u8]> for Color { · 2 unmodified lines
927	}	886	}
928		887
929	impl TryFrom<Vec<u8>> for Color {	888	impl TryFrom<Vec<u8>> for Color {
930	type Error = ColorError;	889	type Error = value::parse::Error;
931		890
932	#[inline]
933	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {	891	fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
934	Self::try_from(value.as_ref())	892	Self::try_from(value.as_ref())
935	}	893	}
936	}	894	}
937		895
938	impl TryFrom<Cow<'_, [u8]>> for Color {	896	impl TryFrom<Cow<'_, [u8]>> for Color {
939	type Error = ColorError;	897	type Error = value::parse::Error;
940		898
941	#[inline]
942	fn try_from(c: Cow<'_, [u8]>) -> Result<Self, Self::Error> {	899	fn try_from(c: Cow<'_, [u8]>) -> Result<Self, Self::Error> {
943	match c {	900	match c {
944	Cow::Borrowed(c) => Self::try_from(c),	901	Cow::Borrowed(c) => Self::try_from(c),
@@ -948,14 +905,12 @@ impl TryFrom<Cow<'_, [u8]>> for Color { · 3 unmodified lines
948	}	905	}
949		906
950	impl From<Color> for Vec<u8> {	907	impl From<Color> for Vec<u8> {
951	#[inline]
952	fn from(c: Color) -> Self {	908	fn from(c: Color) -> Self {
953	c.into()	909	c.into()
954	}	910	}
955	}	911	}
956		912
957	impl From<&Color> for Vec<u8> {	913	impl From<&Color> for Vec<u8> {
958	#[inline]
959	fn from(c: &Color) -> Self {	914	fn from(c: &Color) -> Self {
960	c.to_string().into_bytes()	915	c.to_string().into_bytes()
961	}	916	}
@@ -1026,7 +981,7 @@ impl Serialize for ColorValue { · 64 unmodified lines
1026	}	981	}
1027		982
1028	impl FromStr for ColorValue {	983	impl FromStr for ColorValue {
1029	type Err = ColorError;	984	type Err = value::parse::Error;
1030		985
1031	fn from_str(s: &str) -> Result<Self, Self::Err> {	986	fn from_str(s: &str) -> Result<Self, Self::Err> {
1032	let mut s = s;	987	let mut s = s;
@@ -1039,7 +994,7 @@ impl FromStr for ColorValue { · 6 unmodified lines
1039		994
1040	match s {	995	match s {
1041	"normal" if !bright => return Ok(Self::Normal),	996	"normal" if !bright => return Ok(Self::Normal),
1042	"normal" if bright => return Err(ColorError::InvalidFormat),	997	"normal" if bright => return Err(color_err(s)),
1043	"black" if !bright => return Ok(Self::Black),	998	"black" if !bright => return Ok(Self::Black),
1044	"black" if bright => return Ok(Self::BrightBlack),	999	"black" if bright => return Ok(Self::BrightBlack),
1045	"red" if !bright => return Ok(Self::Red),	1000	"red" if !bright => return Ok(Self::Red),
@@ -1077,16 +1032,15 @@ impl FromStr for ColorValue { · 31 unmodified lines
1077	}	1032	}
1078	}	1033	}
1079		1034
1080	Err(ColorError::InvalidFormat)	1035	Err(color_err(s))
1081	}	1036	}
1082	}	1037	}
1083		1038
1084	impl TryFrom<&[u8]> for ColorValue {	1039	impl TryFrom<&[u8]> for ColorValue {
1085	type Error = ColorError;	1040	type Error = value::parse::Error;
1086		1041
1087	#[inline]
1088	fn try_from(s: &[u8]) -> Result<Self, Self::Error> {	1042	fn try_from(s: &[u8]) -> Result<Self, Self::Error> {
1089	Self::from_str(std::str::from_utf8(s)?)	1043	Self::from_str(std::str::from_utf8(s).map_err(\|err\| color_err(s).with_err(err))?)
1090	}	1044	}
1091	}	1045	}
1092		1046
@@ -1161,7 +1115,7 @@ impl Serialize for ColorAttribute { · 68 unmodified lines
1161	}	1115	}
1162		1116
1163	impl FromStr for ColorAttribute {	1117	impl FromStr for ColorAttribute {
1164	type Err = ColorError;	1118	type Err = value::parse::Error;
1165		1119
1166	fn from_str(s: &str) -> Result<Self, Self::Err> {	1120	fn from_str(s: &str) -> Result<Self, Self::Err> {
1167	let inverted = s.starts_with("no");	1121	let inverted = s.starts_with("no");
@@ -1190,16 +1144,15 @@ impl FromStr for ColorAttribute { · 22 unmodified lines
1190	"italic" if inverted => Ok(Self::NoItalic),	1144	"italic" if inverted => Ok(Self::NoItalic),
1191	"strike" if !inverted => Ok(Self::Strike),	1145	"strike" if !inverted => Ok(Self::Strike),
1192	"strike" if inverted => Ok(Self::NoStrike),	1146	"strike" if inverted => Ok(Self::NoStrike),
1193	_ => Err(ColorError::InvalidFormat),	1147	_ => Err(color_err(parsed)),
1194	}	1148	}
1195	}	1149	}
1196	}	1150	}
1197		1151
1198	impl TryFrom<&[u8]> for ColorAttribute {	1152	impl TryFrom<&[u8]> for ColorAttribute {
1199	type Error = ColorError;	1153	type Error = value::parse::Error;
1200		1154
1201	#[inline]
1202	fn try_from(s: &[u8]) -> Result<Self, Self::Error> {	1155	fn try_from(s: &[u8]) -> Result<Self, Self::Error> {
1203	Self::from_str(std::str::from_utf8(s)?)	1156	Self::from_str(std::str::from_utf8(s).map_err(\|err\| color_err(s).with_err(err))?)
1204	}	1157	}
1205	}	1158	}

git-config/tests/git_config/mod.rs+139−108

     fn value_is_correct() {
         let mut git_config = init_config();
-        let value = git_config.get_raw_value_mut("core", None, "a").unwrap();
+        let value = git_config.raw_value_mut("core", None, "a").unwrap();
         assert_eq!(&*value.get().unwrap(), b"b100");
     }
     fn set_string_cleanly_updates() {
         let mut git_config = init_config();
-        let mut value = git_config.get_raw_value_mut("core", None, "a").unwrap();
+        let mut value = git_config.raw_value_mut("core", None, "a").unwrap();
         value.set_string("hello world".to_string());
         assert_eq!(
             git_config.to_string(),
                 e=f"#,
         );
-        let mut value = git_config.get_raw_value_mut("core", None, "e").unwrap();
+        let mut value = git_config.raw_value_mut("core", None, "e").unwrap();
         value.set_string(String::new());
         assert_eq!(
             git_config.to_string(),
     fn delete_value() {
         let mut git_config = init_config();
-        let mut value = git_config.get_raw_value_mut("core", None, "a").unwrap();
+        let mut value = git_config.raw_value_mut("core", None, "a").unwrap();
         value.delete();
         assert_eq!(
             git_config.to_string(),
                 e=f",
         );
-        let mut value = git_config.get_raw_value_mut("core", None, "c").unwrap();
+        let mut value = git_config.raw_value_mut("core", None, "c").unwrap();
         value.delete();
         assert_eq!(
             git_config.to_string(),
     fn get_value_after_deleted() {
         let mut git_config = init_config();
-        let mut value = git_config.get_raw_value_mut("core", None, "a").unwrap();
+        let mut value = git_config.raw_value_mut("core", None, "a").unwrap();
         value.delete();
         assert!(value.get().is_err());
     }
     fn set_string_after_deleted() {
         let mut git_config = init_config();
-        let mut value = git_config.get_raw_value_mut("core", None, "a").unwrap();
+        let mut value = git_config.raw_value_mut("core", None, "a").unwrap();
         value.delete();
         value.set_string("hello world".to_string());
         assert_eq!(
     fn subsequent_delete_calls_are_noop() {
         let mut git_config = init_config();
-        let mut value = git_config.get_raw_value_mut("core", None, "a").unwrap();
+        let mut value = git_config.raw_value_mut("core", None, "a").unwrap();
         for _ in 0..10 {
             value.delete();
         }
                 e=f"#,
         )
         .unwrap();
-        let mut value = git_config.get_raw_value_mut("core", None, "a").unwrap();
+        let mut value = git_config.raw_value_mut("core", None, "a").unwrap();
         assert_eq!(&*value.get().unwrap(), b"b100b");
         value.delete();
         assert_eq!(
     fn value_is_correct() {
         let mut git_config = init_config();
-        let value = git_config.get_raw_multi_value_mut("core", None, "a").unwrap();
+        let value = git_config.raw_multi_value_mut("core", None, "a").unwrap();
         assert_eq!(
             &*value.get().unwrap(),
             vec![
     #[test]
     fn non_empty_sizes_are_correct() {
         let mut git_config = init_config();
-        assert_eq!(git_config.get_raw_multi_value_mut("core", None, "a").unwrap().len(), 3);
+        assert_eq!(git_config.raw_multi_value_mut("core", None, "a").unwrap().len(), 3);
-        assert!(!git_config
+        assert!(!git_config.raw_multi_value_mut("core", None, "a").unwrap().is_empty());
-            .get_raw_multi_value_mut("core", None, "a")
-            .unwrap()
-            .is_empty());
     }
     #[test]
     fn set_value_at_start() {
         let mut git_config = init_config();
-        let mut values = git_config.get_raw_multi_value_mut("core", None, "a").unwrap();
+        let mut values = git_config.raw_multi_value_mut("core", None, "a").unwrap();
         values.set_string(0, "Hello".to_string());
         assert_eq!(
             git_config.to_string(),
     #[test]
     fn set_value_at_end() {
         let mut git_config = init_config();
-        let mut values = git_config.get_raw_multi_value_mut("core", None, "a").unwrap();
+        let mut values = git_config.raw_multi_value_mut("core", None, "a").unwrap();
         values.set_string(2, "Hello".to_string());
         assert_eq!(
             git_config.to_string(),
     #[test]
     fn set_values_all() {
         let mut git_config = init_config();
-        let mut values = git_config.get_raw_multi_value_mut("core", None, "a").unwrap();
+        let mut values = git_config.raw_multi_value_mut("core", None, "a").unwrap();
         values.set_owned_values_all(b"Hello");
         assert_eq!(
             git_config.to_string(),
     #[test]
     fn delete() {
         let mut git_config = init_config();
-        let mut values = git_config.get_raw_multi_value_mut("core", None, "a").unwrap();
+        let mut values = git_config.raw_multi_value_mut("core", None, "a").unwrap();
         values.delete(0);
         assert_eq!(
             git_config.to_string(),
     #[test]
     fn delete_all() {
         let mut git_config = init_config();
-        let mut values = git_config.get_raw_multi_value_mut("core", None, "a").unwrap();
+        let mut values = git_config.raw_multi_value_mut("core", None, "a").unwrap();
         values.delete_all();
         assert!(values.get().is_err());
         assert_eq!(
 a"#,
         )
         .unwrap();
-        let mut values = git_config.get_raw_multi_value_mut("core", None, "a").unwrap();
+        let mut values = git_config.raw_multi_value_mut("core", None, "a").unwrap();
         assert_eq!(
             &*values.get().unwrap(),
         let config = GitConfig::from_paths(paths, &Default::default()).unwrap();
         assert_eq!(
-            config.get_raw_value("core", None, "boolean"),
+            config.raw_value("core", None, "boolean").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"true"))
+            Cow::<[u8]>::Borrowed(b"true")
         );
         assert_eq!(config.len(), 1);
         let config = GitConfig::from_paths(vec![c_path], &Default::default()).unwrap();
         assert_eq!(
-            config.get_raw_value("core", None, "c"),
+            config.raw_value("core", None, "c").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"12"))
+            Cow::<[u8]>::Borrowed(b"12")
         );
         assert_eq!(
-            config.get_raw_value("core", None, "d"),
+            config.raw_value("core", None, "d").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"41"))
+            Cow::<[u8]>::Borrowed(b"41")
         );
         assert_eq!(
-            config.get_raw_value("http", None, "sslVerify"),
+            config.raw_value("http", None, "sslVerify").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"false"))
+            Cow::<[u8]>::Borrowed(b"false")
         );
         assert_eq!(
-            config.get_raw_value("diff", None, "renames"),
+            config.raw_value("diff", None, "renames").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"true"))
+            Cow::<[u8]>::Borrowed(b"true")
         );
         assert_eq!(
-            config.get_raw_value("core", None, "a"),
+            config.raw_value("core", None, "a").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"false"))
+            Cow::<[u8]>::Borrowed(b"false")
         );
     }
         let options = from_paths::Options::default();
         let config = GitConfig::from_paths(vec![dir.path().join("0")], &options).unwrap();
         assert_eq!(
-            config.get_raw_multi_value("core", None, "i").unwrap(),
+            config.raw_multi_value("core", None, "i").unwrap(),
             vec![
                 Cow::Borrowed(b"0"),
                 Cow::Borrowed(b"1"),
             ..Default::default()
         };
         let config = GitConfig::from_paths(vec![dir.path().join("0")], &options).unwrap();
-        assert_eq!(config.get_raw_value("core", None, "i"), Ok(Cow::<[u8]>::Borrowed(b"1")));
+        assert_eq!(
+            config.raw_value("core", None, "i").unwrap(),
+            Cow::<[u8]>::Borrowed(b"1")
+        );
         // with default max_allowed_depth of 10 and 4 levels of includes, last level is read
         let options = from_paths::Options::default();
         let config = GitConfig::from_paths(vec![dir.path().join("0")], &options).unwrap();
-        assert_eq!(config.get_raw_value("core", None, "i"), Ok(Cow::<[u8]>::Borrowed(b"4")));
+        assert_eq!(
+            config.raw_value("core", None, "i").unwrap(),
+            Cow::<[u8]>::Borrowed(b"4")
+        );
         // with max_allowed_depth of 5, the base and 4 levels of includes, last level is read
         let options = from_paths::Options {
             ..Default::default()
         };
         let config = GitConfig::from_paths(vec![dir.path().join("0")], &options).unwrap();
-        assert_eq!(config.get_raw_value("core", None, "i"), Ok(Cow::<[u8]>::Borrowed(b"4")));
+        assert_eq!(
+            config.raw_value("core", None, "i").unwrap(),
+            Cow::<[u8]>::Borrowed(b"4")
+        );
         // with max_allowed_depth of 2 and 4 levels of includes, max_allowed_depth is exceeded and error is returned
         let options = from_paths::Options {
             ..Default::default()
         };
         let config = GitConfig::from_paths(vec![dir.path().join("0")], &options).unwrap();
-        assert_eq!(config.get_raw_value("core", None, "i"), Ok(Cow::<[u8]>::Borrowed(b"2")));
+        assert_eq!(
+            config.raw_value("core", None, "i").unwrap(),
+            Cow::<[u8]>::Borrowed(b"2")
+        );
         // with max_allowed_depth of 0 and 4 levels of includes, max_allowed_depth is exceeded and error is returned
         let options = from_paths::Options {
         let config = GitConfig::from_paths(vec![a_path], &Default::default()).unwrap();
         assert_eq!(
-            config.get_raw_value("core", None, "b"),
+            config.raw_value("core", None, "b").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"false"))
+            Cow::<[u8]>::Borrowed(b"false")
         );
     }
         };
         let config = GitConfig::from_paths(vec![a_path], &options).unwrap();
         assert_eq!(
-            config.get_raw_multi_value("core", None, "b").unwrap(),
+            config.raw_multi_value("core", None, "b").unwrap(),
             vec![
                 Cow::Borrowed(b"0"),
                 Cow::Borrowed(b"1"),
         let config = GitConfig::from_paths(vec![c_path], &Default::default()).unwrap();
-        assert_eq!(config.get_raw_value("core", None, "c"), Ok(Cow::<[u8]>::Borrowed(b"1")));
+        assert_eq!(
+            config.raw_value("core", None, "c").unwrap(),
+            Cow::<[u8]>::Borrowed(b"1")
+        );
         assert_eq!(
-            config.get_raw_value("core", None, "b"),
+            config.raw_value("core", None, "b").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"true"))
+            Cow::<[u8]>::Borrowed(b"true")
         );
         assert_eq!(
-            config.get_raw_value("core", None, "a"),
+            config.raw_value("core", None, "a").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"false"))
+            Cow::<[u8]>::Borrowed(b"false")
         );
     }
         let config = GitConfig::from_paths(paths, &Default::default()).unwrap();
         assert_eq!(
-            config.get_raw_value("core", None, "a"),
+            config.raw_value("core", None, "a").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"false"))
+            Cow::<[u8]>::Borrowed(b"false")
         );
         assert_eq!(
-            config.get_raw_value("core", None, "b"),
+            config.raw_value("core", None, "b").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"true"))
+            Cow::<[u8]>::Borrowed(b"true")
         );
         assert_eq!(
-            config.get_raw_value("core", None, "c"),
+            config.raw_value("core", None, "c").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"true"))
+            Cow::<[u8]>::Borrowed(b"true")
         );
         assert_eq!(config.len(), 4);
         let config = GitConfig::from_paths(paths, &Default::default()).unwrap();
         assert_eq!(
-            config.get_raw_multi_value("core", None, "key").unwrap(),
+            config.raw_multi_value("core", None, "key").unwrap(),
             vec![Cow::Borrowed(b"a"), Cow::Borrowed(b"b"), Cow::Borrowed(b"c")]
         );
         assert_eq!(
-            config.get_raw_multi_value("include", None, "path").unwrap(),
+            config.raw_multi_value("include", None, "path").unwrap(),
             vec![Cow::Borrowed(b"d_path"), Cow::Borrowed(b"e_path")]
         );
     fn parse_error_with_invalid_count() {
         let _env = Env::new().set("GIT_CONFIG_COUNT", "invalid");
         let err = GitConfig::from_env(&Options::default()).unwrap_err();
-        assert!(matches!(err, from_env::Error::ParseError(_)));
+        assert!(matches!(err, from_env::Error::ParseError { .. }));
     }
     #[test]
         let config = GitConfig::from_env(&Options::default()).unwrap().unwrap();
         assert_eq!(
-            config.get_raw_value("core", None, "key"),
+            config.raw_value("core", None, "key").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"value"))
+            Cow::<[u8]>::Borrowed(b"value")
         );
         assert_eq!(config.len(), 1);
         let config = GitConfig::from_env(&Options::default()).unwrap().unwrap();
-        assert_eq!(config.get_raw_value("core", None, "a"), Ok(Cow::<[u8]>::Borrowed(b"a")));
+        assert_eq!(
-        assert_eq!(config.get_raw_value("core", None, "b"), Ok(Cow::<[u8]>::Borrowed(b"b")));
+            config.raw_value("core", None, "a").unwrap(),
-        assert_eq!(config.get_raw_value("core", None, "c"), Ok(Cow::<[u8]>::Borrowed(b"c")));
+            Cow::<[u8]>::Borrowed(b"a")
+        );
+        assert_eq!(
+            config.raw_value("core", None, "b").unwrap(),
+            Cow::<[u8]>::Borrowed(b"b")
+        );
+        assert_eq!(
+            config.raw_value("core", None, "c").unwrap(),
+            Cow::<[u8]>::Borrowed(b"c")
+        );
         assert_eq!(config.len(), 3);
     }
         let config = GitConfig::from_env(&Options::default()).unwrap().unwrap();
         assert_eq!(
-            config.get_raw_value("core", None, "key"),
+            config.raw_value("core", None, "key").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"changed"))
+            Cow::<[u8]>::Borrowed(b"changed")
         );
         assert_eq!(config.len(), 5);
     }
 mod get_raw_value {
     use std::{borrow::Cow, convert::TryFrom};
-    use git_config::{
+    use git_config::{file::GitConfig, lookup};
-        file::{GitConfig, GitConfigError},
-        parser::SectionHeaderName,
-    };
     #[test]
     fn single_section() {
         let config = GitConfig::try_from("[core]\na=b\nc=d").unwrap();
-        assert_eq!(config.get_raw_value("core", None, "a"), Ok(Cow::<[u8]>::Borrowed(b"b")));
+        assert_eq!(
-        assert_eq!(config.get_raw_value("core", None, "c"), Ok(Cow::<[u8]>::Borrowed(b"d")));
+            config.raw_value("core", None, "a").unwrap(),
+            Cow::<[u8]>::Borrowed(b"b")
+        );
+        assert_eq!(
+            config.raw_value("core", None, "c").unwrap(),
+            Cow::<[u8]>::Borrowed(b"d")
+        );
     }
     #[test]
     fn last_one_wins_respected_in_section() {
         let config = GitConfig::try_from("[core]\na=b\na=d").unwrap();
-        assert_eq!(config.get_raw_value("core", None, "a"), Ok(Cow::<[u8]>::Borrowed(b"d")));
+        assert_eq!(
+            config.raw_value("core", None, "a").unwrap(),
+            Cow::<[u8]>::Borrowed(b"d")
+        );
     }
     #[test]
     fn last_one_wins_respected_across_section() {
         let config = GitConfig::try_from("[core]\na=b\n[core]\na=d").unwrap();
-        assert_eq!(config.get_raw_value("core", None, "a"), Ok(Cow::<[u8]>::Borrowed(b"d")));
+        assert_eq!(
+            config.raw_value("core", None, "a").unwrap(),
+            Cow::<[u8]>::Borrowed(b"d")
+        );
     }
     #[test]
     fn section_not_found() {
         let config = GitConfig::try_from("[core]\na=b\nc=d").unwrap();
-        assert_eq!(
+        assert!(matches!(
-            config.get_raw_value("foo", None, "a"),
+            config.raw_value("foo", None, "a"),
-            Err(GitConfigError::SectionDoesNotExist(SectionHeaderName("foo".into())))
+            Err(lookup::existing::Error::SectionMissing)
-        );
+        ));
     }
     #[test]
     fn subsection_not_found() {
         let config = GitConfig::try_from("[core]\na=b\nc=d").unwrap();
-        assert_eq!(
+        assert!(matches!(
-            config.get_raw_value("core", Some("a"), "a"),
+            config.raw_value("core", Some("a"), "a"),
-            Err(GitConfigError::SubSectionDoesNotExist(Some("a")))
+            Err(lookup::existing::Error::SubSectionMissing)
-        );
+        ));
     }
     #[test]
     fn key_not_found() {
         let config = GitConfig::try_from("[core]\na=b\nc=d").unwrap();
-        assert_eq!(
+        assert!(matches!(
-            config.get_raw_value("core", None, "aaaaaa"),
+            config.raw_value("core", None, "aaaaaa"),
-            Err(GitConfigError::KeyDoesNotExist)
+            Err(lookup::existing::Error::KeyMissing)
-        );
+        ));
     }
     #[test]
     fn subsection_must_be_respected() {
         let config = GitConfig::try_from("[core]a=b\n[core.a]a=c").unwrap();
-        assert_eq!(config.get_raw_value("core", None, "a"), Ok(Cow::<[u8]>::Borrowed(b"b")));
         assert_eq!(
-            config.get_raw_value("core", Some("a"), "a"),
+            config.raw_value("core", None, "a").unwrap(),
-            Ok(Cow::<[u8]>::Borrowed(b"c"))
+            Cow::<[u8]>::Borrowed(b"b")
+        );
+        assert_eq!(
+            config.raw_value("core", Some("a"), "a").unwrap(),
+            Cow::<[u8]>::Borrowed(b"c")
         );
     }
 }
 mod get_raw_multi_value {
     use std::{borrow::Cow, convert::TryFrom};
-    use git_config::{
+    use git_config::file::GitConfig;
-        file::{GitConfig, GitConfigError},
+    use git_config::lookup;
-        parser::SectionHeaderName,
-    };
     #[test]
     fn single_value_is_identical_to_single_value_query() {
         let config = GitConfig::try_from("[core]\na=b\nc=d").unwrap();
         assert_eq!(
-            vec![config.get_raw_value("core", None, "a").unwrap()],
+            vec![config.raw_value("core", None, "a").unwrap()],
-            config.get_raw_multi_value("core", None, "a").unwrap()
+            config.raw_multi_value("core", None, "a").unwrap()
         );
     }
     fn multi_value_in_section() {
         let config = GitConfig::try_from("[core]\na=b\na=c").unwrap();
         assert_eq!(
-            config.get_raw_multi_value("core", None, "a").unwrap(),
+            config.raw_multi_value("core", None, "a").unwrap(),
             vec![Cow::Borrowed(b"b"), Cow::Borrowed(b"c")]
         );
     }
     fn multi_value_across_sections() {
         let config = GitConfig::try_from("[core]\na=b\na=c\n[core]a=d").unwrap();
         assert_eq!(
-            config.get_raw_multi_value("core", None, "a").unwrap(),
+            config.raw_multi_value("core", None, "a").unwrap(),
             vec![Cow::Borrowed(b"b"), Cow::Borrowed(b"c"), Cow::Borrowed(b"d")]
         );
     }
     #[test]
     fn section_not_found() {
         let config = GitConfig::try_from("[core]\na=b\nc=d").unwrap();
-        assert_eq!(
+        assert!(matches!(
-            config.get_raw_multi_value("foo", None, "a"),
+            config.raw_multi_value("foo", None, "a"),
-            Err(GitConfigError::SectionDoesNotExist(SectionHeaderName("foo".into())))
+            Err(lookup::existing::Error::SectionMissing)
-        );
+        ));
     }
     #[test]
     fn subsection_not_found() {
         let config = GitConfig::try_from("[core]\na=b\nc=d").unwrap();
-        assert_eq!(
+        assert!(matches!(
-            config.get_raw_multi_value("core", Some("a"), "a"),
+            config.raw_multi_value("core", Some("a"), "a"),
-            Err(GitConfigError::SubSectionDoesNotExist(Some("a")))
+            Err(lookup::existing::Error::SubSectionMissing)
-        );
+        ));
     }
     #[test]
     fn key_not_found() {
         let config = GitConfig::try_from("[core]\na=b\nc=d").unwrap();
-        assert_eq!(
+        assert!(matches!(
-            config.get_raw_multi_value("core", None, "aaaaaa"),
+            config.raw_multi_value("core", None, "aaaaaa"),
-            Err(GitConfigError::KeyDoesNotExist)
+            Err(lookup::existing::Error::KeyMissing)
-        );
+        ));
     }
     #[test]
     fn subsection_must_be_respected() {
         let config = GitConfig::try_from("[core]a=b\n[core.a]a=c").unwrap();
         assert_eq!(
-            config.get_raw_multi_value("core", None, "a").unwrap(),
+            config.raw_multi_value("core", None, "a").unwrap(),
             vec![Cow::Borrowed(b"b")]
         );
         assert_eq!(
-            config.get_raw_multi_value("core", Some("a"), "a").unwrap(),
+            config.raw_multi_value("core", Some("a"), "a").unwrap(),
             vec![Cow::Borrowed(b"c")]
         );
     }
     fn non_relevant_subsection_is_ignored() {
         let config = GitConfig::try_from("[core]\na=b\na=c\n[core]a=d\n[core]g=g").unwrap();
         assert_eq!(
-            config.get_raw_multi_value("core", None, "a").unwrap(),
+            config.raw_multi_value("core", None, "a").unwrap(),
             vec![Cow::Borrowed(b"b"), Cow::Borrowed(b"c"), Cow::Borrowed(b"d")]
         );
     }

git-config/tests/value/mod.rs+22−7

         file.value::<Boolean>("core", None, "bool-explicit")?,
         Boolean::False(Cow::Borrowed("false"))
     );
+    assert!(!file.boolean("core", None, "bool-explicit").expect("exists")?);
     assert_eq!(
         file.value::<Boolean>("core", None, "bool-implicit")?,
         Boolean::True(TrueVariant::Implicit)
     );
+    assert_eq!(
+        file.try_value::<Boolean>("core", None, "bool-implicit")
+            .expect("exists")?,
+        Boolean::True(TrueVariant::Implicit)
+    );
+    assert!(file.boolean("core", None, "bool-implicit").expect("present")?);
+    assert_eq!(file.try_value::<String>("doesnt", None, "exist"), None);
     assert_eq!(
         file.value::<Integer>("core", None, "integer-no-prefix")?,
         }
     );
+    assert_eq!(
+        file.string("core", None, "other").expect("present").as_ref(),
+        "hello world"
+    );
     let actual = file.value::<git_config::values::Path>("core", None, "location")?;
     assert_eq!(
-        &*actual,
+        &*actual, "~/tmp",
-        "~/tmp".as_bytes(),
         "no interpolation occurs when querying a path due to lack of context"
     );
     let expected = PathBuf::from(format!("{}/tmp", dirs::home_dir().expect("empty home dir").display()));
     assert_eq!(actual.interpolate(None).unwrap(), expected);
+    let actual = file.path("core", None, "location").expect("present");
+    assert_eq!(&*actual, "~/tmp",);
     Ok(())
 }
 fn section_names_are_case_insensitive() -> crate::Result {
     let config = "[core] bool-implicit";
     let file = GitConfig::try_from(config)?;
-    assert!(file.value::<Boolean>("core", None, "bool-implicit").is_ok());
     assert_eq!(
-        file.value::<Boolean>("core", None, "bool-implicit"),
+        file.value::<Boolean>("core", None, "bool-implicit").unwrap(),
-        file.value::<Boolean>("CORE", None, "bool-implicit")
+        file.value::<Boolean>("CORE", None, "bool-implicit").unwrap()
     );
     Ok(())
     let file = GitConfig::try_from(config)?;
     assert_eq!(file.multi_value::<Boolean>("core", None, "a")?.len(), 2);
     assert_eq!(
-        file.value::<Boolean>("core", None, "a"),
+        file.value::<Boolean>("core", None, "a").unwrap(),
-        file.value::<Boolean>("core", None, "A")
+        file.value::<Boolean>("core", None, "A").unwrap()
     );
     Ok(())

git-features/Cargo.toml+0−10

 path = "tests/pipe.rs"
 required-features = ["io-pipe"]
-[[test]]
-name = "path"
-path = "tests/path.rs"
-required-features = ["bstr"]
 [dependencies]
 #! ### Optional Dependencies
 ## make the `time` module available with access to the local time as configured by the system.
 time = { version = "0.3.2", optional = true, default-features = false, features = ["local-offset"] }
-# path
-## make bstr utilities available in the `path` modules, which itself is gated by the `path` feature.
-bstr = { version = "0.2.17", optional = true, default-features = false, features = ["std"] }
 document-features = { version = "0.2.0", optional = true }
 [target.'cfg(unix)'.dependencies]

git-features/src/lib.rs+0−1

@@ -24,7 +24,6 @@ pub mod interrupt; · 23 unmodified lines
24	#[cfg(feature = "io-pipe")]	24	#[cfg(feature = "io-pipe")]
25	pub mod io;	25	pub mod io;
26	pub mod parallel;	26	pub mod parallel;
27	pub mod path;
28	#[cfg(feature = "progress")]	27	#[cfg(feature = "progress")]
29	pub mod progress;	28	pub mod progress;
30	pub mod threading;	29	pub mod threading;

git-features/src/path.rs+0−234

@@ -1,234 +0,0 @@
1	//! ### Research
2	//!
3	//! * windows
4	//! - [`dirent.c`](https://github.com/git/git/blob/main/compat/win32/dirent.c#L31:L31) contains all implementation (seemingly) of opening directories and reading their entries, along with all path conversions (UTF-16 for windows). This is done on the fly so git can work with [in UTF-8](https://github.com/git/git/blob/main/compat/win32/dirent.c#L12:L12).
5	//! - mingw [is used for the conversion](https://github.com/git/git/blob/main/compat/mingw.h#L579:L579) and it appears they handle surrogates during the conversion, maybe some sort of non-strict UTF-8 converter? Actually it uses [WideCharToMultiByte](https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-widechartomultibyte)
6	//! under the hood which by now does fail if the UTF-8 would be invalid unicode, i.e. unicode pairs.
7	//! - `OsString` on windows already stores strings as WTF-8, which supports [surrogate pairs](https://unicodebook.readthedocs.io/unicode_encodings.html),
8	//! something that UTF-8 isn't allowed do it for security reasons, after all it's UTF-16 specific and exists only to extend
9	//! the encodable code-points.
10	//! - informative reading on [WTF-8](https://simonsapin.github.io/wtf-8/#motivation) which is the encoding used by Rust
11	//! internally that deals with surrogates and non-wellformed surrogates (those that aren't in pairs).
12	//! * unix
13	//! - It uses [opendir](https://man7.org/linux/man-pages/man3/opendir.3.html) and [readdir](https://man7.org/linux/man-pages/man3/readdir.3.html)
14	//! respectively. There is no encoding specified, except that these paths are null-terminated.
15	//!
16	//! ### Learnings
17	//!
18	//! Surrogate pairs are a way to extend the encodable value range in UTF-16 encodings, used primarily on windows and in Javascript.
19	//! For a long time these codepoints used for surrogates, always to be used in pairs, were not assigned, until…they were for rare
20	//! emojies and the likes. The unicode standard does not require surrogates to happen in pairs, even though by now unpaired surrogates
21	//! in UTF-16 are considered ill-formed, which aren't supposed to be converted to UTF-8 for example.
22	//!
23	//! This is the reason we have to deal with `to_string_lossy()`, it's _just_ for that quirk.
24	//!
25	//! This also means the only platform ever eligible to see conversion errors is windows, and there it's only older pre-vista
26	//! windows versions which incorrectly allow ill-formed UTF-16 strings. Newer versions don't perform such conversions anymore, for
27	//! example when going from UTF-16 to UTF-8, they will trigger an error.
28	//!
29	//! ### Conclusions
30	//!
31	//! Since [WideCharToMultiByte](https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-widechartomultibyte) by now is
32	//! fixed (Vista onward) to produce valid UTF-8, lone surrogate codepoints will cause failure, which `git`
33	//! [doesn't care about](https://github.com/git/git/blob/main/compat/win32/dirent.c#L12:L12).
34	//!
35	//! We will, though, which means from now on we can just convert to UTF-8 on windows and bubble up errors where necessary,
36	//! preventing potential mismatched surrogate pairs to ever be saved on disk by gitoxide.
37	//!
38	//! Even though the error only exists on older windows versions, we will represent it in the type system through fallible function calls.
39	//! Callers may `.expect()` on the result to indicate they don't wish to handle this special and rare case. Note that servers should not
40	//! ever get into a code-path which does panic though.
41
42	use std::{
43	borrow::Cow,
44	ffi::OsStr,
45	path::{Path, PathBuf},
46	};
47
48	#[derive(Debug)]
49	/// The error type returned by [`into_bytes()`] and others may suffer from failed conversions from or to bytes.
50	pub struct Utf8Error;
51
52	impl std::fmt::Display for Utf8Error {
53	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54	f.write_str("Could not convert to UTF8 or from UTF8 due to ill-formed input")
55	}
56	}
57
58	impl std::error::Error for Utf8Error {}
59
60	/// Like [`into_bytes()`], but takes `OsStr` as input for a lossless, but fallible, conversion.
61	pub fn os_str_into_bytes(path: &OsStr) -> Result<&[u8], Utf8Error> {
62	let path = into_bytes(Cow::Borrowed(path.as_ref()))?;
63	match path {
64	Cow::Borrowed(path) => Ok(path),
65	Cow::Owned(_) => unreachable!("borrowed cows stay borrowed"),
66	}
67	}
68
69	/// Convert the given path either into its raw bytes on unix or its UTF8 encoded counterpart on windows.
70	///
71	/// On windows, if the source Path contains ill-formed, lone surrogates, the UTF-8 conversion will fail
72	/// causing `Utf8Error` to be returned.
73	pub fn into_bytes<'a>(path: impl Into<Cow<'a, Path>>) -> Result<Cow<'a, [u8]>, Utf8Error> {
74	let path = path.into();
75	let utf8_bytes = match path {
76	Cow::Owned(path) => Cow::Owned({
77	#[cfg(unix)]
78	let p = {
79	use std::os::unix::ffi::OsStringExt;
80	path.into_os_string().into_vec()
81	};
82	#[cfg(not(unix))]
83	let p: Vec<_> = path.into_os_string().into_string().map_err(\|_\| Utf8Error)?.into();
84	p
85	}),
86	Cow::Borrowed(path) => Cow::Borrowed({
87	#[cfg(unix)]
88	let p = {
89	use std::os::unix::ffi::OsStrExt;
90	path.as_os_str().as_bytes()
91	};
92	#[cfg(not(unix))]
93	let p = path.to_str().ok_or(Utf8Error)?.as_bytes();
94	p
95	}),
96	};
97	Ok(utf8_bytes)
98	}
99
100	/// Similar to [`into_bytes()`] but panics if malformed surrogates are encountered on windows.
101	pub fn into_bytes_or_panic_on_windows<'a>(path: impl Into<Cow<'a, Path>>) -> Cow<'a, [u8]> {
102	into_bytes(path).expect("prefix path doesn't contain ill-formed UTF-8")
103	}
104
105	/// Given `input` bytes, produce a `Path` from them ignoring encoding entirely if on unix.
106	///
107	/// On windows, the input is required to be valid UTF-8, which is guaranteed if we wrote it before. There are some potential
108	/// git versions and windows installation which produce mal-formed UTF-16 if certain emojies are in the path. It's as rare as
109	/// it sounds, but possible.
110	pub fn from_byte_slice(input: &[u8]) -> Result<&Path, Utf8Error> {
111	#[cfg(unix)]
112	let p = {
113	use std::os::unix::ffi::OsStrExt;
114	OsStr::from_bytes(input).as_ref()
115	};
116	#[cfg(not(unix))]
117	let p = Path::new(std::str::from_utf8(input).map_err(\|_\| Utf8Error)?);
118	Ok(p)
119	}
120
121	/// Similar to [`from_byte_slice()`], but takes either borrowed or owned `input`.
122	pub fn from_bytes<'a>(input: impl Into<Cow<'a, [u8]>>) -> Result<Cow<'a, Path>, Utf8Error> {
123	let input = input.into();
124	match input {
125	Cow::Borrowed(input) => from_byte_slice(input).map(Cow::Borrowed),
126	Cow::Owned(input) => from_byte_vec(input).map(Cow::Owned),
127	}
128	}
129
130	/// Similar to [`from_byte_slice()`], but takes either borrowed or owned `input` as bstr.
131	#[cfg(feature = "bstr")]
132	pub fn from_bstr<'a>(input: impl Into<Cow<'a, bstr::BStr>>) -> Result<Cow<'a, Path>, Utf8Error> {
133	let input = input.into();
134	match input {
135	Cow::Borrowed(input) => from_byte_slice(input).map(Cow::Borrowed),
136	Cow::Owned(input) => from_byte_vec(input).map(Cow::Owned),
137	}
138	}
139
140	/// Similar to [`from_byte_slice()`], but takes and produces owned data.
141	pub fn from_byte_vec(input: impl Into<Vec<u8>>) -> Result<PathBuf, Utf8Error> {
142	let input = input.into();
143	#[cfg(unix)]
144	let p = {
145	use std::os::unix::ffi::OsStringExt;
146	std::ffi::OsString::from_vec(input).into()
147	};
148	#[cfg(not(unix))]
149	let p = PathBuf::from(String::from_utf8(input).map_err(\|_\| Utf8Error)?);
150	Ok(p)
151	}
152
153	/// Similar to [`from_byte_vec()`], but will panic if there is ill-formed UTF-8 in the `input`.
154	pub fn from_byte_vec_or_panic_on_windows(input: impl Into<Vec<u8>>) -> PathBuf {
155	from_byte_vec(input).expect("well-formed UTF-8 on windows")
156	}
157
158	/// Similar to [`from_byte_slice()`], but will panic if there is ill-formed UTF-8 in the `input`.
159	pub fn from_byte_slice_or_panic_on_windows(input: &[u8]) -> &Path {
160	from_byte_slice(input).expect("well-formed UTF-8 on windows")
161	}
162
163	/// Methods to handle paths as bytes and do conversions between them.
164	pub mod convert {
165	use std::borrow::Cow;
166
167	fn replace<'a>(path: impl Into<Cow<'a, [u8]>>, find: u8, replace: u8) -> Cow<'a, [u8]> {
168	let path = path.into();
169	match path {
170	Cow::Owned(mut path) => {
171	for b in path.iter_mut().filter(\|b\| **b == find) {
172	*b = replace;
173	}
174	path.into()
175	}
176	Cow::Borrowed(path) => {
177	if !path.contains(&find) {
178	return path.into();
179	}
180	let mut path = path.to_owned();
181	for b in path.iter_mut().filter(\|b\| **b == find) {
182	*b = replace;
183	}
184	path.into()
185	}
186	}
187	}
188
189	/// Replaces windows path separators with slashes.
190	pub fn to_native_separators<'a>(path: impl Into<Cow<'a, [u8]>>) -> Cow<'a, [u8]> {
191	#[cfg(not(windows))]
192	let p = to_unix_separators(path);
193	#[cfg(windows)]
194	let p = to_windows_separators(path);
195	p
196	}
197
198	/// Convert paths with slashes to backslashes on windows and do nothing on unix.
199	pub fn to_windows_separators_on_windows_or_panic(path: &std::path::Path) -> Cow<'_, std::path::Path> {
200	#[cfg(not(windows))]
201	{
202	path.into()
203	}
204	#[cfg(windows)]
205	{
206	crate::path::from_byte_slice_or_panic_on_windows(
207	crate::path::convert::to_windows_separators(crate::path::into_bytes_or_panic_on_windows(path)).as_ref(),
208	)
209	.to_owned()
210	.into()
211	}
212	}
213
214	/// Replaces windows path separators with slashes.
215	pub fn to_unix_separators<'a>(path: impl Into<Cow<'a, [u8]>>) -> Cow<'a, [u8]> {
216	replace(path, b'\\', b'/')
217	}
218
219	/// Find backslashes and replace them with slashes, which typically resembles a unix path.
220	///
221	/// No other transformation is performed, the caller must check other invariants.
222	pub fn to_windows_separators<'a>(path: impl Into<Cow<'a, [u8]>>) -> Cow<'a, [u8]> {
223	replace(path, b'/', b'\\')
224	}
225
226	/// Obtain a `BStr` compatible `Cow` from one that is bytes.
227	#[cfg(feature = "bstr")]
228	pub fn into_bstr(path: Cow<'_, [u8]>) -> Cow<'_, bstr::BStr> {
229	match path {
230	Cow::Owned(p) => Cow::Owned(p.into()),
231	Cow::Borrowed(p) => Cow::Borrowed(p.into()),
232	}
233	}
234	}

git-features/tests/path.rs+0−30

@@ -1,30 +0,0 @@
1	mod bytes {
2	use bstr::ByteSlice;
3	use git_features::path;
4
5	#[test]
6	fn assure_unix_separators() {
7	assert_eq!(
8	path::convert::to_unix_separators(b"no-backslash".as_ref()).as_bstr(),
9	"no-backslash"
10	);
11
12	assert_eq!(
13	path::convert::to_unix_separators(b"\\a\\b\\\\".as_ref()).as_bstr(),
14	"/a/b//"
15	);
16	}
17
18	#[test]
19	fn assure_windows_separators() {
20	assert_eq!(
21	path::convert::to_windows_separators(b"no-backslash".as_ref()).as_bstr(),
22	"no-backslash"
23	);
24
25	assert_eq!(
26	path::convert::to_windows_separators(b"/a/b//".as_ref()).as_bstr(),
27	"\\a\\b\\\\"
28	);
29	}
30	}

git-glob/src/lib.rs+6−4

 use bstr::BString;
-/// A glob pattern at a particular base path.
+/// A glob pattern optimized for matching paths relative to a root directory.
 ///
-/// This closely models how patterns appear in a directory hierarchy of include or attribute files.
+/// For normal globbing, use [`wildmatch()`] instead.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct Pattern {
 mod parse;
 /// Create a [`Pattern`] by parsing `text` or return `None` if `text` is empty.
-pub fn parse(text: &[u8]) -> Option<Pattern> {
+///
-    Pattern::from_bytes(text)
+/// Note that
+pub fn parse(text: impl AsRef<[u8]>) -> Option<Pattern> {
+    Pattern::from_bytes(text.as_ref())
 }

git-glob/src/parse.rs+3−3

     }
     if pat.first() == Some(&b'/') {
         mode |= Mode::ABSOLUTE;
+        pat = &pat[1..];
     }
     let mut pat = truncate_non_escaped_trailing_spaces(pat);
     if pat.last() == Some(&b'/') {
         pat.pop();
     }
-    let relative_pattern = mode.contains(Mode::ABSOLUTE).then(|| &pat[1..]).unwrap_or(&pat);
+    if !pat.contains(&b'/') {
-    if !relative_pattern.contains(&b'/') {
         mode |= Mode::NO_SUB_DIR;
     }
-    if relative_pattern.first() == Some(&b'*') && first_wildcard_pos(&relative_pattern[1..]).is_none() {
+    if pat.first() == Some(&b'*') && first_wildcard_pos(&pat[1..]).is_none() {
         mode |= Mode::ENDS_WITH;
     }

git-glob/src/pattern.rs+37−34

 use bitflags::bitflags;
 use bstr::{BStr, ByteSlice};
+use std::fmt;
 use crate::{pattern, wildmatch, Pattern};
     Fold,
 }
+impl Default for Case {
+    fn default() -> Self {
+        Case::Sensitive
+    }
+}
 impl Pattern {
     /// Parse the given `text` as pattern, or return `None` if `text` was empty.
     pub fn from_bytes(text: &[u8]) -> Option<Self> {
     /// `basename_start_pos` is the index at which the `path`'s basename starts.
     ///
     /// Lastly, `case` folding can be configured as well.
-    ///
-    /// Note that this method uses shortcuts to accelerate simple patterns.
     pub fn matches_repo_relative_path<'a>(
         &self,
         path: impl Into<&'a BStr>,
         basename_start_pos: Option<usize>,
-        is_dir: bool,
+        is_dir: Option<bool>,
         case: Case,
     ) -> bool {
+        let is_dir = is_dir.unwrap_or(false);
         if !is_dir && self.mode.contains(pattern::Mode::MUST_BE_DIR) {
             return false;
         }
         );
         debug_assert!(!path.starts_with(b"/"), "input path must be relative");
-        let (text, first_wildcard_pos) = self
+        if self.mode.contains(pattern::Mode::NO_SUB_DIR) && !self.mode.contains(pattern::Mode::ABSOLUTE) {
-            .mode
+            let basename = &path[basename_start_pos.unwrap_or_default()..];
-            .contains(pattern::Mode::ABSOLUTE)
+            self.matches(basename, flags)
-            .then(|| (self.text[1..].as_bstr(), self.first_wildcard_pos.map(|p| p - 1)))
-            .unwrap_or((self.text.as_bstr(), self.first_wildcard_pos));
-        if self.mode.contains(pattern::Mode::NO_SUB_DIR) {
-            let basename = if self.mode.contains(pattern::Mode::ABSOLUTE) {
-                path
-            } else {
-                &path[basename_start_pos.unwrap_or_default()..]
-            };
-            self.matches_inner(text, first_wildcard_pos, basename, flags)
         } else {
-            self.matches_inner(text, first_wildcard_pos, path, flags)
+            self.matches(path, flags)
         }
     }
     /// strings with cases ignored as well. Note that the case folding performed here is ASCII only.
     ///
     /// Note that this method uses some shortcuts to accelerate simple patterns.
-    pub fn matches<'a>(&self, value: impl Into<&'a BStr>, mode: wildmatch::Mode) -> bool {
+    fn matches<'a>(&self, value: impl Into<&'a BStr>, mode: wildmatch::Mode) -> bool {
-        self.matches_inner(self.text.as_bstr(), self.first_wildcard_pos, value, mode)
-    }
-    fn matches_inner<'a>(
-        &self,
-        text: &BStr,
-        first_wildcard_pos: Option<usize>,
-        value: impl Into<&'a BStr>,
-        mode: wildmatch::Mode,
-    ) -> bool {
         let value = value.into();
-        match first_wildcard_pos {
+        match self.first_wildcard_pos {
             // "*literal" case, overrides starts-with
             Some(pos) if self.mode.contains(pattern::Mode::ENDS_WITH) && !value.contains(&b'/') => {
-                let text = &text[pos + 1..];
+                let text = &self.text[pos + 1..];
                 if mode.contains(wildmatch::Mode::IGNORE_CASE) {
                     value
                         .len()
                 if mode.contains(wildmatch::Mode::IGNORE_CASE) {
                     if !value
                         .get(..pos)
-                        .map_or(false, |value| value.eq_ignore_ascii_case(&text[..pos]))
+                        .map_or(false, |value| value.eq_ignore_ascii_case(&self.text[..pos]))
                     {
                         return false;
                     }
-                } else if !value.starts_with(&text[..pos]) {
+                } else if !value.starts_with(&self.text[..pos]) {
                     return false;
                 }
-                crate::wildmatch(text.as_bstr(), value, mode)
+                crate::wildmatch(self.text.as_bstr(), value, mode)
             }
             None => {
                 if mode.contains(wildmatch::Mode::IGNORE_CASE) {
-                    text.eq_ignore_ascii_case(value)
+                    self.text.eq_ignore_ascii_case(value)
                 } else {
-                    text == value
+                    self.text == value
                 }
             }
         }
     }
 }
+impl fmt::Display for Pattern {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.mode.contains(Mode::NEGATIVE) {
+            "!".fmt(f)?;
+        }
+        if self.mode.contains(Mode::ABSOLUTE) {
+            "/".fmt(f)?;
+        }
+        self.text.fmt(f)?;
+        if self.mode.contains(Mode::MUST_BE_DIR) {
+            "/".fmt(f)?;
+        }
+        Ok(())
+    }
+}

git-glob/tests/fixtures/generated-archives/make_baseline.tar.xz+2−2

@@ -1,3 +1,3 @@
1	version https://git-lfs.github.com/spec/v1	1	version https://git-lfs.github.com/spec/v1
2	oid sha256:cdade0fe7f3df3ac737130a101b077c82f9de1dcb3d59d5964e5ffd920405e8d	2	oid sha256:6bda59c1591dfd35f09cad5d09e2950b2a6ff885d9f7900535144a5275ab51c3
3	size 10384	3	size 10428

git-glob/tests/fixtures/make_baseline.sh+5−2

   echo "$pattern" > .gitignore
   echo "$value" | git check-ignore -vn --stdin 2>&1 || :
 done <<EOF >git-baseline.nmatch
-*/\ XXX/\
+/*foo bam/barfoo/baz/bam
-*/\\ XXX/\
+/*foo bar/bam/barfoo/baz/bam
+foo foobaz
+*/\' XXX/\'
 /*foo bar/foo
 /*foo bar/bazfoo
 foo*bar foo/baz/bar
   echo "$pattern" > .gitignore
   echo "$value" | git check-ignore -vn --stdin 2>&1 || :
 done <<EOF >git-baseline.match
+*/' XXX/'
 \a  a
 \\\[a-z] \a
 \\\? \a

git-glob/tests/glob.rs+1−1

@@ -1,3 +1,3 @@
1	mod matching;
2	mod parse;	1	mod parse;
		2	mod pattern;
3	mod wildmatch;	3	mod wildmatch;

git-glob/tests/matching/mod.rs+0−279

@@ -1,280 +1 @@
1	use std::collections::BTreeSet;
2		1
3	use bstr::{BStr, ByteSlice};
4	use git_glob::{pattern, pattern::Case};
5
6	#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Copy, Clone)]
7	pub struct GitMatch<'a> {
8	pattern: &'a BStr,
9	value: &'a BStr,
10	/// True if git could match `value` with `pattern`
11	is_match: bool,
12	}
13
14	pub struct Baseline<'a> {
15	inner: bstr::Lines<'a>,
16	}
17
18	impl<'a> Iterator for Baseline<'a> {
19	type Item = GitMatch<'a>;
20
21	fn next(&mut self) -> Option<Self::Item> {
22	let mut tokens = self.inner.next()?.splitn(2, \|b\| *b == b' ');
23	let pattern = tokens.next().expect("pattern").as_bstr();
24	let value = tokens.next().expect("value").as_bstr().trim_start().as_bstr();
25
26	let git_match = self.inner.next()?;
27	let is_match = !git_match.starts_with(b"::\t");
28	Some(GitMatch {
29	pattern,
30	value,
31	is_match,
32	})
33	}
34	}
35
36	impl<'a> Baseline<'a> {
37	fn new(input: &'a [u8]) -> Self {
38	Baseline {
39	inner: input.as_bstr().lines(),
40	}
41	}
42	}
43
44	#[test]
45	fn compare_baseline_with_ours() {
46	let dir = git_testtools::scripted_fixture_repo_read_only("make_baseline.sh").unwrap();
47	let (mut total_matches, mut total_correct, mut panics) = (0, 0, 0);
48	let mut mismatches = Vec::new();
49	for (input_file, expected_matches, case) in &[
50	("git-baseline.match", true, pattern::Case::Sensitive),
51	("git-baseline.nmatch", false, pattern::Case::Sensitive),
52	("git-baseline.match-icase", true, pattern::Case::Fold),
53	] {
54	let input = std::fs::read(dir.join(*input_file)).unwrap();
55	let mut seen = BTreeSet::default();
56
57	for m @ GitMatch {
58	pattern,
59	value,
60	is_match,
61	} in Baseline::new(&input)
62	{
63	total_matches += 1;
64	assert!(seen.insert(m), "duplicate match entry: {:?}", m);
65	assert_eq!(
66	is_match, *expected_matches,
67	"baseline for matches must be {} - check baseline and git version: {:?}",
68	expected_matches, m
69	);
70	match std::panic::catch_unwind(\|\| {
71	let pattern = pat(pattern);
72	pattern.matches_repo_relative_path(
73	value,
74	basename_start_pos(value),
75	false, // TODO: does it make sense to pretend it is a dir and see what happens?
76	*case,
77	)
78	}) {
79	Ok(actual_match) => {
80	if actual_match == is_match {
81	total_correct += 1;
82	} else {
83	mismatches.push((pattern.to_owned(), value.to_owned(), is_match, expected_matches));
84	}
85	}
86	Err(_) => {
87	panics += 1;
88	continue;
89	}
90	};
91	}
92	}
93
94	dbg!(mismatches);
95	assert_eq!(
96	total_correct,
97	total_matches - panics,
98	"We perfectly agree with git here"
99	);
100	assert_eq!(panics, 0);
101	}
102
103	#[test]
104	fn non_dirs_for_must_be_dir_patterns_are_ignored() {
105	let pattern = pat("hello/");
106
107	assert!(pattern.mode.contains(pattern::Mode::MUST_BE_DIR));
108	assert_eq!(
109	pattern.text, "hello",
110	"a dir pattern doesn't actually end with the trailing slash"
111	);
112	let path = "hello";
113	assert!(
114	!pattern.matches_repo_relative_path(path, None, false /* is-dir */, Case::Sensitive),
115	"non-dirs never match a dir pattern"
116	);
117	assert!(
118	pattern.matches_repo_relative_path(path, None, true /* is-dir */, Case::Sensitive),
119	"dirs can match a dir pattern with the normal rules"
120	);
121	}
122
123	#[test]
124	fn matches_of_absolute_paths_work() {
125	let input = "/hello/git";
126	let pat = pat(input);
127	assert!(
128	pat.matches(input, git_glob::wildmatch::Mode::empty()),
129	"patterns always match themselves"
130	);
131	assert!(
132	pat.matches(input, git_glob::wildmatch::Mode::NO_MATCH_SLASH_LITERAL),
133	"patterns always match themselves, path mode doesn't change that"
134	);
135	}
136
137	#[test]
138	fn basename_matches_from_end() {
139	let pat = &pat("foo");
140	assert!(match_file(pat, "FoO", Case::Fold));
141	assert!(!match_file(pat, "FoOo", Case::Fold));
142	assert!(!match_file(pat, "Foo", Case::Sensitive));
143	assert!(match_file(pat, "foo", Case::Sensitive));
144	assert!(!match_file(pat, "Foo", Case::Sensitive));
145	assert!(!match_file(pat, "barfoo", Case::Sensitive));
146	}
147
148	#[test]
149	fn absolute_basename_matches_only_from_beginning() {
150	let pat = &pat("/foo");
151	assert!(match_file(pat, "FoO", Case::Fold));
152	assert!(!match_file(pat, "bar/Foo", Case::Fold));
153	assert!(match_file(pat, "foo", Case::Sensitive));
154	assert!(!match_file(pat, "Foo", Case::Sensitive));
155	assert!(!match_file(pat, "bar/foo", Case::Sensitive));
156	}
157
158	#[test]
159	fn absolute_path_matches_only_from_beginning() {
160	let pat = &pat("/bar/foo");
161	assert!(!match_file(pat, "FoO", Case::Fold));
162	assert!(match_file(pat, "bar/Foo", Case::Fold));
163	assert!(!match_file(pat, "foo", Case::Sensitive));
164	assert!(match_file(pat, "bar/foo", Case::Sensitive));
165	assert!(!match_file(pat, "bar/Foo", Case::Sensitive));
166	}
167
168	#[test]
169	fn absolute_path_with_recursive_glob_detects_mismatches_quickly() {
170	let pat = &pat("/bar/foo/**");
171	assert!(!match_file(pat, "FoO", Case::Fold));
172	assert!(!match_file(pat, "bar/Fooo", Case::Fold));
173	assert!(!match_file(pat, "baz/bar/Foo", Case::Fold));
174	}
175
176	#[test]
177	fn absolute_path_with_recursive_glob_can_do_case_insensitive_prefix_search() {
178	let pat = &pat("/bar/foo/**");
179	assert!(!match_file(pat, "bar/Foo/match", Case::Sensitive));
180	assert!(match_file(pat, "bar/Foo/match", Case::Fold));
181	}
182
183	#[test]
184	fn relative_path_does_not_match_from_end() {
185	let pattern = &pat("bar/foo");
186	assert!(!match_file(pattern, "FoO", Case::Fold));
187	assert!(match_file(pattern, "bar/Foo", Case::Fold));
188	assert!(!match_file(pattern, "baz/bar/Foo", Case::Fold));
189	assert!(!match_file(pattern, "foo", Case::Sensitive));
190	assert!(match_file(pattern, "bar/foo", Case::Sensitive));
191	assert!(!match_file(pattern, "baz/bar/foo", Case::Sensitive));
192	assert!(!match_file(pattern, "Baz/bar/Foo", Case::Sensitive));
193	}
194
195	#[test]
196	fn basename_glob_and_literal_is_ends_with() {
197	let pattern = &pat("*foo");
198	assert!(match_file(pattern, "FoO", Case::Fold));
199	assert!(match_file(pattern, "BarFoO", Case::Fold));
200	assert!(!match_file(pattern, "BarFoOo", Case::Fold));
201	assert!(!match_file(pattern, "Foo", Case::Sensitive));
202	assert!(!match_file(pattern, "BarFoo", Case::Sensitive));
203	assert!(match_file(pattern, "barfoo", Case::Sensitive));
204	assert!(!match_file(pattern, "barfooo", Case::Sensitive));
205
206	assert!(match_file(pattern, "bar/foo", Case::Sensitive));
207	assert!(match_file(pattern, "bar/bazfoo", Case::Sensitive));
208	}
209
210	#[test]
211	fn special_cases_from_corpus() {
212	let pattern = &pat("foo*bar");
213	assert!(
214	!match_file(pattern, "foo/baz/bar", Case::Sensitive),
215	"asterisk does not match path separators"
216	);
217	let pattern = &pat("*some/path/to/hello.txt");
218	assert!(
219	!match_file(pattern, "a/bigger/some/path/to/hello.txt", Case::Sensitive),
220	"asterisk doesn't match path separators"
221	);
222
223	let pattern = &pat("/*foo.txt");
224	assert!(match_file(pattern, "hello-foo.txt", Case::Sensitive));
225	assert!(
226	!match_file(pattern, "hello/foo.txt", Case::Sensitive),
227	"absolute single asterisk doesn't match paths"
228	);
229	}
230
231	#[test]
232	fn absolute_basename_glob_and_literal_is_ends_with_in_basenames() {
233	let pattern = &pat("/*foo");
234
235	assert!(match_file(pattern, "FoO", Case::Fold));
236	assert!(match_file(pattern, "BarFoO", Case::Fold));
237	assert!(!match_file(pattern, "BarFoOo", Case::Fold));
238	assert!(!match_file(pattern, "Foo", Case::Sensitive));
239	assert!(!match_file(pattern, "BarFoo", Case::Sensitive));
240	assert!(match_file(pattern, "barfoo", Case::Sensitive));
241	assert!(!match_file(pattern, "barfooo", Case::Sensitive));
242	}
243
244	#[test]
245	fn absolute_basename_glob_and_literal_is_glob_in_paths() {
246	let pattern = &pat("/*foo");
247
248	assert!(!match_file(pattern, "bar/foo", Case::Sensitive), "* does not match /");
249	assert!(!match_file(pattern, "bar/bazfoo", Case::Sensitive));
250	}
251
252	#[test]
253	fn negated_patterns_are_handled_by_caller() {
254	let pattern = &pat("!foo");
255	assert!(
256	match_file(pattern, "foo", Case::Sensitive),
257	"negative patterns match like any other"
258	);
259	assert!(
260	pattern.is_negative(),
261	"the caller checks for the negative flag and acts accordingly"
262	);
263	}
264
265	fn pat<'a>(pattern: impl Into<&'a BStr>) -> git_glob::Pattern {
266	git_glob::Pattern::from_bytes(pattern.into()).expect("parsing works")
267	}
268
269	fn match_file<'a>(pattern: &git_glob::Pattern, path: impl Into<&'a BStr>, case: Case) -> bool {
270	match_path(pattern, path, false, case)
271	}
272
273	fn match_path<'a>(pattern: &git_glob::Pattern, path: impl Into<&'a BStr>, is_dir: bool, case: Case) -> bool {
274	let path = path.into();
275	pattern.matches_repo_relative_path(path, basename_start_pos(path), is_dir, case)
276	}
277
278	fn basename_start_pos(value: &BStr) -> Option<usize> {
279	value.rfind_byte(b'/').map(\|pos\| pos + 1)
280	}

git-glob/tests/parse/mod.rs+2−2

@@ -77,12 +77,12 @@ fn leading_exclamation_marks_can_be_escaped_with_backslash() { · 76 unmodified lines
77	fn leading_slashes_mark_patterns_as_absolute() {	77	fn leading_slashes_mark_patterns_as_absolute() {
78	assert_eq!(	78	assert_eq!(
79	git_glob::parse(br"/absolute"),	79	git_glob::parse(br"/absolute"),
80	pat("/absolute", Mode::NO_SUB_DIR \| Mode::ABSOLUTE, None)	80	pat("absolute", Mode::NO_SUB_DIR \| Mode::ABSOLUTE, None)
81	);	81	);
82		82
83	assert_eq!(	83	assert_eq!(
84	git_glob::parse(br"/absolute/path"),	84	git_glob::parse(br"/absolute/path"),
85	pat("/absolute/path", Mode::ABSOLUTE, None)	85	pat("absolute/path", Mode::ABSOLUTE, None)
86	);	86	);
87	}	87	}
88		88

git-glob/tests/pattern/matching.rs+326−0

@@ -0,0 +1,326 @@
	1	use std::collections::BTreeSet;
	2
	3	use bstr::{BStr, ByteSlice};
	4	use git_glob::{pattern, pattern::Case};
	5
	6	#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Copy, Clone)]
	7	pub struct GitMatch<'a> {
	8	pattern: &'a BStr,
	9	value: &'a BStr,
	10	/// True if git could match `value` with `pattern`
	11	is_match: bool,
	12	}
	13
	14	pub struct Baseline<'a> {
	15	inner: bstr::Lines<'a>,
	16	}
	17
	18	impl<'a> Iterator for Baseline<'a> {
	19	type Item = GitMatch<'a>;
	20
	21	fn next(&mut self) -> Option<Self::Item> {
	22	let mut tokens = self.inner.next()?.splitn(2, \|b\| *b == b' ');
	23	let pattern = tokens.next().expect("pattern").as_bstr();
	24	let value = tokens.next().expect("value").as_bstr().trim_start().as_bstr();
	25
	26	let git_match = self.inner.next()?;
	27	let is_match = !git_match.starts_with(b"::\t");
	28	Some(GitMatch {
	29	pattern,
	30	value,
	31	is_match,
	32	})
	33	}
	34	}
	35
	36	impl<'a> Baseline<'a> {
	37	fn new(input: &'a [u8]) -> Self {
	38	Baseline {
	39	inner: input.as_bstr().lines(),
	40	}
	41	}
	42	}
	43
	44	#[test]
	45	fn compare_baseline_with_ours() {
	46	let dir = git_testtools::scripted_fixture_repo_read_only("make_baseline.sh").unwrap();
	47	let (mut total_matches, mut total_correct, mut panics) = (0, 0, 0);
	48	let mut mismatches = Vec::new();
	49	for (input_file, expected_matches, case) in &[
	50	("git-baseline.match", true, pattern::Case::Sensitive),
	51	("git-baseline.nmatch", false, pattern::Case::Sensitive),
	52	("git-baseline.match-icase", true, pattern::Case::Fold),
	53	] {
	54	let input = std::fs::read(dir.join(*input_file)).unwrap();
	55	let mut seen = BTreeSet::default();
	56
	57	for m @ GitMatch {
	58	pattern,
	59	value,
	60	is_match,
	61	} in Baseline::new(&input)
	62	{
	63	total_matches += 1;
	64	assert!(seen.insert(m), "duplicate match entry: {:?}", m);
	65	assert_eq!(
	66	is_match, *expected_matches,
	67	"baseline for matches must be {} - check baseline and git version: {:?}",
	68	expected_matches, m
	69	);
	70	match std::panic::catch_unwind(\|\| {
	71	let pattern = pat(pattern);
	72	pattern.matches_repo_relative_path(value, basename_start_pos(value), None, *case)
	73	}) {
	74	Ok(actual_match) => {
	75	if actual_match == is_match {
	76	total_correct += 1;
	77	} else {
	78	mismatches.push((pattern.to_owned(), value.to_owned(), is_match, expected_matches));
	79	}
	80	}
	81	Err(_) => {
	82	panics += 1;
	83	continue;
	84	}
	85	};
	86	}
	87	}
	88
	89	dbg!(mismatches);
	90	assert_eq!(
	91	total_correct,
	92	total_matches - panics,
	93	"We perfectly agree with git here"
	94	);
	95	assert_eq!(panics, 0);
	96	}
	97
	98	#[test]
	99	fn non_dirs_for_must_be_dir_patterns_are_ignored() {
	100	let pattern = pat("hello/");
	101
	102	assert!(pattern.mode.contains(pattern::Mode::MUST_BE_DIR));
	103	assert_eq!(
	104	pattern.text, "hello",
	105	"a dir pattern doesn't actually end with the trailing slash"
	106	);
	107	let path = "hello";
	108	assert!(
	109	!pattern.matches_repo_relative_path(path, None, false.into() /* is-dir */, Case::Sensitive),
	110	"non-dirs never match a dir pattern"
	111	);
	112	assert!(
	113	pattern.matches_repo_relative_path(path, None, true.into() /* is-dir */, Case::Sensitive),
	114	"dirs can match a dir pattern with the normal rules"
	115	);
	116	}
	117
	118	#[test]
	119	fn matches_of_absolute_paths_work() {
	120	let pattern = "/hello/git";
	121	assert!(
	122	git_glob::wildmatch(pattern.into(), pattern.into(), git_glob::wildmatch::Mode::empty()),
	123	"patterns always match themselves"
	124	);
	125	assert!(
	126	git_glob::wildmatch(
	127	pattern.into(),
	128	pattern.into(),
	129	git_glob::wildmatch::Mode::NO_MATCH_SLASH_LITERAL
	130	),
	131	"patterns always match themselves, path mode doesn't change that"
	132	);
	133	}
	134
	135	#[test]
	136	fn basename_matches_from_end() {
	137	let pat = &pat("foo");
	138	assert!(match_file(pat, "FoO", Case::Fold));
	139	assert!(!match_file(pat, "FoOo", Case::Fold));
	140	assert!(!match_file(pat, "Foo", Case::Sensitive));
	141	assert!(match_file(pat, "foo", Case::Sensitive));
	142	assert!(!match_file(pat, "Foo", Case::Sensitive));
	143	assert!(!match_file(pat, "barfoo", Case::Sensitive));
	144	}
	145
	146	#[test]
	147	fn absolute_basename_matches_only_from_beginning() {
	148	let pat = &pat("/foo");
	149	assert!(match_file(pat, "FoO", Case::Fold));
	150	assert!(!match_file(pat, "bar/Foo", Case::Fold));
	151	assert!(match_file(pat, "foo", Case::Sensitive));
	152	assert!(!match_file(pat, "Foo", Case::Sensitive));
	153	assert!(!match_file(pat, "bar/foo", Case::Sensitive));
	154	}
	155
	156	#[test]
	157	fn absolute_path_matches_only_from_beginning() {
	158	let pat = &pat("/bar/foo");
	159	assert!(!match_file(pat, "FoO", Case::Fold));
	160	assert!(match_file(pat, "bar/Foo", Case::Fold));
	161	assert!(!match_file(pat, "foo", Case::Sensitive));
	162	assert!(match_file(pat, "bar/foo", Case::Sensitive));
	163	assert!(!match_file(pat, "bar/Foo", Case::Sensitive));
	164	}
	165
	166	#[test]
	167	fn absolute_path_with_recursive_glob_detects_mismatches_quickly() {
	168	let pat = &pat("/bar/foo/**");
	169	assert!(!match_file(pat, "FoO", Case::Fold));
	170	assert!(!match_file(pat, "bar/Fooo", Case::Fold));
	171	assert!(!match_file(pat, "baz/bar/Foo", Case::Fold));
	172	}
	173
	174	#[test]
	175	fn absolute_path_with_recursive_glob_can_do_case_insensitive_prefix_search() {
	176	let pat = &pat("/bar/foo/**");
	177	assert!(!match_file(pat, "bar/Foo/match", Case::Sensitive));
	178	assert!(match_file(pat, "bar/Foo/match", Case::Fold));
	179	}
	180
	181	#[test]
	182	fn relative_path_does_not_match_from_end() {
	183	for pattern in &["bar/foo", "/bar/foo"] {
	184	let pattern = &pat(*pattern);
	185	assert!(!match_file(pattern, "FoO", Case::Fold));
	186	assert!(match_file(pattern, "bar/Foo", Case::Fold));
	187	assert!(!match_file(pattern, "baz/bar/Foo", Case::Fold));
	188	assert!(!match_file(pattern, "foo", Case::Sensitive));
	189	assert!(match_file(pattern, "bar/foo", Case::Sensitive));
	190	assert!(!match_file(pattern, "baz/bar/foo", Case::Sensitive));
	191	assert!(!match_file(pattern, "Baz/bar/Foo", Case::Sensitive));
	192	}
	193	}
	194
	195	#[test]
	196	fn basename_glob_and_literal_is_ends_with() {
	197	let pattern = &pat("*foo");
	198	assert!(match_file(pattern, "FoO", Case::Fold));
	199	assert!(match_file(pattern, "BarFoO", Case::Fold));
	200	assert!(!match_file(pattern, "BarFoOo", Case::Fold));
	201	assert!(!match_file(pattern, "Foo", Case::Sensitive));
	202	assert!(!match_file(pattern, "BarFoo", Case::Sensitive));
	203	assert!(match_file(pattern, "barfoo", Case::Sensitive));
	204	assert!(!match_file(pattern, "barfooo", Case::Sensitive));
	205
	206	assert!(match_file(pattern, "bar/foo", Case::Sensitive));
	207	assert!(match_file(pattern, "bar/bazfoo", Case::Sensitive));
	208	}
	209
	210	#[test]
	211	fn special_cases_from_corpus() {
	212	let pattern = &pat("foo*bar");
	213	assert!(
	214	!match_file(pattern, "foo/baz/bar", Case::Sensitive),
	215	"asterisk does not match path separators"
	216	);
	217	let pattern = &pat("*some/path/to/hello.txt");
	218	assert!(
	219	!match_file(pattern, "a/bigger/some/path/to/hello.txt", Case::Sensitive),
	220	"asterisk doesn't match path separators"
	221	);
	222
	223	let pattern = &pat("/*foo.txt");
	224	assert!(match_file(pattern, "hello-foo.txt", Case::Sensitive));
	225	assert!(
	226	!match_file(pattern, "hello/foo.txt", Case::Sensitive),
	227	"absolute single asterisk doesn't match paths"
	228	);
	229	}
	230
	231	#[test]
	232	fn absolute_basename_glob_and_literal_is_ends_with_in_basenames() {
	233	let pattern = &pat("/*foo");
	234
	235	assert!(match_file(pattern, "FoO", Case::Fold));
	236	assert!(match_file(pattern, "BarFoO", Case::Fold));
	237	assert!(!match_file(pattern, "BarFoOo", Case::Fold));
	238	assert!(!match_file(pattern, "Foo", Case::Sensitive));
	239	assert!(!match_file(pattern, "BarFoo", Case::Sensitive));
	240	assert!(match_file(pattern, "barfoo", Case::Sensitive));
	241	assert!(!match_file(pattern, "barfooo", Case::Sensitive));
	242	}
	243
	244	#[test]
	245	fn absolute_basename_glob_and_literal_is_glob_in_paths() {
	246	let pattern = &pat("/*foo");
	247
	248	assert!(!match_file(pattern, "bar/foo", Case::Sensitive), "* does not match /");
	249	assert!(!match_file(pattern, "bar/bazfoo", Case::Sensitive));
	250	}
	251
	252	#[test]
	253	fn negated_patterns_are_handled_by_caller() {
	254	let pattern = &pat("!foo");
	255	assert!(
	256	match_file(pattern, "foo", Case::Sensitive),
	257	"negative patterns match like any other"
	258	);
	259	assert!(
	260	pattern.is_negative(),
	261	"the caller checks for the negative flag and acts accordingly"
	262	);
	263	}
	264	#[test]
	265	fn names_do_not_automatically_match_entire_directories() {
	266	// this feature is implemented with the directory stack.
	267	let pattern = &pat("foo");
	268	assert!(!match_file(pattern, "foobar", Case::Sensitive));
	269	assert!(!match_file(pattern, "foo/bar", Case::Sensitive));
	270	assert!(!match_file(pattern, "foo/bar/baz", Case::Sensitive));
	271	}
	272
	273	#[test]
	274	fn directory_patterns_do_not_match_files_within_a_directory_as_well_like_slash_star_star() {
	275	// this feature is implemented with the directory stack, which excludes entire directories
	276	let pattern = &pat("dir/");
	277	assert!(!match_path(pattern, "dir/file", None, Case::Sensitive));
	278	assert!(!match_path(pattern, "base/dir/file", None, Case::Sensitive));
	279	assert!(!match_path(pattern, "base/ndir/file", None, Case::Sensitive));
	280	assert!(!match_path(pattern, "Dir/File", None, Case::Fold));
	281	assert!(!match_path(pattern, "Base/Dir/File", None, Case::Fold));
	282	assert!(!match_path(pattern, "dir2/file", None, Case::Sensitive));
	283
	284	let pattern = &pat("dir/sub-dir/");
	285	assert!(!match_path(pattern, "dir/sub-dir/file", None, Case::Sensitive));
	286	assert!(!match_path(pattern, "dir/Sub-dir/File", None, Case::Fold));
	287	assert!(!match_path(pattern, "dir/Sub-dir2/File", None, Case::Fold));
	288	}
	289
	290	#[test]
	291	fn single_paths_match_anywhere() {
	292	let pattern = &pat("target");
	293	assert!(match_file(pattern, "dir/target", Case::Sensitive));
	294	assert!(!match_file(pattern, "dir/atarget", Case::Sensitive));
	295	assert!(!match_file(pattern, "dir/targeta", Case::Sensitive));
	296	assert!(match_path(pattern, "dir/target", Some(true), Case::Sensitive));
	297
	298	let pattern = &pat("target/");
	299	assert!(!match_file(pattern, "dir/target", Case::Sensitive));
	300	assert!(
	301	!match_path(pattern, "dir/target", None, Case::Sensitive),
	302	"it assumes unknown to not be a directory"
	303	);
	304	assert!(match_path(pattern, "dir/target", Some(true), Case::Sensitive));
	305	assert!(
	306	!match_path(pattern, "dir/target/", Some(true), Case::Sensitive),
	307	"we need sanitized paths that don't have trailing slashes"
	308	);
	309	}
	310
	311	fn pat<'a>(pattern: impl Into<&'a BStr>) -> git_glob::Pattern {
	312	git_glob::Pattern::from_bytes(pattern.into()).expect("parsing works")
	313	}
	314
	315	fn match_file<'a>(pattern: &git_glob::Pattern, path: impl Into<&'a BStr>, case: Case) -> bool {
	316	match_path(pattern, path, false.into(), case)
	317	}
	318
	319	fn match_path<'a>(pattern: &git_glob::Pattern, path: impl Into<&'a BStr>, is_dir: Option<bool>, case: Case) -> bool {
	320	let path = path.into();
	321	pattern.matches_repo_relative_path(path, basename_start_pos(path), is_dir, case)
	322	}
	323
	324	fn basename_start_pos(value: &BStr) -> Option<usize> {
	325	value.rfind_byte(b'/').map(\|pos\| pos + 1)
	326	}

git-glob/tests/pattern/mod.rs+19−0

@@ -0,0 +1,19 @@
	1	use git_glob::pattern::Mode;
	2	use git_glob::Pattern;
	3
	4	#[test]
	5	fn display() {
	6	fn pat(text: &str, mode: Mode) -> String {
	7	Pattern {
	8	text: text.into(),
	9	mode,
	10	first_wildcard_pos: None,
	11	}
	12	.to_string()
	13	}
	14	assert_eq!(pat("a", Mode::ABSOLUTE), "/a");
	15	assert_eq!(pat("a", Mode::MUST_BE_DIR), "a/");
	16	assert_eq!(pat("a", Mode::NEGATIVE), "!a");
	17	assert_eq!(pat("a", Mode::ABSOLUTE \| Mode::NEGATIVE \| Mode::MUST_BE_DIR), "!/a/");
	18	}
	19	mod matching;

git-glob/tests/wildmatch/mod.rs+7−3

+use bstr::ByteSlice;
 use std::{
     fmt::{Debug, Display, Formatter},
     panic::catch_unwind,
         }
     }
+    dbg!(&failures);
     assert_eq!(failures.len(), 0);
     assert_eq!(at_least_one_panic, 0, "not a single panic in any invocation");
     let pattern = git_glob::Pattern::from_bytes(pattern_text.as_bytes()).expect("valid (enough) pattern");
     let actual_path_match: MatchResult = catch_unwind(|| match_file_path(&pattern, text, Case::Sensitive)).into();
     let actual_path_imatch: MatchResult = catch_unwind(|| match_file_path(&pattern, text, Case::Fold)).into();
-    let actual_glob_match: MatchResult = catch_unwind(|| pattern.matches(text, wildmatch::Mode::empty())).into();
+    let actual_glob_match: MatchResult =
-    let actual_glob_imatch: MatchResult = catch_unwind(|| pattern.matches(text, wildmatch::Mode::IGNORE_CASE)).into();
+        catch_unwind(|| git_glob::wildmatch(pattern.text.as_bstr(), text.into(), wildmatch::Mode::empty())).into();
+    let actual_glob_imatch: MatchResult =
+        catch_unwind(|| git_glob::wildmatch(pattern.text.as_bstr(), text.into(), wildmatch::Mode::IGNORE_CASE)).into();
     let actual = MultiMatch {
         path_match: actual_path_match,
         path_imatch: actual_path_imatch,
 }
 fn match_file_path(pattern: &git_glob::Pattern, path: &str, case: Case) -> bool {
-    pattern.matches_repo_relative_path(path, basename_of(path), false /* is_dir */, case)
+    pattern.matches_repo_relative_path(path, basename_of(path), false.into() /* is_dir */, case)
 }
 fn basename_of(path: &str) -> Option<usize> {
     path.rfind('/').map(|pos| pos + 1)

git-index/src/access.rs+39−1

@@ -1,6 +1,6 @@
1	use bstr::{BStr, ByteSlice};	1	use bstr::{BStr, ByteSlice};
2		2
3	use crate::{extension, Entry, State, Version};	3	use crate::{extension, Entry, PathStorage, State, Version};
4		4
5	impl State {	5	impl State {
6	pub fn version(&self) -> Version {	6	pub fn version(&self) -> Version {
@@ -10,6 +10,35 @@ impl State { · 3 unmodified lines
10	pub fn entries(&self) -> &[Entry] {	10	pub fn entries(&self) -> &[Entry] {
11	&self.entries	11	&self.entries
12	}	12	}
		13	pub fn path_backing(&self) -> &PathStorage {
		14	&self.path_backing
		15	}
		16	pub fn take_path_backing(&mut self) -> PathStorage {
		17	assert_eq!(
		18	self.entries.is_empty(),
		19	self.path_backing.is_empty(),
		20	"BUG: cannot take out backing multiple times"
		21	);
		22	std::mem::take(&mut self.path_backing)
		23	}
		24
		25	pub fn return_path_backing(&mut self, backing: PathStorage) {
		26	assert!(
		27	self.path_backing.is_empty(),
		28	"BUG: return path backing only after taking it, once"
		29	);
		30	self.path_backing = backing;
		31	}
		32
		33	pub fn entries_with_paths_by_filter_map<'a, T>(
		34	&'a self,
		35	mut filter_map: impl FnMut(&'a BStr, &Entry) -> Option<T> + 'a,
		36	) -> impl Iterator<Item = (&'a BStr, T)> + 'a {
		37	self.entries.iter().filter_map(move \|e\| {
		38	let p = e.path(self);
		39	filter_map(p, e).map(\|t\| (p, t))
		40	})
		41	}
13	pub fn entries_mut(&mut self) -> &mut [Entry] {	42	pub fn entries_mut(&mut self) -> &mut [Entry] {
14	&mut self.entries	43	&mut self.entries
15	}	44	}
@@ -20,6 +49,15 @@ impl State { · 4 unmodified lines
20	(e, path)	49	(e, path)
21	})	50	})
22	}	51	}
		52	pub fn entries_mut_with_paths_in<'state, 'backing>(
		53	&'state mut self,
		54	backing: &'backing PathStorage,
		55	) -> impl Iterator<Item = (&'state mut Entry, &'backing BStr)> {
		56	self.entries.iter_mut().map(move \|e\| {
		57	let path = (&backing[e.path.clone()]).as_bstr();
		58	(e, path)
		59	})
		60	}
23	pub fn tree(&self) -> Option<&extension::Tree> {	61	pub fn tree(&self) -> Option<&extension::Tree> {
24	self.tree.as_ref()	62	self.tree.as_ref()
25	}	63	}

git-index/src/decode/mod.rs+2−1

 pub struct Options {
     pub object_hash: git_hash::Kind,
     /// If Some(_), we are allowed to use more than one thread. If Some(N), use no more than N threads. If Some(0)|None, use as many threads
-    /// as there are physical cores.
+    /// as there are logical cores.
     ///
     /// This applies to loading extensions in parallel to entries if the common EOIE extension is available.
     /// It also allows to use multiple threads for loading entries if the IEOT extension is present.
     pub thread_limit: Option<usize>,
     /// The minimum size in bytes to load extensions in their own thread, assuming there is enough `num_threads` available.
+    /// If set to 0, for example, extensions will always be read in their own thread if enough threads are available.
     pub min_extension_block_in_bytes_for_threading: usize,
 }

git-index/src/entry.rs+4−0

             (&state.path_backing[self.path.clone()]).as_bstr()
         }
+        pub fn path_in<'backing>(&self, backing: &'backing crate::PathStorage) -> &'backing BStr {
+            (backing[self.path.clone()]).as_bstr()
+        }
         pub fn stage(&self) -> u32 {
             self.flags.stage()
         }

git-index/src/lib.rs+4−1

     pub checksum: git_hash::ObjectId,
 }
+/// The type to use and store paths to all entries.
+pub type PathStorage = Vec<u8>;
 /// An in-memory cache of a fully parsed git index file.
 ///
 /// As opposed to a snapshot, it's meant to be altered and eventually be written back to disk or converted into a tree.
     version: Version,
     entries: Vec<Entry>,
     /// A memory area keeping all index paths, in full length, independently of the index version.
-    path_backing: Vec<u8>,
+    path_backing: PathStorage,
     /// True if one entry in the index has a special marker mode
     #[allow(dead_code)]
     is_sparse: bool,

git-odb/Cargo.toml+2−1

@@ -30,7 +30,8 @@ required-features = [] · 29 unmodified lines
30	all-features = true	30	all-features = true
31		31
32	[dependencies]	32	[dependencies]
33	git-features = { version = "^0.20.0", path = "../git-features", features = ["rustsha1", "walkdir", "zlib", "crc32", "bstr"] }	33	git-features = { version = "^0.20.0", path = "../git-features", features = ["rustsha1", "walkdir", "zlib", "crc32" ] }
		34	git-path = { version = "^0.1.0", path = "../git-path" }
34	git-hash = { version = "^0.9.3", path = "../git-hash" }	35	git-hash = { version = "^0.9.3", path = "../git-hash" }
35	git-quote = { version = "^0.2.0", path = "../git-quote" }	36	git-quote = { version = "^0.2.0", path = "../git-quote" }
36	git-object = { version = "^0.18.0", path = "../git-object" }	37	git-object = { version = "^0.18.0", path = "../git-object" }

git-odb/src/alternate/parse.rs+1−1

@@ -20,7 +20,7 @@ pub(crate) fn content(input: &[u8]) -> Result<Vec<PathBuf>, Error> { · 19 unmodified lines
20	continue;	20	continue;
21	}	21	}
22	out.push(	22	out.push(
23	git_features::path::from_bstr(if line.starts_with(b"\"") {	23	git_path::try_from_bstr(if line.starts_with(b"\"") {
24	git_quote::ansi_c::undo(line)?.0	24	git_quote::ansi_c::undo(line)?.0
25	} else {	25	} else {
26	Cow::Borrowed(line)	26	Cow::Borrowed(line)

git-pack/Cargo.toml+1−0

@@ -39,6 +39,7 @@ required-features = ["internal-testing-to-avoid-being-run-by-cargo-test-all"] · 38 unmodified lines
39	[dependencies]	39	[dependencies]
40	git-features = { version = "^0.20.0", path = "../git-features", features = ["crc32", "rustsha1", "progress", "zlib"] }	40	git-features = { version = "^0.20.0", path = "../git-features", features = ["crc32", "rustsha1", "progress", "zlib"] }
41	git-hash = { version = "^0.9.3", path = "../git-hash" }	41	git-hash = { version = "^0.9.3", path = "../git-hash" }
		42	git-path = { version = "^0.1.0", path = "../git-path" }
42	git-chunk = { version = "^0.3.0", path = "../git-chunk" }	43	git-chunk = { version = "^0.3.0", path = "../git-chunk" }
43	git-object = { version = "^0.18.0", path = "../git-object" }	44	git-object = { version = "^0.18.0", path = "../git-object" }
44	git-traverse = { version = "^0.14.0", path = "../git-traverse" }	45	git-traverse = { version = "^0.14.0", path = "../git-traverse" }

git-pack/src/multi_index/chunk.rs+1−1

@@ -34,7 +34,7 @@ pub mod index_names { · 33 unmodified lines
34	let null_byte_pos = chunk.find_byte(b'\0').ok_or(decode::Error::MissingNullByte)?;	34	let null_byte_pos = chunk.find_byte(b'\0').ok_or(decode::Error::MissingNullByte)?;
35		35
36	let path = &chunk[..null_byte_pos];	36	let path = &chunk[..null_byte_pos];
37	let path = git_features::path::from_byte_slice(path)	37	let path = git_path::try_from_byte_slice(path)
38	.map_err(\|_\| decode::Error::PathEncoding {	38	.map_err(\|_\| decode::Error::PathEncoding {
39	path: BString::from(path),	39	path: BString::from(path),
40	})?	40	})?

git-path/CHANGELOG.md+42−0

@@ -0,0 +1,42 @@
	1	# Changelog
	2
	3	All notable changes to this project will be documented in this file.
	4
	5	The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
	6	and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
	7
	8	## 0.1.0 (2022-04-28)
	9
	10	### Refactor (BREAKING)
	11
	12	- <csr-id-54801592488416ef2bb0f34c5061b62189c35c5e/> various name changes for more convenient API
	13
	14	### Commit Statistics
	15
	16	<csr-read-only-do-not-edit/>
	17
	18	- 8 commits contributed to the release over the course of 1 calendar day.
	19	- 1 commit where understood as [conventional](https://www.conventionalcommits.org).
	20	- 1 unique issue was worked on: [#301](https://github.com/Byron/gitoxide/issues/301)
	21
	22	### Commit Details
	23
	24	<csr-read-only-do-not-edit/>
	25
	26	<details><summary>view details</summary>
	27
	28	* [#301](https://github.com/Byron/gitoxide/issues/301)
	29	- frame for `gix repo exclude query` ([`a331314`](https://github.com/Byron/gitoxide/commit/a331314758629a93ba036245a5dd03cf4109dc52))
	30	- refactor ([`21d4076`](https://github.com/Byron/gitoxide/commit/21d407638285b728d0c64fabf2abe0e1948e9bec))
	31	- The first indication that directory-based excludes work ([`e868acc`](https://github.com/Byron/gitoxide/commit/e868acce2e7c3e2501497bf630e3a54f349ad38e))
	32	- various name changes for more convenient API ([`5480159`](https://github.com/Byron/gitoxide/commit/54801592488416ef2bb0f34c5061b62189c35c5e))
	33	- Use bstr intead of [u8] ([`9380e99`](https://github.com/Byron/gitoxide/commit/9380e9990065897e318b040f49b3c9a6de8bebb1))
	34	- Use `git-path` crate instead of `git_features::path` ([`47e607d`](https://github.com/Byron/gitoxide/commit/47e607dc256a43a3411406c645eb7ff04239dd3a))
	35	- Copy all existing functions from git-features::path to git-path:: ([`725e198`](https://github.com/Byron/gitoxide/commit/725e1985dc521d01ff9e1e89b6468ef62fc09656))
	36	- add empty git-path crate ([`8d13f81`](https://github.com/Byron/gitoxide/commit/8d13f81068b4663d322002a9617d39b307b63469))
	37	</details>
	38
	39	## 0.0.0 (2022-03-31)
	40
	41	An empty crate without any content to reserve the name for the gitoxide project.
	42

git-path/Cargo.toml+16−0

@@ -0,0 +1,16 @@
	1	[package]
	2	name = "git-path"
	3	version = "0.1.0"
	4	repository = "https://github.com/Byron/gitoxide"
	5	license = "MIT/Apache-2.0"
	6	description = "A WIP crate of the gitoxide project dealing paths and their conversions"
	7	authors = ["Sebastian Thiel <sebastian.thiel@icloud.com>"]
	8	edition = "2018"
	9
	10	[lib]
	11	doctest = false
	12
	13	# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
	14
	15	[dependencies]
	16	bstr = { version = "0.2.17", default-features = false, features = ["std"] }

git-path/src/convert.rs+197−0

@@ -0,0 +1,197 @@
	1	use bstr::{BStr, BString};
	2	use std::{
	3	borrow::Cow,
	4	ffi::OsStr,
	5	path::{Path, PathBuf},
	6	};
	7
	8	#[derive(Debug)]
	9	/// The error type returned by [`into_bstr()`] and others may suffer from failed conversions from or to bytes.
	10	pub struct Utf8Error;
	11
	12	impl std::fmt::Display for Utf8Error {
	13	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
	14	f.write_str("Could not convert to UTF8 or from UTF8 due to ill-formed input")
	15	}
	16	}
	17
	18	impl std::error::Error for Utf8Error {}
	19
	20	/// Like [`into_bstr()`], but takes `OsStr` as input for a lossless, but fallible, conversion.
	21	pub fn os_str_into_bstr(path: &OsStr) -> Result<&BStr, Utf8Error> {
	22	let path = try_into_bstr(Cow::Borrowed(path.as_ref()))?;
	23	match path {
	24	Cow::Borrowed(path) => Ok(path),
	25	Cow::Owned(_) => unreachable!("borrowed cows stay borrowed"),
	26	}
	27	}
	28
	29	/// Convert the given path either into its raw bytes on unix or its UTF8 encoded counterpart on windows.
	30	///
	31	/// On windows, if the source Path contains ill-formed, lone surrogates, the UTF-8 conversion will fail
	32	/// causing `Utf8Error` to be returned.
	33	pub fn try_into_bstr<'a>(path: impl Into<Cow<'a, Path>>) -> Result<Cow<'a, BStr>, Utf8Error> {
	34	let path = path.into();
	35	let path_str = match path {
	36	Cow::Owned(path) => Cow::Owned({
	37	#[cfg(unix)]
	38	let p: BString = {
	39	use std::os::unix::ffi::OsStringExt;
	40	path.into_os_string().into_vec().into()
	41	};
	42	#[cfg(not(unix))]
	43	let p: BString = path.into_os_string().into_string().map_err(\|_\| Utf8Error)?.into();
	44	p
	45	}),
	46	Cow::Borrowed(path) => Cow::Borrowed({
	47	#[cfg(unix)]
	48	let p: &BStr = {
	49	use std::os::unix::ffi::OsStrExt;
	50	path.as_os_str().as_bytes().into()
	51	};
	52	#[cfg(not(unix))]
	53	let p: &BStr = path.to_str().ok_or(Utf8Error)?.as_bytes().into();
	54	p
	55	}),
	56	};
	57	Ok(path_str)
	58	}
	59
	60	/// Similar to [`try_into_bstr()`] but panics if malformed surrogates are encountered on windows.
	61	pub fn into_bstr<'a>(path: impl Into<Cow<'a, Path>>) -> Cow<'a, BStr> {
	62	try_into_bstr(path).expect("prefix path doesn't contain ill-formed UTF-8")
	63	}
	64
	65	/// Given `input` bytes, produce a `Path` from them ignoring encoding entirely if on unix.
	66	///
	67	/// On windows, the input is required to be valid UTF-8, which is guaranteed if we wrote it before. There are some potential
	68	/// git versions and windows installation which produce mal-formed UTF-16 if certain emojies are in the path. It's as rare as
	69	/// it sounds, but possible.
	70	pub fn try_from_byte_slice(input: &[u8]) -> Result<&Path, Utf8Error> {
	71	#[cfg(unix)]
	72	let p = {
	73	use std::os::unix::ffi::OsStrExt;
	74	OsStr::from_bytes(input).as_ref()
	75	};
	76	#[cfg(not(unix))]
	77	let p = Path::new(std::str::from_utf8(input).map_err(\|_\| Utf8Error)?);
	78	Ok(p)
	79	}
	80
	81	/// Similar to [`from_byte_slice()`], but takes either borrowed or owned `input`.
	82	pub fn try_from_bstr<'a>(input: impl Into<Cow<'a, BStr>>) -> Result<Cow<'a, Path>, Utf8Error> {
	83	let input = input.into();
	84	match input {
	85	Cow::Borrowed(input) => try_from_byte_slice(input).map(Cow::Borrowed),
	86	Cow::Owned(input) => try_from_bstring(input).map(Cow::Owned),
	87	}
	88	}
	89
	90	/// Similar to [`try_from_bstr()`], but panics if malformed surrogates are encountered on windows.
	91	pub fn from_bstr<'a>(input: impl Into<Cow<'a, BStr>>) -> Cow<'a, Path> {
	92	try_from_bstr(input).expect("prefix path doesn't contain ill-formed UTF-8")
	93	}
	94
	95	/// Similar to [`try_from_bstr()`], but takes and produces owned data.
	96	pub fn try_from_bstring(input: impl Into<BString>) -> Result<PathBuf, Utf8Error> {
	97	let input = input.into();
	98	#[cfg(unix)]
	99	let p = {
	100	use std::os::unix::ffi::OsStringExt;
	101	std::ffi::OsString::from_vec(input.into()).into()
	102	};
	103	#[cfg(not(unix))]
	104	let p = {
	105	use bstr::ByteVec;
	106	PathBuf::from(
	107	{
	108	let v: Vec<_> = input.into();
	109	v
	110	}
	111	.into_string()
	112	.map_err(\|_\| Utf8Error)?,
	113	)
	114	};
	115	Ok(p)
	116	}
	117
	118	/// Similar to [`try_from_bstring()`], but will panic if there is ill-formed UTF-8 in the `input`.
	119	pub fn from_bstring(input: impl Into<BString>) -> PathBuf {
	120	try_from_bstring(input).expect("well-formed UTF-8 on windows")
	121	}
	122
	123	/// Similar to [`try_from_byte_slice()`], but will panic if there is ill-formed UTF-8 in the `input`.
	124	pub fn from_byte_slice(input: &[u8]) -> &Path {
	125	try_from_byte_slice(input).expect("well-formed UTF-8 on windows")
	126	}
	127
	128	fn replace<'a>(path: impl Into<Cow<'a, BStr>>, find: u8, replace: u8) -> Cow<'a, BStr> {
	129	let path = path.into();
	130	match path {
	131	Cow::Owned(mut path) => {
	132	for b in path.iter_mut().filter(\|b\| **b == find) {
	133	*b = replace;
	134	}
	135	path.into()
	136	}
	137	Cow::Borrowed(path) => {
	138	if !path.contains(&find) {
	139	return path.into();
	140	}
	141	let mut path = path.to_owned();
	142	for b in path.iter_mut().filter(\|b\| **b == find) {
	143	*b = replace;
	144	}
	145	path.into()
	146	}
	147	}
	148	}
	149
	150	/// Assures the given bytes use the native path separator.
	151	pub fn to_native_separators<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, BStr> {
	152	#[cfg(not(windows))]
	153	let p = to_unix_separators(path);
	154	#[cfg(windows)]
	155	let p = to_windows_separators(path);
	156	p
	157	}
	158
	159	/// Convert paths with slashes to backslashes on windows and do nothing on unix, but panics if malformed surrogates are encountered on windows.
	160	pub fn to_native_path_on_windows<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, std::path::Path> {
	161	#[cfg(not(windows))]
	162	{
	163	crate::from_bstr(path)
	164	}
	165	#[cfg(windows)]
	166	{
	167	crate::from_bstr(to_windows_separators(path))
	168	}
	169	}
	170
	171	/// Replaces windows path separators with slashes, but only do so on windows.
	172	pub fn to_unix_separators_on_windows<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, BStr> {
	173	#[cfg(windows)]
	174	{
	175	replace(path, b'\\', b'/')
	176	}
	177	#[cfg(not(windows))]
	178	{
	179	path.into()
	180	}
	181	}
	182
	183	/// Replaces windows path separators with slashes, unconditionally.
	184	///
	185	/// Note Do not use these and prefer the conditional versions of this method.
	186	// TODO: use https://lib.rs/crates/path-slash to handle escapes
	187	pub fn to_unix_separators<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, BStr> {
	188	replace(path, b'\\', b'/')
	189	}
	190
	191	/// Find backslashes and replace them with slashes, which typically resembles a unix path, unconditionally.
	192	///
	193	/// Note Do not use these and prefer the conditional versions of this method.
	194	// TODO: use https://lib.rs/crates/path-slash to handle escapes
	195	pub fn to_windows_separators<'a>(path: impl Into<Cow<'a, BStr>>) -> Cow<'a, BStr> {
	196	replace(path, b'/', b'\\')
	197	}

git-path/src/lib.rs+52−0

@@ -0,0 +1,52 @@
	1	#![forbid(unsafe_code, rust_2018_idioms, missing_docs)]
	2	//! ### Research
	3	//!
	4	//! * windows
	5	//! - [`dirent.c`](https://github.com/git/git/blob/main/compat/win32/dirent.c#L31:L31) contains all implementation (seemingly) of opening directories and reading their entries, along with all path conversions (UTF-16 for windows). This is done on the fly so git can work with [in UTF-8](https://github.com/git/git/blob/main/compat/win32/dirent.c#L12:L12).
	6	//! - mingw [is used for the conversion](https://github.com/git/git/blob/main/compat/mingw.h#L579:L579) and it appears they handle surrogates during the conversion, maybe some sort of non-strict UTF-8 converter? Actually it uses [WideCharToMultiByte](https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-widechartomultibyte)
	7	//! under the hood which by now does fail if the UTF-8 would be invalid unicode, i.e. unicode pairs.
	8	//! - `OsString` on windows already stores strings as WTF-8, which supports [surrogate pairs](https://unicodebook.readthedocs.io/unicode_encodings.html),
	9	//! something that UTF-8 isn't allowed do it for security reasons, after all it's UTF-16 specific and exists only to extend
	10	//! the encodable code-points.
	11	//! - informative reading on [WTF-8](https://simonsapin.github.io/wtf-8/#motivation) which is the encoding used by Rust
	12	//! internally that deals with surrogates and non-wellformed surrogates (those that aren't in pairs).
	13	//! * unix
	14	//! - It uses [opendir](https://man7.org/linux/man-pages/man3/opendir.3.html) and [readdir](https://man7.org/linux/man-pages/man3/readdir.3.html)
	15	//! respectively. There is no encoding specified, except that these paths are null-terminated.
	16	//!
	17	//! ### Learnings
	18	//!
	19	//! Surrogate pairs are a way to extend the encodable value range in UTF-16 encodings, used primarily on windows and in Javascript.
	20	//! For a long time these codepoints used for surrogates, always to be used in pairs, were not assigned, until…they were for rare
	21	//! emojies and the likes. The unicode standard does not require surrogates to happen in pairs, even though by now unpaired surrogates
	22	//! in UTF-16 are considered ill-formed, which aren't supposed to be converted to UTF-8 for example.
	23	//!
	24	//! This is the reason we have to deal with `to_string_lossy()`, it's _just_ for that quirk.
	25	//!
	26	//! This also means the only platform ever eligible to see conversion errors is windows, and there it's only older pre-vista
	27	//! windows versions which incorrectly allow ill-formed UTF-16 strings. Newer versions don't perform such conversions anymore, for
	28	//! example when going from UTF-16 to UTF-8, they will trigger an error.
	29	//!
	30	//! ### Conclusions
	31	//!
	32	//! Since [WideCharToMultiByte](https://docs.microsoft.com/en-us/windows/win32/api/stringapiset/nf-stringapiset-widechartomultibyte) by now is
	33	//! fixed (Vista onward) to produce valid UTF-8, lone surrogate codepoints will cause failure, which `git`
	34	//! [doesn't care about](https://github.com/git/git/blob/main/compat/win32/dirent.c#L12:L12).
	35	//!
	36	//! We will, though, which means from now on we can just convert to UTF-8 on windows and bubble up errors where necessary,
	37	//! preventing potential mismatched surrogate pairs to ever be saved on disk by gitoxide.
	38	//!
	39	//! Even though the error only exists on older windows versions, we will represent it in the type system through fallible function calls.
	40	//! Callers may `.expect()` on the result to indicate they don't wish to handle this special and rare case. Note that servers should not
	41	//! ever get into a code-path which does panic though.
	42
	43	/// A dummy type to represent path specs and help finding all spots that take path specs once it is implemented.
	44
	45	/// A preliminary version of a path-spec based on glances of the code.
	46	#[derive(Clone, Debug)]
	47	pub struct Spec(bstr::BString);
	48
	49	mod convert;
	50	mod spec;
	51
	52	pub use convert::*;

git-path/src/spec.rs+51−0

@@ -0,0 +1,51 @@
	1	use crate::Spec;
	2	use bstr::{BStr, ByteSlice, ByteVec};
	3	use std::ffi::OsStr;
	4
	5	impl std::convert::TryFrom<&OsStr> for Spec {
	6	type Error = crate::Utf8Error;
	7
	8	fn try_from(value: &OsStr) -> Result<Self, Self::Error> {
	9	crate::os_str_into_bstr(value).map(\|value\| {
	10	assert_valid_hack(value);
	11	Spec(value.into())
	12	})
	13	}
	14	}
	15
	16	fn assert_valid_hack(input: &BStr) {
	17	assert!(!input.contains_str(b"/../"));
	18	assert!(!input.contains_str(b"/./"));
	19	assert!(!input.starts_with_str(b"../"));
	20	assert!(!input.starts_with_str(b"./"));
	21	assert!(!input.starts_with_str(b"/"));
	22	}
	23
	24	impl Spec {
	25	/// Parse `input` into a `Spec` or `None` if it could not be parsed
	26	// TODO: tests, actual implementation probably via `git-pathspec` to make use of the crate after all.
	27	pub fn from_bytes(input: &BStr) -> Option<Self> {
	28	assert_valid_hack(input);
	29	Spec(input.into()).into()
	30	}
	31	/// Return all paths described by this path spec, using slashes on all platforms.
	32	pub fn items(&self) -> impl Iterator<Item = &BStr> {
	33	std::iter::once(self.0.as_bstr())
	34	}
	35	/// Adjust this path specification according to the given `prefix`, which may be empty to indicate we are the at work-tree root.
	36	// TODO: this is a hack, needs test and time to do according to spec. This is just a minimum version to have -something-.
	37	pub fn apply_prefix(&mut self, prefix: &std::path::Path) -> &Self {
	38	// many more things we can't handle. `Path` never ends with trailing path separator.
	39	let prefix = crate::into_bstr(prefix);
	40	if !prefix.is_empty() {
	41	let mut prefix = crate::to_unix_separators_on_windows(prefix);
	42	{
	43	let path = prefix.to_mut();
	44	path.push_byte(b'/');
	45	path.extend_from_slice(&self.0);
	46	}
	47	self.0 = prefix.into_owned();
	48	}
	49	self
	50	}
	51	}

git-path/tests/path.rs+21−0

@@ -0,0 +1,21 @@
	1	mod convert {
	2	use bstr::ByteSlice;
	3	use git_path::{to_unix_separators, to_windows_separators};
	4
	5	#[test]
	6	fn assure_unix_separators() {
	7	assert_eq!(to_unix_separators(b"no-backslash".as_bstr()).as_bstr(), "no-backslash");
	8
	9	assert_eq!(to_unix_separators(b"\\a\\b\\\\".as_bstr()).as_bstr(), "/a/b//");
	10	}
	11
	12	#[test]
	13	fn assure_windows_separators() {
	14	assert_eq!(
	15	to_windows_separators(b"no-backslash".as_bstr()).as_bstr(),
	16	"no-backslash"
	17	);
	18
	19	assert_eq!(to_windows_separators(b"/a/b//".as_bstr()).as_bstr(), "\\a\\b\\\\");
	20	}
	21	}

git-ref/Cargo.toml+2−1

@@ -25,7 +25,8 @@ required-features = ["internal-testing-git-features-parallel"] · 24 unmodified lines
25	# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html	25	# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
26		26
27	[dependencies]	27	[dependencies]
28	git-features = { version = "^0.20.0", path = "../git-features", features = ["walkdir", "bstr"]}	28	git-features = { version = "^0.20.0", path = "../git-features", features = ["walkdir"]}
		29	git-path = { version = "^0.1.0", path = "../git-path" }
29	git-hash = { version = "^0.9.3", path = "../git-hash" }	30	git-hash = { version = "^0.9.3", path = "../git-hash" }
30	git-object = { version = "^0.18.0", path = "../git-object" }	31	git-object = { version = "^0.18.0", path = "../git-object" }
31	git-validate = { version ="^0.5.3", path = "../git-validate" }	32	git-validate = { version ="^0.5.3", path = "../git-validate" }

git-ref/src/fullname.rs+1−1

@@ -75,7 +75,7 @@ impl FullName { · 74 unmodified lines
75		75
76	/// Convert this name into the relative path, lossily, identifying the reference location relative to a repository	76	/// Convert this name into the relative path, lossily, identifying the reference location relative to a repository
77	pub fn to_path(&self) -> &Path {	77	pub fn to_path(&self) -> &Path {
78	git_features::path::from_byte_slice_or_panic_on_windows(&self.0)	78	git_path::from_byte_slice(&self.0)
79	}	79	}
80		80
81	/// Dissolve this instance and return the buffer.	81	/// Dissolve this instance and return the buffer.

git-ref/src/name.rs+3−3

@@ -26,7 +26,7 @@ impl Category { · 25 unmodified lines
26	impl<'a> FullNameRef<'a> {	26	impl<'a> FullNameRef<'a> {
27	/// Convert this name into the relative path identifying the reference location.	27	/// Convert this name into the relative path identifying the reference location.
28	pub fn to_path(self) -> &'a Path {	28	pub fn to_path(self) -> &'a Path {
29	git_features::path::from_byte_slice_or_panic_on_windows(self.0)	29	git_path::from_byte_slice(self.0)
30	}	30	}
31		31
32	/// Return ourselves as byte string which is a valid refname	32	/// Return ourselves as byte string which is a valid refname
@@ -79,7 +79,7 @@ impl<'a> PartialNameRef<'a> { · 46 unmodified lines
79	/// Convert this name into the relative path possibly identifying the reference location.	79	/// Convert this name into the relative path possibly identifying the reference location.
80	/// Note that it may be only a partial path though.	80	/// Note that it may be only a partial path though.
81	pub fn to_partial_path(&'a self) -> &'a Path {	81	pub fn to_partial_path(&'a self) -> &'a Path {
82	git_features::path::from_byte_slice_or_panic_on_windows(self.0.as_ref())	82	git_path::from_byte_slice(self.0.as_ref())
83	}	83	}
84		84
85	/// Provide the name as binary string which is known to be a valid partial ref name.	85	/// Provide the name as binary string which is known to be a valid partial ref name.
@@ -122,7 +122,7 @@ impl<'a> TryFrom<&'a OsStr> for PartialNameRef<'a> { · 36 unmodified lines
122	type Error = Error;	122	type Error = Error;
123		123
124	fn try_from(v: &'a OsStr) -> Result<Self, Self::Error> {	124	fn try_from(v: &'a OsStr) -> Result<Self, Self::Error> {
125	let v = git_features::path::os_str_into_bytes(v)	125	let v = git_path::os_str_into_bstr(v)
126	.map_err(\|_\| Error::Tag(git_validate::tag::name::Error::InvalidByte("<unknown encoding>".into())))?;	126	.map_err(\|_\| Error::Tag(git_validate::tag::name::Error::InvalidByte("<unknown encoding>".into())))?;
127	Ok(PartialNameRef(	127	Ok(PartialNameRef(
128	git_validate::reference::name_partial(v.as_bstr())?.into(),	128	git_validate::reference::name_partial(v.as_bstr())?.into(),

git-ref/src/namespace.rs+3−10

     }
     /// Return ourselves as a path for use within the filesystem.
     pub fn to_path(&self) -> &Path {
-        git_features::path::from_byte_slice_or_panic_on_windows(&self.0)
+        git_path::from_byte_slice(&self.0)
     }
     /// Append the given `prefix` to this namespace so it becomes usable for prefixed iteration.
     pub fn into_namespaced_prefix(mut self, prefix: impl AsRef<Path>) -> PathBuf {
-        self.0
+        self.0.push_str(git_path::into_bstr(prefix.as_ref()).as_ref());
-            .push_str(git_features::path::into_bytes_or_panic_on_windows(prefix.as_ref()));
+        git_path::to_native_path_on_windows(self.0.clone()).into_owned()
-        git_features::path::from_byte_vec_or_panic_on_windows(
-            git_features::path::convert::to_native_separators({
-                let v: Vec<_> = self.0.into();
-                v
-            })
-            .into_owned(),
-        )
     }
 }

git-ref/src/store/file/find.rs+1−1

@@ -124,7 +124,7 @@ impl file::Store { · 123 unmodified lines
124	};	124	};
125	let relative_path = base.join(inbetween).join(relative_path);	125	let relative_path = base.join(inbetween).join(relative_path);
126		126
127	let path_to_open = git_features::path::convert::to_windows_separators_on_windows_or_panic(&relative_path);	127	let path_to_open = git_path::to_native_path_on_windows(git_path::into_bstr(&relative_path));
128	let contents = match self	128	let contents = match self
129	.ref_contents(&path_to_open)	129	.ref_contents(&path_to_open)
130	.map_err(\|err\| Error::ReadFileContents {	130	.map_err(\|err\| Error::ReadFileContents {

git-ref/src/store/file/loose/iter.rs+6−7

                         .as_deref()
                         .and_then(|prefix| full_path.file_name().map(|name| (prefix, name)))
                     {
-                        match git_features::path::os_str_into_bytes(name) {
+                        match git_path::os_str_into_bstr(name) {
                             Ok(name) => {
                                 if !name.starts_with(prefix) {
                                     continue;
                     let full_name = full_path
                         .strip_prefix(&self.base)
                         .expect("prefix-stripping cannot fail as prefix is our root");
-                    let full_name = match git_features::path::into_bytes(full_name) {
+                    let full_name = match git_path::try_into_bstr(full_name) {
                         Ok(name) => {
-                            #[cfg(windows)]
+                            let name = git_path::to_unix_separators_on_windows(name);
-                            let name = git_features::path::convert::to_unix_separators(name);
                             name.into_owned()
                         }
                         Err(_) => continue, // TODO: silently skipping ill-formed UTF-8 on windows here, maybe there are better ways?
                     };
                     if git_validate::reference::name_partial(full_name.as_bstr()).is_ok() {
-                        let name = FullName(full_name.into());
+                        let name = FullName(full_name);
                         return Some(Ok((full_path, name)));
                     } else {
                         continue;
                 base.file_name()
                     .map(ToOwned::to_owned)
                     .map(|p| {
-                        git_features::path::into_bytes(PathBuf::from(p))
+                        git_path::try_into_bstr(PathBuf::from(p))
-                            .map(|p| BString::from(p.into_owned()))
+                            .map(|p| p.into_owned())
                             .map_err(|_| {
                                 std::io::Error::new(
                                     std::io::ErrorKind::InvalidInput,

git-ref/src/store/file/mod.rs+2−6

@@ -53,12 +53,8 @@ pub struct Transaction<'s> { · 52 unmodified lines
53	}	53	}
54		54
55	pub(in crate::store_impl::file) fn path_to_name<'a>(path: impl Into<Cow<'a, Path>>) -> Cow<'a, BStr> {	55	pub(in crate::store_impl::file) fn path_to_name<'a>(path: impl Into<Cow<'a, Path>>) -> Cow<'a, BStr> {
56	let path = git_features::path::into_bytes_or_panic_on_windows(path.into());	56	let path = git_path::into_bstr(path.into());
57		57	git_path::to_unix_separators_on_windows(path)
58	#[cfg(windows)]
59	let path = git_features::path::convert::to_unix_separators(path);
60
61	git_features::path::convert::into_bstr(path)
62	}	58	}
63		59
64	///	60	///

git-repository/Cargo.toml+6−3

 #! ### Other
 ## Data structures implement `serde::Serialize` and `serde::Deserialize`.
-serde1 = ["git-pack/serde1", "git-object/serde1", "git-protocol/serde1", "git-transport/serde1", "git-ref/serde1", "git-odb/serde1", "git-index/serde1", "git-mailmap/serde1"]
+serde1 = ["git-pack/serde1", "git-object/serde1", "git-protocol/serde1", "git-transport/serde1", "git-ref/serde1", "git-odb/serde1", "git-index/serde1", "git-mailmap/serde1", "git-attributes/serde1"]
 ## Activate other features that maximize performance, like usage of threads, `zlib-ng` and access to caching in object databases.
 ## **Note** that
 max-performance = ["git-features/parallel", "git-features/zlib-ng-compat", "git-pack/pack-cache-lru-static", "git-pack/pack-cache-lru-dynamic"]
 local-time-support = ["git-actor/local-time-support"]
 ## Re-export stability tier 2 crates for convenience and make `Repository` struct fields with types from these crates publicly accessible.
 ## Doing so is less stable than the stability tier 1 that `git-repository` is a member of.
-unstable = ["git-index", "git-worktree", "git-mailmap", "git-glob", "git-credentials"]
+unstable = ["git-index", "git-worktree", "git-mailmap", "git-glob", "git-credentials", "git-path", "git-attributes"]
 ## Print debugging information about usage of object database caches, useful for tuning cache sizes.
 cache-efficiency-debug = ["git-features/cache-efficiency-debug"]
 git-tempfile = { version = "^2.0.0", path = "../git-tempfile" }
 git-lock = { version = "^2.0.0", path = "../git-lock" }
 git-validate = { version ="^0.5.3", path = "../git-validate" }
-git-sec = { version = "^0.1.0", path = "../git-sec" }
+git-sec = { version = "^0.1.0", path = "../git-sec", features = ["thiserror"] }
 git-config = { version = "^0.2.1", path = "../git-config" }
 git-odb = { version = "^0.28.0", path = "../git-odb" }
 git-pack = { version = "^0.18.0", path = "../git-pack", features = ["object-cache-dynamic"] }
 git-revision = { version = "^0.1.0", path = "../git-revision" }
+git-path = { version = "^0.1.0", path = "../git-path", optional = true }
 git-url = { version = "^0.4.0", path = "../git-url", optional = true }
 git-traverse = { version = "^0.14.0", path = "../git-traverse" }
 git-protocol = { version = "^0.15.0", path = "../git-protocol", optional = true }
 git-features = { version = "^0.20.0", path = "../git-features", features = ["progress"] }
 # unstable only
+git-attributes = { version = "^0.1.0", path = "../git-attributes", optional = true }
 git-glob = { version = "^0.2.0", path = "../git-glob", optional = true }
 git-credentials = { version = "^0.1.0", path = "../git-credentials", optional = true }
 git-index = { version = "^0.2.0", path = "../git-index", optional = true }
 [dev-dependencies]
 git-testtools = { path = "../tests/tools" }
+is_ci = "1.1.1"
 anyhow = "1"
 tempfile = "3.2.0"

git-repository/src/config.rs+85−33

@@ -1,4 +1,5 @@
1	use crate::bstr::BString;	1	use crate::bstr::BString;
		2	use crate::permission::EnvVarResourcePermission;
2		3
3	#[derive(Debug, thiserror::Error)]	4	#[derive(Debug, thiserror::Error)]
4	pub enum Error {	5	pub enum Error {
@@ -10,85 +11,112 @@ pub enum Error { · 5 unmodified lines
10	EmptyValue { key: &'static str },	11	EmptyValue { key: &'static str },
11	#[error("Invalid value for 'core.abbrev' = '{}'. It must be between 4 and {}", .value, .max)]	12	#[error("Invalid value for 'core.abbrev' = '{}'. It must be between 4 and {}", .value, .max)]
12	CoreAbbrev { value: BString, max: u8 },	13	CoreAbbrev { value: BString, max: u8 },
		14	#[error("Value '{}' at key '{}' could not be decoded as boolean", .value, .key)]
		15	DecodeBoolean { key: String, value: BString },
		16	#[error(transparent)]
		17	PathInterpolation(#[from] git_config::values::path::interpolate::Error),
13	}	18	}
14		19
15	/// Utility type to keep pre-obtained configuration values.	20	/// Utility type to keep pre-obtained configuration values.
16	#[derive(Debug, Clone)]	21	#[derive(Debug, Clone)]
17	pub(crate) struct Cache {	22	pub(crate) struct Cache {
18	// TODO: remove this once resolved is used without a feature dependency	23	// TODO: remove this once resolved is used without a feature dependency
19	#[cfg_attr(not(feature = "git-mailmap"), allow(dead_code))]	24	#[cfg_attr(not(any(feature = "git-mailmap", feature = "git-index")), allow(dead_code))]
20	pub resolved: crate::Config,	25	pub resolved: crate::Config,
21	/// The hex-length to assume when shortening object ids. If `None`, it should be computed based on the approximate object count.	26	/// The hex-length to assume when shortening object ids. If `None`, it should be computed based on the approximate object count.
22	pub hex_len: Option<usize>,	27	pub hex_len: Option<usize>,
23	/// true if the repository is designated as 'bare', without work tree	28	/// true if the repository is designated as 'bare', without work tree.
24	pub is_bare: bool,	29	pub is_bare: bool,
25	/// The type of hash to use	30	/// The type of hash to use.
26	pub object_hash: git_hash::Kind,	31	pub object_hash: git_hash::Kind,
27	/// If true, multi-pack indices, whether present or not, may be used by the object database.	32	/// If true, multi-pack indices, whether present or not, may be used by the object database.
28	pub use_multi_pack_index: bool,	33	pub use_multi_pack_index: bool,
		34	/// If true, we are on a case-insensitive file system.
		35	#[cfg_attr(not(feature = "git-index"), allow(dead_code))]
		36	pub ignore_case: bool,
		37	/// The path to the user-level excludes file to ignore certain files in the worktree.
		38	#[cfg_attr(not(feature = "git-index"), allow(dead_code))]
		39	pub excludes_file: Option<std::path::PathBuf>,
		40	/// Define how we can use values obtained with `xdg_config(…)` and its `XDG_CONFIG_HOME` variable.
		41	#[cfg_attr(not(feature = "git-index"), allow(dead_code))]
		42	xdg_config_home_env: EnvVarResourcePermission,
		43	/// Define how we can use values obtained with `xdg_config(…)`. and its `HOME` variable.
		44	#[cfg_attr(not(feature = "git-index"), allow(dead_code))]
		45	home_env: EnvVarResourcePermission,
29	// TODO: make core.precomposeUnicode available as well.	46	// TODO: make core.precomposeUnicode available as well.
30	}	47	}
31		48
32	mod cache {	49	mod cache {
33	use std::{borrow::Cow, convert::TryFrom};	50	use std::convert::TryFrom;
		51	use std::path::PathBuf;
34		52
35	use git_config::{	53	use git_config::{
36	file::GitConfig,	54	file::GitConfig,
37	values,
38	values::{Boolean, Integer},	55	values::{Boolean, Integer},
39	};	56	};
40		57
41	use super::{Cache, Error};	58	use super::{Cache, Error};
42	use crate::bstr::ByteSlice;	59	use crate::bstr::ByteSlice;
		60	use crate::permission::EnvVarResourcePermission;
43		61
44	impl Cache {	62	impl Cache {
45	pub fn new(git_dir: &std::path::Path) -> Result<Self, Error> {	63	pub fn new(
		64	git_dir: &std::path::Path,
		65	xdg_config_home_env: EnvVarResourcePermission,
		66	home_env: EnvVarResourcePermission,
		67	git_install_dir: Option<&std::path::Path>,
		68	) -> Result<Self, Error> {
46	let config = GitConfig::open(git_dir.join("config"))?;	69	let config = GitConfig::open(git_dir.join("config"))?;
47	let is_bare = config_bool(&config, "core.bare", false);	70
48	let use_multi_pack_index = config_bool(&config, "core.multiPackIndex", true);	71	let is_bare = config_bool(&config, "core.bare", false)?;
		72	let use_multi_pack_index = config_bool(&config, "core.multiPackIndex", true)?;
		73	let ignore_case = config_bool(&config, "core.ignorecase", false)?;
		74	let excludes_file = config
		75	.path("core", None, "excludesFile")
		76	.map(\|p\| p.interpolate(git_install_dir).map(\|p\| p.into_owned()))
		77	.transpose()?;
49	let repo_format_version = config	78	let repo_format_version = config
50	.value::<Integer>("core", None, "repositoryFormatVersion")	79	.value::<Integer>("core", None, "repositoryFormatVersion")
51	.map_or(0, \|v\| v.value);	80	.map_or(0, \|v\| v.value);
52	let object_hash = if repo_format_version == 1 {	81	let object_hash = (repo_format_version != 1)
53	if let Ok(format) = config.value::<Cow<'_, [u8]>>("extensions", None, "objectFormat") {	82	.then(\|\| Ok(git_hash::Kind::Sha1))
54	match format.as_ref() {	83	.or_else(\|\| {
55	b"sha1" => git_hash::Kind::Sha1,	84	config
56	_ => {	85	.raw_value("extensions", None, "objectFormat")
57	return Err(Error::UnsupportedObjectFormat {	86	.ok()
		87	.map(\|format\| match format.as_ref() {
		88	b"sha1" => Ok(git_hash::Kind::Sha1),
		89	_ => Err(Error::UnsupportedObjectFormat {
58	name: format.to_vec().into(),	90	name: format.to_vec().into(),
59	})	91	}),
60	}	92	})
61	}	93	})
62	} else {	94	.transpose()?
63	git_hash::Kind::Sha1	95	.unwrap_or(git_hash::Kind::Sha1);
64	}
65	} else {
66	git_hash::Kind::Sha1
67	};
68		96
69	let mut hex_len = None;	97	let mut hex_len = None;
70	if let Ok(hex_len_str) = config.value::<values::String<'_>>("core", None, "abbrev") {	98	if let Some(hex_len_str) = config.string("core", None, "abbrev") {
71	if hex_len_str.value.trim().is_empty() {	99	if hex_len_str.trim().is_empty() {
72	return Err(Error::EmptyValue { key: "core.abbrev" });	100	return Err(Error::EmptyValue { key: "core.abbrev" });
73	}	101	}
74	if hex_len_str.value.as_ref() != "auto" {	102	if hex_len_str.as_ref() != "auto" {
75	let value_bytes = hex_len_str.value.as_ref().as_ref();	103	let value_bytes = hex_len_str.as_ref().as_ref();
76	if let Ok(Boolean::False(_)) = Boolean::try_from(value_bytes) {	104	if let Ok(Boolean::False(_)) = Boolean::try_from(value_bytes) {
77	hex_len = object_hash.len_in_hex().into();	105	hex_len = object_hash.len_in_hex().into();
78	} else {	106	} else {
79	let value = Integer::try_from(value_bytes)	107	let value = Integer::try_from(value_bytes)
80	.map_err(\|_\| Error::CoreAbbrev {	108	.map_err(\|_\| Error::CoreAbbrev {
81	value: hex_len_str.value.clone().into_owned(),	109	value: hex_len_str.clone().into_owned(),
82	max: object_hash.len_in_hex() as u8,	110	max: object_hash.len_in_hex() as u8,
83	})?	111	})?
84	.to_decimal()	112	.to_decimal()
85	.ok_or_else(\|\| Error::CoreAbbrev {	113	.ok_or_else(\|\| Error::CoreAbbrev {
86	value: hex_len_str.value.clone().into_owned(),	114	value: hex_len_str.clone().into_owned(),
87	max: object_hash.len_in_hex() as u8,	115	max: object_hash.len_in_hex() as u8,
88	})?;	116	})?;
89	if value < 4 \|\| value as usize > object_hash.len_in_hex() {	117	if value < 4 \|\| value as usize > object_hash.len_in_hex() {
90	return Err(Error::CoreAbbrev {	118	return Err(Error::CoreAbbrev {
91	value: hex_len_str.value.clone().into_owned(),	119	value: hex_len_str.clone().into_owned(),
92	max: object_hash.len_in_hex() as u8,	120	max: object_hash.len_in_hex() as u8,
93	});	121	});
94	}	122	}
@@ -102,15 +130,39 @@ mod cache { · 7 unmodified lines
102	use_multi_pack_index,	130	use_multi_pack_index,
103	object_hash,	131	object_hash,
104	is_bare,	132	is_bare,
		133	ignore_case,
105	hex_len,	134	hex_len,
		135	excludes_file,
		136	xdg_config_home_env,
		137	home_env,
106	})	138	})
107	}	139	}
		140
		141	/// Return a path by using the `$XDF_CONFIG_HOME` or `$HOME/.config/…` environment variables locations.
		142	#[cfg_attr(not(feature = "git-index"), allow(dead_code))]
		143	pub fn xdg_config_path(
		144	&self,
		145	resource_file_name: &str,
		146	) -> Result<Option<PathBuf>, git_sec::permission::Error<PathBuf, git_sec::Permission>> {
		147	std::env::var_os("XDG_CONFIG_HOME")
		148	.map(\|path\| (path, &self.xdg_config_home_env))
		149	.or_else(\|\| std::env::var_os("HOME").map(\|path\| (path, &self.home_env)))
		150	.and_then(\|(base, permission)\| {
		151	let resource = std::path::PathBuf::from(base).join("git").join(resource_file_name);
		152	permission.check(resource).transpose()
		153	})
		154	.transpose()
		155	}
108	}	156	}
109		157
110	fn config_bool(config: &GitConfig<'_>, key: &str, default: bool) -> bool {	158	fn config_bool(config: &GitConfig<'_>, key: &str, default: bool) -> Result<bool, Error> {
111	let (section, key) = key.split_once('.').expect("valid section.key format");	159	let (section, key) = key.split_once('.').expect("valid section.key format");
112	config	160	config
113	.value::<Boolean<'_>>(section, None, key)	161	.boolean(section, None, key)
114	.map_or(default, \|b\| b.to_bool())	162	.unwrap_or(Ok(default))
		163	.map_err(\|err\| Error::DecodeBoolean {
		164	value: err.input,
		165	key: key.into(),
		166	})
115	}	167	}
116	}	168	}

git-repository/src/lib.rs+20−4

 //! even if this crate doesn't, hence breaking downstream.
 //!
 //! `git_repository::`
+//! * [`attrs`]
 //! * [`hash`]
 //! * [`url`]
 //! * [`actor`]
 //! * [`bstr`][bstr]
 //! * [`index`]
 //! * [`glob`]
+//! * [`path`]
 //! * [`credentials`]
 //! * [`sec`]
 //! * [`worktree`]
 // This also means that their major version changes affect our major version, but that's alright as we directly expose their
 // APIs/instances anyway.
 pub use git_actor as actor;
+#[cfg(all(feature = "unstable", feature = "git-attributes"))]
+pub use git_attributes as attrs;
 #[cfg(all(feature = "unstable", feature = "git-credentials"))]
 pub use git_credentials as credentials;
 #[cfg(all(feature = "unstable", feature = "git-diff"))]
 #[doc(inline)]
 #[cfg(all(feature = "unstable", feature = "git-url"))]
 pub use git_url::Url;
-#[cfg(all(feature = "unstable", feature = "git-worktree"))]
-pub use git_worktree as worktree;
 pub use hash::{oid, ObjectId};
 pub mod interrupt;
 ///
 mod types;
-pub use types::{Commit, DetachedObject, Head, Id, Object, Reference, Repository, Tag, ThreadSafeRepository, Tree};
+pub use types::{
+    Commit, DetachedObject, Head, Id, Object, Reference, Repository, Tag, ThreadSafeRepository, Tree, Worktree,
+};
 pub mod commit;
 pub mod head;
 pub mod object;
 pub mod reference;
 mod repository;
-pub use repository::{permissions, permissions::Permissions};
 pub mod tag;
 /// The kind of `Repository`
     ThreadSafeRepository::open(directory).map(Into::into)
 }
+///
+pub mod permission {
+    use git_sec::permission::Resource;
+    use git_sec::Access;
+    /// A permission to control access to the resource pointed to an environment variable.
+    pub type EnvVarResourcePermission = Access<Resource, git_sec::Permission>;
+}
+pub use repository::permissions::Permissions;
 ///
 pub mod open;
     }
 }
+///
+pub mod worktree;
 ///
 pub mod rev_parse {
     /// The error returned by [`crate::Repository::rev_parse()`].

git-repository/src/open.rs+13−3

         Options {
             object_store_slots,
             replacement_objects,
-            permissions,
+            permissions:
+                Permissions {
+                    git_dir: git_dir_perm,
+                    xdg_config_home,
+                    home,
+                },
         }: Options,
     ) -> Result<Self, Error> {
-        if *permissions.git_dir != git_sec::ReadWrite::all() {
+        if *git_dir_perm != git_sec::ReadWrite::all() {
             // TODO: respect `save.directory`, which needs more support from git-config to do properly.
             return Err(Error::UnsafeGitDir { path: git_dir });
         }
         //       This would be something read in later as have to first check for extensions. Also this means
         //       that each worktree, even if accessible through this instance, has to come in its own Repository instance
         //       as it may have its own configuration. That's fine actually.
-        let config = crate::config::Cache::new(&git_dir)?;
+        let config = crate::config::Cache::new(
+            &git_dir,
+            xdg_config_home,
+            home,
+            crate::path::install_dir().ok().as_deref(),
+        )?;
         match worktree_dir {
             None if !config.is_bare => {
                 worktree_dir = Some(git_dir.parent().expect("parent is always available").to_owned());

git-repository/src/path/discover.rs+47−23

     InaccessibleDirectory { path: PathBuf },
     #[error("Could find a git repository in '{}' or in any of its parents", .path.display())]
     NoGitRepository { path: PathBuf },
+    #[error("Could find a trusted git repository in '{}' or in any of its parents, candidate at '{}' discarded", .path.display(), .candidate.display())]
+    NoTrustedGitRepository {
+        path: PathBuf,
+        candidate: PathBuf,
+        required: git_sec::Trust,
+    },
     #[error("Could not determine trust level for path '{}'.", .path.display())]
     CheckTrust {
         path: PathBuf,
         // us the parent directory. (`Path::parent` just strips off the last
         // path component, which means it will not do what you expect when
         // working with paths paths that contain '..'.)
-        let directory = maybe_canonicalize(directory.as_ref()).map_err(|_| Error::InaccessibleDirectory {
+        let directory = directory.as_ref();
-            path: directory.as_ref().into(),
+        let dir = maybe_canonicalize(directory).map_err(|_| Error::InaccessibleDirectory { path: directory.into() })?;
-        })?;
+        let is_canonicalized = dir.as_ref() != directory;
-        if !directory.is_dir() {
+        if !dir.is_dir() {
-            return Err(Error::InaccessibleDirectory {
+            return Err(Error::InaccessibleDirectory { path: dir.into_owned() });
-                path: directory.into_owned(),
-            });
         }
-        let filter_by_trust =
+        let filter_by_trust = |x: &std::path::Path| -> Result<Option<git_sec::Trust>, Error> {
-            |x: &std::path::Path, kind: crate::path::Kind| -> Result<Option<(crate::Path, git_sec::Trust)>, Error> {
+            let trust =
-                let trust =
+                git_sec::Trust::from_path_ownership(x).map_err(|err| Error::CheckTrust { path: x.into(), err })?;
-                    git_sec::Trust::from_path_ownership(x).map_err(|err| Error::CheckTrust { path: x.into(), err })?;
+            Ok((trust >= required_trust).then(|| (trust)))
-                Ok((trust >= required_trust).then(|| (crate::Path::from_dot_git_dir(x, kind), trust)))
+        };
-            };
-        let mut cursor = directory.clone();
+        let mut cursor = dir.clone();
         'outer: loop {
             for append_dot_git in &[false, true] {
                 if *append_dot_git {
                     }
                 }
                 if let Ok(kind) = path::is::git(&cursor) {
-                    match filter_by_trust(&cursor, kind)? {
+                    match filter_by_trust(&cursor)? {
-                        Some(res) => break 'outer Ok(res),
+                        Some(trust) => {
+                            // TODO: test this more
+                            let path = if is_canonicalized {
+                                match std::env::current_dir() {
+                                    Ok(cwd) => cwd
+                                        .strip_prefix(&cursor.parent().expect(".git appended"))
+                                        .ok()
+                                        .and_then(|p| {
+                                            let short_path_components = p.components().count();
+                                            (short_path_components < cursor.components().count()).then(|| {
+                                                std::iter::repeat("..")
+                                                    .take(short_path_components)
+                                                    .chain(Some(".git"))
+                                                    .collect()
+                                            })
+                                        })
+                                        .unwrap_or_else(|| cursor.into_owned()),
+                                    Err(_) => cursor.into_owned(),
+                                }
+                            } else {
+                                cursor.into_owned()
+                            };
+                            break 'outer Ok((crate::Path::from_dot_git_dir(path, kind), trust));
+                        }
                         None => {
-                            break 'outer Err(Error::NoGitRepository {
+                            break 'outer Err(Error::NoTrustedGitRepository {
-                                path: directory.into_owned(),
+                                path: dir.into_owned(),
+                                candidate: cursor.into_owned(),
+                                required: required_trust,
                             })
                         }
                     }
             }
             match cursor.parent() {
                 Some(parent) => cursor = parent.to_owned().into(),
-                None => {
+                None => break Err(Error::NoGitRepository { path: dir.into_owned() }),
-                    break Err(Error::NoGitRepository {
-                        path: directory.into_owned(),
-                    })
-                }
             }
         }
     }

git-repository/src/path/is.rs+1−0

@@ -28,6 +28,7 @@ pub fn bare(git_dir_candidate: impl AsRef<Path>) -> bool { · 27 unmodified lines
28	/// What constitutes a valid git repository, and what's yet to be implemented, returning the guessed repository kind	28	/// What constitutes a valid git repository, and what's yet to be implemented, returning the guessed repository kind
29	/// purely based on the presence of files. Note that the git-config ultimately decides what's bare.	29	/// purely based on the presence of files. Note that the git-config ultimately decides what's bare.
30	///	30	///
		31	/// * [ ] git files
31	/// * [x] a valid head	32	/// * [x] a valid head
32	/// * [ ] git common directory	33	/// * [ ] git common directory
33	/// * [ ] respect GIT_COMMON_DIR	34	/// * [ ] respect GIT_COMMON_DIR

git-repository/src/path/mod.rs+16−1

 use crate::{Kind, Path};
+#[cfg(all(feature = "unstable", feature = "git-path"))]
+pub use git_path::*;
 ///
 pub mod create;
 ///
     pub fn from_dot_git_dir(dir: impl Into<PathBuf>, kind: Kind) -> Self {
         let dir = dir.into();
         match kind {
-            Kind::WorkTree => Path::WorkTree(dir.parent().expect("this is a sub-directory").to_owned()),
+            Kind::WorkTree => Path::WorkTree(if dir == std::path::Path::new(".git") {
+                PathBuf::from(".")
+            } else {
+                dir.parent().expect("this is a sub-directory").to_owned()
+            }),
             Kind::Bare => Path::Repository(dir),
         }
     }
         }
     }
 }
+pub(crate) fn install_dir() -> std::io::Result<std::path::PathBuf> {
+    std::env::current_exe().and_then(|exe| {
+        exe.parent()
+            .map(ToOwned::to_owned)
+            .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::Other, "no parent for current executable"))
+    })
+}

git-repository/src/repository/init.rs+32−0

@@ -0,0 +1,32 @@
	1	use std::cell::RefCell;
	2
	3	impl crate::Repository {
	4	pub(crate) fn from_refs_and_objects(
	5	refs: crate::RefStore,
	6	objects: crate::OdbHandle,
	7	work_tree: Option<std::path::PathBuf>,
	8	config: crate::config::Cache,
	9	) -> Self {
	10	crate::Repository {
	11	bufs: RefCell::new(Vec::with_capacity(4)),
	12	work_tree,
	13	objects: {
	14	#[cfg(feature = "max-performance")]
	15	{
	16	objects.with_pack_cache(\|\| Box::new(git_pack::cache::lru::StaticLinkedList::<64>::default()))
	17	}
	18	#[cfg(not(feature = "max-performance"))]
	19	{
	20	objects
	21	}
	22	},
	23	refs,
	24	config,
	25	}
	26	}
	27
	28	/// Convert this instance into a [`ThreadSafeRepository`][crate::ThreadSafeRepository] by dropping all thread-local data.
	29	pub fn into_sync(self) -> crate::ThreadSafeRepository {
	30	self.into()
	31	}
	32	}

git-repository/src/repository/location.rs+25−4

@@ -12,10 +12,31 @@ impl crate::Repository { · 11 unmodified lines
12	// TODO: tests, respect precomposeUnicode	12	// TODO: tests, respect precomposeUnicode
13	/// The directory of the binary path of the current process.	13	/// The directory of the binary path of the current process.
14	pub fn install_dir(&self) -> std::io::Result<std::path::PathBuf> {	14	pub fn install_dir(&self) -> std::io::Result<std::path::PathBuf> {
15	std::env::current_exe().and_then(\|exe\| {	15	crate::path::install_dir()
16	exe.parent()	16	}
17	.map(ToOwned::to_owned)	17
18	.ok_or_else(\|\| std::io::Error::new(std::io::ErrorKind::Other, "no parent for current executable"))	18	/// Returns the relative path which is the components between the working tree and the current working dir (CWD).
		19	/// Note that there may be `None` if there is no work tree, even though the `PathBuf` will be empty
		20	/// if the CWD is at the root of the work tree.
		21	// TODO: tests, details - there is a lot about environment variables to change things around.
		22	pub fn prefix(&self) -> Option<std::io::Result<std::path::PathBuf>> {
		23	self.work_tree.as_ref().map(\|root\| {
		24	root.canonicalize().and_then(\|root\| {
		25	std::env::current_dir().and_then(\|cwd\| {
		26	cwd.strip_prefix(&root)
		27	.map_err(\|_\| {
		28	std::io::Error::new(
		29	std::io::ErrorKind::Other,
		30	format!(
		31	"CWD '{}' isn't within the work tree '{}'",
		32	cwd.display(),
		33	root.display()
		34	),
		35	)
		36	})
		37	.map(ToOwned::to_owned)
		38	})
		39	})
19	})	40	})
20	}	41	}
21		42

git-repository/src/repository/mod.rs+4−90

@@ -39,98 +39,12 @@ impl crate::Repository { · 38 unmodified lines
39	}	39	}
40	}	40	}
41		41
42	/// Various permissions for parts of git repositories.	42	mod worktree;
43	pub mod permissions {
44	use git_sec::permission::Resource;
45	use git_sec::{Access, Trust};
46
47	/// Permissions associated with various resources of a git repository
48	pub struct Permissions {
49	/// Control how a git-dir can be used.
50	///
51	/// Note that a repository won't be usable at all unless read and write permissions are given.
52	pub git_dir: Access<Resource, git_sec::ReadWrite>,
53	}
54
55	impl Permissions {
56	/// Return permissions similar to what git does when the repository isn't owned by the current user,
57	/// thus refusing all operations in it.
58	pub fn strict() -> Self {
59	Permissions {
60	git_dir: Access::resource(git_sec::ReadWrite::empty()),
61	}
62	}
63
64	/// Return permissions that will not include configuration files not owned by the current user,
65	/// but trust system and global configuration files along with those which are owned by the current user.
66	///
67	/// This allows to read and write repositories even if they aren't owned by the current user, but avoid using
68	/// anything else that could cause us to write into unknown locations or use programs beyond our `PATH`.
69	pub fn secure() -> Self {
70	Permissions {
71	git_dir: Access::resource(git_sec::ReadWrite::all()),
72	}
73	}
74
75	/// Everything is allowed with this set of permissions, thus we read all configuration and do what git typically
76	/// does with owned repositories.
77	pub fn all() -> Self {
78	Permissions {
79	git_dir: Access::resource(git_sec::ReadWrite::all()),
80	}
81	}
82	}
83		43
84	impl git_sec::trust::DefaultForLevel for Permissions {	44	/// Various permissions for parts of git repositories.
85	fn default_for_level(level: Trust) -> Self {	45	pub(crate) mod permissions;
86	match level {
87	Trust::Full => Permissions::all(),
88	Trust::Reduced => Permissions::secure(),
89	}
90	}
91	}
92
93	impl Default for Permissions {
94	fn default() -> Self {
95	Permissions::secure()
96	}
97	}
98	}
99
100	mod init {
101	use std::cell::RefCell;
102
103	impl crate::Repository {
104	pub(crate) fn from_refs_and_objects(
105	refs: crate::RefStore,
106	objects: crate::OdbHandle,
107	work_tree: Option<std::path::PathBuf>,
108	config: crate::config::Cache,
109	) -> Self {
110	crate::Repository {
111	bufs: RefCell::new(Vec::with_capacity(4)),
112	work_tree,
113	objects: {
114	#[cfg(feature = "max-performance")]
115	{
116	objects.with_pack_cache(\|\| Box::new(git_pack::cache::lru::StaticLinkedList::<64>::default()))
117	}
118	#[cfg(not(feature = "max-performance"))]
119	{
120	objects
121	}
122	},
123	refs,
124	config,
125	}
126	}
127		46
128	/// Convert this instance into a [`ThreadSafeRepository`][crate::ThreadSafeRepository] by dropping all thread-local data.	47	mod init;
129	pub fn into_sync(self) -> crate::ThreadSafeRepository {
130	self.into()
131	}
132	}
133	}
134		48
135	mod location;	49	mod location;
136		50

git-repository/src/repository/permissions.rs+67−0

@@ -0,0 +1,67 @@
	1	use crate::permission::EnvVarResourcePermission;
	2	use git_sec::permission::Resource;
	3	use git_sec::{Access, Trust};
	4
	5	/// Permissions associated with various resources of a git repository
	6	pub struct Permissions {
	7	/// Control how a git-dir can be used.
	8	///
	9	/// Note that a repository won't be usable at all unless read and write permissions are given.
	10	pub git_dir: Access<Resource, git_sec::ReadWrite>,
	11	/// Control whether resources pointed to by `XDG_CONFIG_HOME` can be used when looking up common configuration values.
	12	///
	13	/// Note that [`git_sec::Permission::Forbid`] will cause the operation to abort if a resource is set via the XDG config environment.
	14	pub xdg_config_home: EnvVarResourcePermission,
	15	/// Control if resources pointed to by the
	16	pub home: EnvVarResourcePermission,
	17	}
	18
	19	impl Permissions {
	20	/// Return permissions similar to what git does when the repository isn't owned by the current user,
	21	/// thus refusing all operations in it.
	22	pub fn strict() -> Self {
	23	Permissions {
	24	git_dir: Access::resource(git_sec::ReadWrite::empty()),
	25	xdg_config_home: Access::resource(git_sec::Permission::Allow),
	26	home: Access::resource(git_sec::Permission::Allow),
	27	}
	28	}
	29
	30	/// Return permissions that will not include configuration files not owned by the current user,
	31	/// but trust system and global configuration files along with those which are owned by the current user.
	32	///
	33	/// This allows to read and write repositories even if they aren't owned by the current user, but avoid using
	34	/// anything else that could cause us to write into unknown locations or use programs beyond our `PATH`.
	35	pub fn secure() -> Self {
	36	Permissions {
	37	git_dir: Access::resource(git_sec::ReadWrite::all()),
	38	xdg_config_home: Access::resource(git_sec::Permission::Allow),
	39	home: Access::resource(git_sec::Permission::Allow),
	40	}
	41	}
	42
	43	/// Everything is allowed with this set of permissions, thus we read all configuration and do what git typically
	44	/// does with owned repositories.
	45	pub fn all() -> Self {
	46	Permissions {
	47	git_dir: Access::resource(git_sec::ReadWrite::all()),
	48	xdg_config_home: Access::resource(git_sec::Permission::Allow),
	49	home: Access::resource(git_sec::Permission::Allow),
	50	}
	51	}
	52	}
	53
	54	impl git_sec::trust::DefaultForLevel for Permissions {
	55	fn default_for_level(level: Trust) -> Self {
	56	match level {
	57	Trust::Full => Permissions::all(),
	58	Trust::Reduced => Permissions::secure(),
	59	}
	60	}
	61	}
	62
	63	impl Default for Permissions {
	64	fn default() -> Self {
	65	Permissions::secure()
	66	}
	67	}

git-repository/src/repository/snapshots.rs+1−1

@@ -48,7 +48,7 @@ impl crate::Repository { · 47 unmodified lines
48	let mut blob_id = self	48	let mut blob_id = self
49	.config	49	.config
50	.resolved	50	.resolved
51	.get_raw_value("mailmap", None, "blob")	51	.raw_value("mailmap", None, "blob")
52	.ok()	52	.ok()
53	.and_then(\|spec\| {	53	.and_then(\|spec\| {
54	// TODO: actually resolve this as spec (once we can do that)	54	// TODO: actually resolve this as spec (once we can do that)

git-repository/src/repository/worktree.rs+21−0

@@ -0,0 +1,21 @@
	1	use crate::{worktree, Worktree};
	2
	3	impl crate::Repository {
	4	/// Return a platform for interacting with worktrees
	5	pub fn worktree(&self) -> worktree::Platform<'_> {
	6	worktree::Platform { parent: self }
	7	}
	8	}
	9
	10	impl<'repo> worktree::Platform<'repo> {
	11	/// Return the currently set worktree if there is one.
	12	///
	13	/// Note that there would be `None` if this repository is `bare` and the parent [`Repository`][crate::Repository] was instantiated without
	14	/// registered worktree in the current working dir.
	15	pub fn current(&self) -> Option<Worktree<'repo>> {
	16	self.parent.work_dir().map(\|path\| Worktree {
	17	parent: self.parent,
	18	path,
	19	})
	20	}
	21	}

git-repository/src/types.rs+17−8

 use crate::head;
+/// A worktree checkout containing the files of the repository in consumable form.
+pub struct Worktree<'repo> {
+    #[cfg_attr(not(feature = "git-index"), allow(dead_code))]
+    pub(crate) parent: &'repo Repository,
+    /// The root path of the checkout.
+    #[allow(dead_code)]
+    pub(crate) path: &'repo std::path::Path,
+}
 /// The head reference, as created from looking at `.git/HEAD`, able to represent all of its possible states.
 ///
 /// Note that like [`Reference`], this type's data is snapshot of persisted state on disk.
 pub struct Head<'repo> {
     /// One of various possible states for the HEAD reference
     pub kind: head::Kind,
-    pub(crate) repo: &'repo crate::Repository,
+    pub(crate) repo: &'repo Repository,
 }
 /// An [ObjectId] with access to a repository.
 pub struct Id<'r> {
     /// The actual object id
     pub(crate) inner: ObjectId,
-    pub(crate) repo: &'r crate::Repository,
+    pub(crate) repo: &'r Repository,
 }
 /// A decoded object with a reference to its owning repository.
     pub kind: git_object::Kind,
     /// The fully decoded object data
     pub data: Vec<u8>,
-    pub(crate) repo: &'repo crate::Repository,
+    pub(crate) repo: &'repo Repository,
 }
 impl<'a> Drop for Object<'a> {
     pub id: ObjectId,
     /// The fully decoded tree data
     pub data: Vec<u8>,
-    pub(crate) repo: &'repo crate::Repository,
+    pub(crate) repo: &'repo Repository,
 }
 impl<'a> Drop for Tree<'a> {
     pub id: ObjectId,
     /// The fully decoded tag data
     pub data: Vec<u8>,
-    pub(crate) repo: &'repo crate::Repository,
+    pub(crate) repo: &'repo Repository,
 }
 impl<'a> Drop for Tag<'a> {
     pub id: ObjectId,
     /// The fully decoded commit data
     pub data: Vec<u8>,
-    pub(crate) repo: &'repo crate::Repository,
+    pub(crate) repo: &'repo Repository,
 }
 impl<'a> Drop for Commit<'a> {
 pub struct Reference<'r> {
     /// The actual reference data
     pub inner: git_ref::Reference,
-    pub(crate) repo: &'r crate::Repository,
+    pub(crate) repo: &'r Repository,
 }
 /// A thread-local handle to interact with a repository from a single thread.
 /// An instance with access to everything a git repository entails, best imagined as container implementing `Sync + Send` for _most_
 /// for system resources required to interact with a `git` repository which are loaded in once the instance is created.
 ///
-/// Use this type to reference it in a threaded context for creation the creation of a thread-local [`Repositories`][crate::Repository].
+/// Use this type to reference it in a threaded context for creation the creation of a thread-local [`Repositories`][Repository].
 ///
 /// Note that this type purposefully isn't very useful until it is converted into a thread-local repository with `to_thread_local()`,
 /// it's merely meant to be able to exist in a `Sync` context.

git-repository/src/worktree.rs+129−0

@@ -0,0 +1,129 @@
	1	use crate::Repository;
	2	#[cfg(all(feature = "unstable", feature = "git-worktree"))]
	3	pub use git_worktree::*;
	4
	5	///
	6	#[cfg(feature = "git-index")]
	7	pub mod open_index {
	8	use crate::bstr::BString;
	9
	10	/// The error returned by [`Worktree::open_index()`][crate::Worktree::open_index()].
	11	#[derive(Debug, thiserror::Error)]
	12	#[allow(missing_docs)]
	13	pub enum Error {
	14	#[error("Could not interpret value '{}' as 'index.threads'", .value)]
	15	ConfigIndexThreads {
	16	value: BString,
	17	#[source]
	18	err: git_config::value::parse::Error,
	19	},
	20	#[error(transparent)]
	21	IndexFile(#[from] git_index::file::init::Error),
	22	}
	23	}
	24
	25	///
	26	#[cfg(feature = "git-index")]
	27	pub mod excludes {
	28	use std::path::PathBuf;
	29
	30	/// The error returned by [`Worktree::excludes()`][crate::Worktree::excludes()].
	31	#[derive(Debug, thiserror::Error)]
	32	#[allow(missing_docs)]
	33	pub enum Error {
	34	#[error("Could not read repository exclude.")]
	35	Io(#[from] std::io::Error),
	36	#[error(transparent)]
	37	EnvironmentPermission(#[from] git_sec::permission::Error<PathBuf, git_sec::Permission>),
	38	}
	39	}
	40
	41	/// A structure to make the API more stuctured.
	42	pub struct Platform<'repo> {
	43	pub(crate) parent: &'repo Repository,
	44	}
	45
	46	/// Access
	47	impl<'repo> crate::Worktree<'repo> {
	48	/// Returns the root of the worktree under which all checked out files are located.
	49	pub fn root(&self) -> &std::path::Path {
	50	self.path
	51	}
	52	}
	53
	54	impl<'repo> crate::Worktree<'repo> {
	55	/// Configure a file-system cache checking if files below the repository are excluded.
	56	///
	57	/// This takes into consideration all the usual repository configuration.
	58	// TODO: test
	59	#[cfg(feature = "git-index")]
	60	pub fn excludes<'a>(
	61	&self,
	62	index: &'a git_index::State,
	63	overrides: Option<git_attributes::MatchGroup<git_attributes::Ignore>>,
	64	) -> Result<git_worktree::fs::Cache<'a>, excludes::Error> {
	65	let repo = self.parent;
	66	let case = repo
	67	.config
	68	.ignore_case
	69	.then(\|\| git_glob::pattern::Case::Fold)
	70	.unwrap_or_default();
	71	let mut buf = Vec::with_capacity(512);
	72	let state = git_worktree::fs::cache::State::IgnoreStack(git_worktree::fs::cache::state::Ignore::new(
	73	overrides.unwrap_or_default(),
	74	git_attributes::MatchGroup::<git_attributes::Ignore>::from_git_dir(
	75	repo.git_dir(),
	76	match repo.config.excludes_file.as_ref() {
	77	Some(user_path) => Some(user_path.to_owned()),
	78	None => repo.config.xdg_config_path("ignore")?,
	79	},
	80	&mut buf,
	81	)?,
	82	None,
	83	case,
	84	));
	85	let attribute_list = state.build_attribute_list(index, index.path_backing(), case);
	86	Ok(git_worktree::fs::Cache::new(
	87	self.path,
	88	state,
	89	case,
	90	buf,
	91	attribute_list,
	92	))
	93	}
	94
	95	// pub fn
	96	/// Open a new copy of the index file and decode it entirely.
	97	///
	98	/// It will use the `index.threads` configuration key to learn how many threads to use.
	99	// TODO: test
	100	#[cfg(feature = "git-index")]
	101	pub fn open_index(&self) -> Result<git_index::File, crate::worktree::open_index::Error> {
	102	use std::convert::{TryFrom, TryInto};
	103	let repo = self.parent;
	104	let thread_limit = repo
	105	.config
	106	.resolved
	107	.boolean("index", None, "threads")
	108	.map(\|res\| {
	109	res.map(\|value\| if value { 0usize } else { 1 }).or_else(\|err\| {
	110	git_config::values::Integer::try_from(err.input.as_ref())
	111	.map_err(\|err\| crate::worktree::open_index::Error::ConfigIndexThreads {
	112	value: err.input.clone(),
	113	err,
	114	})
	115	.map(\|value\| value.to_decimal().and_then(\|v\| v.try_into().ok()).unwrap_or(1))
	116	})
	117	})
	118	.transpose()?;
	119	git_index::File::at(
	120	repo.git_dir().join("index"),
	121	git_index::decode::Options {
	122	object_hash: repo.object_hash(),
	123	thread_limit,
	124	min_extension_block_in_bytes_for_threading: 0,
	125	},
	126	)
	127	.map_err(Into::into)
	128	}
	129	}

git-repository/tests/discover/mod.rs+13−10

@@ -1,5 +1,5 @@
1	mod existing {	1	mod existing {
2	use std::path::{Component, PathBuf};	2	use std::path::PathBuf;
3		3
4	use git_repository::Kind;	4	use git_repository::Kind;
5		5
@@ -71,17 +71,20 @@ mod existing { · 65 unmodified lines
71	// up far enough. (This tests that `discover::existing` canonicalizes paths before	71	// up far enough. (This tests that `discover::existing` canonicalizes paths before
72	// exploring ancestors.)	72	// exploring ancestors.)
73	let working_dir = repo_path()?;	73	let working_dir = repo_path()?;
74	let dir = working_dir.join("some/very/deeply/nested/subdir/../../../../../../..");	74	let dir = working_dir.join("some/very/deeply/nested/subdir/../../../../../..");
75	let (path, trust) = git_repository::path::discover(&dir)?;	75	let (path, trust) = git_repository::path::discover(&dir)?;
76	assert_eq!(path.kind(), Kind::WorkTree);	76	assert_eq!(path.kind(), Kind::WorkTree);
77	assert_eq!(	77	if !(cfg!(windows) && is_ci::cached()) {
78	path.as_ref()	78	// On CI on windows we get a cursor like this with a question mark so our prefix check won't work.
79	.components()	79	// We recover, but that means this assertion will fail.
80	.filter(\|c\| matches!(c, Component::ParentDir \| Component::CurDir))	80	// &cursor = "\\\\?\\D:\\a\\gitoxide\\gitoxide\\.git"
81	.count(),	81	// &cwd = "D:\\a\\gitoxide\\gitoxide\\git-repository"
82	0,	82	assert_eq!(
83	"there are no relative path components anymore"	83	path.as_ref(),
84	);	84	std::path::Path::new(".."),
		85	"there is only the minimal amount of relative path components to see this worktree"
		86	);
		87	}
85	assert_ne!(	88	assert_ne!(
86	path.as_ref().canonicalize()?,	89	path.as_ref().canonicalize()?,
87	working_dir.canonicalize()?,	90	working_dir.canonicalize()?,

git-sec/Cargo.toml+1−0

@@ -19,6 +19,7 @@ serde1 = [ "serde" ] · 18 unmodified lines
19	[dependencies]	19	[dependencies]
20	serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"] }	20	serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"] }
21	bitflags = "1.3.2"	21	bitflags = "1.3.2"
		22	thiserror = { version = "1.0.26", optional = true }
22		23
23	[target.'cfg(not(windows))'.dependencies]	24	[target.'cfg(not(windows))'.dependencies]
24	libc = "0.2.123"	25	libc = "0.2.123"

git-sec/src/lib.rs+66−5

@@ -1,6 +1,7 @@
1	#![deny(unsafe_code, rust_2018_idioms, missing_docs)]	1	#![deny(unsafe_code, rust_2018_idioms, missing_docs)]
2	//! A shared trust model for `gitoxide` crates.	2	//! A shared trust model for `gitoxide` crates.
3		3
		4	use std::fmt::{Debug, Display, Formatter};
4	use std::marker::PhantomData;	5	use std::marker::PhantomData;
5	use std::ops::Deref;	6	use std::ops::Deref;
6		7
@@ -75,19 +76,22 @@ pub mod trust { · 68 unmodified lines
75	///	76	///
76	pub mod permission {	77	pub mod permission {
77	use crate::Access;	78	use crate::Access;
		79	use std::fmt::{Debug, Display};
78		80
79	/// A marker trait to signal tags for permissions.	81	/// A marker trait to signal tags for permissions.
80	pub trait Tag {}	82	pub trait Tag: Debug + Clone {}
81		83
82	/// A tag indicating that a permission is applying to the contents of a configuration file.	84	/// A tag indicating that a permission is applying to the contents of a configuration file.
		85	#[derive(Debug, Clone)]
83	pub struct Config;	86	pub struct Config;
84	impl Tag for Config {}	87	impl Tag for Config {}
85		88
86	/// A tag indicating that a permission is applying to the resource itself.	89	/// A tag indicating that a permission is applying to the resource itself.
		90	#[derive(Debug, Clone)]
87	pub struct Resource;	91	pub struct Resource;
88	impl Tag for Resource {}	92	impl Tag for Resource {}
89		93
90	impl<P> Access<Config, P> {	94	impl<P: Debug + Display + Clone> Access<Config, P> {
91	/// Create a permission for values contained in git configuration files.	95	/// Create a permission for values contained in git configuration files.
92	///	96	///
93	/// This applies permissions to values contained inside of these files.	97	/// This applies permissions to values contained inside of these files.
@@ -99,7 +103,7 @@ pub mod permission { · 5 unmodified lines
99	}	103	}
100	}	104	}
101		105
102	impl<P> Access<Resource, P> {	106	impl<P: Debug + Display + Clone> Access<Resource, P> {
103	/// Create a permission a file or directory itself.	107	/// Create a permission a file or directory itself.
104	///	108	///
105	/// This applies permissions to a configuration file itself and whether it can be used at all, or to a directory	109	/// This applies permissions to a configuration file itself and whether it can be used at all, or to a directory
@@ -111,6 +115,20 @@ pub mod permission { · 5 unmodified lines
111	}	115	}
112	}	116	}
113	}	117	}
		118
		119	/// An error to use if an operation cannot proceed due to insufficient permissions.
		120	///
		121	/// It's up to the implementation to decide which permission is required for an operation, and which one
		122	/// causes errors.
		123	#[cfg(feature = "thiserror")]
		124	#[derive(Debug, thiserror::Error)]
		125	#[error("Not allowed to handle resource {:?}: permission {}", .resource, .permission)]
		126	pub struct Error<R: Debug, P: Debug + Display> {
		127	/// The resource which cannot be used.
		128	pub resource: R,
		129	/// The permission causing it to be disallowed.
		130	pub permission: P,
		131	}
114	}	132	}
115		133
116	/// Allow, deny or forbid using a resource or performing an action.	134	/// Allow, deny or forbid using a resource or performing an action.
@@ -125,6 +143,36 @@ pub enum Permission { · 8 unmodified lines
125	Allow,	143	Allow,
126	}	144	}
127		145
		146	impl Permission {
		147	/// Check this permissions and produce a reply to indicate if the `resource` can be used and in which way.
		148	///
		149	/// Only if this permission is set to `Allow` will the resource be usable.
		150	#[cfg(feature = "thiserror")]
		151	pub fn check<R: Debug>(&self, resource: R) -> Result<Option<R>, permission::Error<R, Self>> {
		152	match self {
		153	Permission::Allow => Ok(Some(resource)),
		154	Permission::Deny => Ok(None),
		155	Permission::Forbid => Err(permission::Error {
		156	resource,
		157	permission: *self,
		158	}),
		159	}
		160	}
		161	}
		162
		163	impl Display for Permission {
		164	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
		165	Display::fmt(
		166	match self {
		167	Permission::Allow => "allowed",
		168	Permission::Deny => "denied",
		169	Permission::Forbid => "forbidden",
		170	},
		171	f,
		172	)
		173	}
		174	}
		175
128	bitflags::bitflags! {	176	bitflags::bitflags! {
129	/// Whether something can be read or written.	177	/// Whether something can be read or written.
130	#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]	178	#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
@@ -136,14 +184,27 @@ bitflags::bitflags! { · 5 unmodified lines
136	}	184	}
137	}	185	}
138		186
		187	impl Display for ReadWrite {
		188	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
		189	Debug::fmt(self, f)
		190	}
		191	}
		192
139	/// A container to define tagged access permissions, rendering the permission read-only.	193	/// A container to define tagged access permissions, rendering the permission read-only.
140	pub struct Access<T: permission::Tag, P> {	194	#[derive(Debug, Clone)]
		195	pub struct Access<T: permission::Tag, P: Debug + Display + Clone> {
141	/// The access permission itself.	196	/// The access permission itself.
142	permission: P,	197	permission: P,
143	_data: PhantomData<T>,	198	_data: PhantomData<T>,
144	}	199	}
145		200
146	impl<T: permission::Tag, P> Deref for Access<T, P> {	201	impl<T: permission::Tag, P: Debug + Display + Clone> Display for Access<T, P> {
		202	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
		203	Display::fmt(&self.permission, f)
		204	}
		205	}
		206
		207	impl<T: permission::Tag, P: Debug + Display + Clone> Deref for Access<T, P> {
147	type Target = P;	208	type Target = P;
148		209
149	fn deref(&self) -> &Self::Target {	210	fn deref(&self) -> &Self::Target {

git-url/Cargo.toml+1−0

@@ -20,6 +20,7 @@ serde1 = ["serde", "bstr/serde1"] · 19 unmodified lines
20	[dependencies]	20	[dependencies]
21	serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"]}	21	serde = { version = "1.0.114", optional = true, default-features = false, features = ["std", "derive"]}
22	git-features = { version = "^0.20.0", path = "../git-features" }	22	git-features = { version = "^0.20.0", path = "../git-features" }
		23	git-path = { version = "^0.1.0", path = "../git-path" }
23	quick-error = "2.0.0"	24	quick-error = "2.0.0"
24	url = "2.1.1"	25	url = "2.1.1"
25	bstr = { version = "0.2.13", default-features = false, features = ["std"] }	26	bstr = { version = "0.2.13", default-features = false, features = ["std"] }

git-url/src/expand_path.rs+1−1

@@ -106,7 +106,7 @@ pub fn with( · 105 unmodified lines
106	fn make_relative(path: &Path) -> PathBuf {	106	fn make_relative(path: &Path) -> PathBuf {
107	path.components().skip(1).collect()	107	path.components().skip(1).collect()
108	}	108	}
109	let path = git_features::path::from_byte_slice(path).map_err(\|_\| Error::IllformedUtf8 { path: path.to_owned() })?;	109	let path = git_path::try_from_byte_slice(path).map_err(\|_\| Error::IllformedUtf8 { path: path.to_owned() })?;
110	Ok(match user {	110	Ok(match user {
111	Some(user) => home_for_user(user)	111	Some(user) => home_for_user(user)
112	.ok_or_else(\|\| Error::MissingHome(user.to_owned().into()))?	112	.ok_or_else(\|\| Error::MissingHome(user.to_owned().into()))?

git-worktree/Cargo.toml+3−0

 git-index = { version = "^0.2.0", path = "../git-index" }
 git-hash = { version = "^0.9.3", path = "../git-hash" }
 git-object = { version = "^0.18.0", path = "../git-object" }
+git-glob = { version = "^0.2.0", path = "../git-glob" }
+git-path = { version = "^0.1.0", path = "../git-path" }
+git-attributes = { version = "^0.1.0", path = "../git-attributes" }
 git-features = { version = "^0.20.0", path = "../git-features" }
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}

git-worktree/src/fs/cache.rs+0−185

@@ -1,185 +0,0 @@
1	use super::Cache;
2	use crate::fs::Stack;
3	use crate::{fs, os};
4	use std::path::{Path, PathBuf};
5
6	#[derive(Clone)]
7	pub enum Mode {
8	/// Useful for checkout where directories need creation, but we need to access attributes as well.
9	CreateDirectoryAndProvideAttributes {
10	/// If there is a symlink or a file in our path, try to unlink it before creating the directory.
11	unlink_on_collision: bool,
12
13	/// just for testing
14	#[cfg(debug_assertions)]
15	test_mkdir_calls: usize,
16	/// An additional per-user attributes file, similar to `$GIT_DIR/info/attributes`
17	attributes_file: Option<PathBuf>,
18	},
19	/// Used when adding files, requiring access to both attributes and ignore information.
20	ProvideAttributesAndIgnore {
21	/// An additional per-user excludes file, similar to `$GIT_DIR/info/exclude`. It's an error if it is set but can't be read/opened.
22	excludes_file: Option<PathBuf>,
23	/// An additional per-user attributes file, similar to `$GIT_DIR/info/attributes`
24	attributes_file: Option<PathBuf>,
25	},
26	}
27
28	impl Mode {
29	/// Configure a mode to be suitable for checking out files.
30	pub fn checkout(unlink_on_collision: bool, attributes_file: Option<PathBuf>) -> Self {
31	Mode::CreateDirectoryAndProvideAttributes {
32	unlink_on_collision,
33	#[cfg(debug_assertions)]
34	test_mkdir_calls: 0,
35	attributes_file,
36	}
37	}
38
39	/// Configure a mode for adding files.
40	pub fn add(excludes_file: Option<PathBuf>, attributes_file: Option<PathBuf>) -> Self {
41	Mode::ProvideAttributesAndIgnore {
42	excludes_file,
43	attributes_file,
44	}
45	}
46	}
47
48	#[cfg(debug_assertions)]
49	impl Cache {
50	pub fn num_mkdir_calls(&self) -> usize {
51	match self.mode {
52	Mode::CreateDirectoryAndProvideAttributes { test_mkdir_calls, .. } => test_mkdir_calls,
53	_ => 0,
54	}
55	}
56
57	pub fn reset_mkdir_calls(&mut self) {
58	if let Mode::CreateDirectoryAndProvideAttributes { test_mkdir_calls, .. } = &mut self.mode {
59	*test_mkdir_calls = 0;
60	}
61	}
62
63	pub fn unlink_on_collision(&mut self, value: bool) {
64	if let Mode::CreateDirectoryAndProvideAttributes {
65	unlink_on_collision, ..
66	} = &mut self.mode
67	{
68	*unlink_on_collision = value;
69	}
70	}
71	}
72
73	pub struct Platform<'a> {
74	parent: &'a Cache,
75	}
76
77	impl<'a> Platform<'a> {
78	/// The full path to `relative` will be returned for use on the file system.
79	pub fn leading_dir(&self) -> &'a Path {
80	self.parent.stack.current()
81	}
82	}
83
84	impl<'a> std::fmt::Debug for Platform<'a> {
85	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
86	std::fmt::Debug::fmt(&self.leading_dir(), f)
87	}
88	}
89
90	impl Cache {
91	fn assure_init(&mut self) -> std::io::Result<()> {
92	Ok(())
93	}
94	}
95
96	impl Cache {
97	/// Create a new instance with `worktree_root` being the base for all future paths we handle, assuming it to be valid which includes
98	/// symbolic links to be included in it as well.
99	pub fn new(worktree_root: impl Into<PathBuf>, mode: Mode) -> Self {
100	let root = worktree_root.into();
101	Cache {
102	stack: fs::Stack::new(root),
103	mode,
104	}
105	}
106
107	/// Append the `relative` path to the root directory the cache contains and efficiently create leading directories
108	/// unless `mode` indicates `relative` points to a directory itself in which case the entire resulting path is created as directory.
109	///
110	/// Provide access to cached information for that `relative` entry via the platform returned.
111	pub fn at_entry(
112	&mut self,
113	relative: impl AsRef<Path>,
114	mode: git_index::entry::Mode,
115	) -> std::io::Result<Platform<'_>> {
116	self.assure_init()?;
117	let op_mode = &mut self.mode;
118	self.stack.make_relative_path_current(
119	relative,
120	\|components, stack: &fs::Stack\| {
121	match op_mode {
122	Mode::CreateDirectoryAndProvideAttributes {
123	#[cfg(debug_assertions)]
124	test_mkdir_calls,
125	unlink_on_collision,
126	attributes_file: _,
127	} => {
128	#[cfg(debug_assertions)]
129	{
130	create_leading_directory(components, stack, mode, test_mkdir_calls, *unlink_on_collision)?
131	}
132	#[cfg(not(debug_assertions))]
133	{
134	create_leading_directory(components, stack, mode, *unlink_on_collision)?
135	}
136	}
137	Mode::ProvideAttributesAndIgnore { .. } => todo!(),
138	}
139	Ok(())
140	},
141	\|_\| {},
142	)?;
143	Ok(Platform { parent: self })
144	}
145	}
146
147	fn create_leading_directory(
148	components: &mut std::iter::Peekable<std::path::Components<'_>>,
149	stack: &Stack,
150	mode: git_index::entry::Mode,
151	#[cfg(debug_assertions)] mkdir_calls: &mut usize,
152	unlink_on_collision: bool,
153	) -> std::io::Result<()> {
154	let target_is_dir = mode == git_index::entry::Mode::COMMIT \|\| mode == git_index::entry::Mode::DIR;
155	if !(components.peek().is_some() \|\| target_is_dir) {
156	return Ok(());
157	}
158	#[cfg(debug_assertions)]
159	{
160	*mkdir_calls += 1;
161	}
162	match std::fs::create_dir(stack.current()) {
163	Ok(()) => Ok(()),
164	Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => {
165	let meta = stack.current().symlink_metadata()?;
166	if meta.is_dir() {
167	Ok(())
168	} else if unlink_on_collision {
169	if meta.file_type().is_symlink() {
170	os::remove_symlink(stack.current())?;
171	} else {
172	std::fs::remove_file(stack.current())?;
173	}
174	#[cfg(debug_assertions)]
175	{
176	*mkdir_calls += 1;
177	}
178	std::fs::create_dir(stack.current())
179	} else {
180	Err(err)
181	}
182	}
183	Err(err) => Err(err),
184	}
185	}

git-worktree/src/fs/cache/mod.rs+139−0

@@ -0,0 +1,139 @@
	1	use super::Cache;
	2	use crate::fs;
	3	use crate::fs::PathOidMapping;
	4	use bstr::{BStr, ByteSlice};
	5	use git_hash::oid;
	6	use std::path::{Path, PathBuf};
	7
	8	#[derive(Clone)]
	9	pub enum State {
	10	/// Useful for checkout where directories need creation, but we need to access attributes as well.
	11	CreateDirectoryAndAttributesStack {
	12	/// If there is a symlink or a file in our path, try to unlink it before creating the directory.
	13	unlink_on_collision: bool,
	14
	15	/// just for testing
	16	#[cfg(debug_assertions)]
	17	test_mkdir_calls: usize,
	18	/// State to handle attribute information
	19	attributes: state::Attributes,
	20	},
	21	/// Used when adding files, requiring access to both attributes and ignore information, for example during add operations.
	22	AttributesAndIgnoreStack {
	23	/// State to handle attribute information
	24	attributes: state::Attributes,
	25	/// State to handle exclusion information
	26	ignore: state::Ignore,
	27	},
	28	/// Used when providing worktree status information.
	29	IgnoreStack(state::Ignore),
	30	}
	31
	32	#[cfg(debug_assertions)]
	33	impl<'paths> Cache<'paths> {
	34	pub fn set_case(&mut self, case: git_glob::pattern::Case) {
	35	self.case = case;
	36	}
	37	pub fn num_mkdir_calls(&self) -> usize {
	38	match self.state {
	39	State::CreateDirectoryAndAttributesStack { test_mkdir_calls, .. } => test_mkdir_calls,
	40	_ => 0,
	41	}
	42	}
	43
	44	pub fn reset_mkdir_calls(&mut self) {
	45	if let State::CreateDirectoryAndAttributesStack { test_mkdir_calls, .. } = &mut self.state {
	46	*test_mkdir_calls = 0;
	47	}
	48	}
	49
	50	pub fn unlink_on_collision(&mut self, value: bool) {
	51	if let State::CreateDirectoryAndAttributesStack {
	52	unlink_on_collision, ..
	53	} = &mut self.state
	54	{
	55	*unlink_on_collision = value;
	56	}
	57	}
	58	}
	59
	60	#[must_use]
	61	pub struct Platform<'a, 'paths> {
	62	parent: &'a Cache<'paths>,
	63	is_dir: Option<bool>,
	64	}
	65
	66	impl<'paths> Cache<'paths> {
	67	/// Create a new instance with `worktree_root` being the base for all future paths we handle, assuming it to be valid which includes
	68	/// symbolic links to be included in it as well.
	69	/// The `case` configures attribute and exclusion query case sensitivity.
	70	pub fn new(
	71	worktree_root: impl Into<PathBuf>,
	72	state: State,
	73	case: git_glob::pattern::Case,
	74	buf: Vec<u8>,
	75	attribute_files_in_index: Vec<PathOidMapping<'paths>>,
	76	) -> Self {
	77	let root = worktree_root.into();
	78	Cache {
	79	stack: fs::Stack::new(root),
	80	state,
	81	case,
	82	buf,
	83	attribute_files_in_index,
	84	}
	85	}
	86
	87	/// Append the `relative` path to the root directory the cache contains and efficiently create leading directories
	88	/// unless `is_dir` is known (`Some(…)`) then `relative` points to a directory itself in which case the entire resulting
	89	/// path is created as directory. If it's not known it is assumed to be a file.
	90	///
	91	/// Provide access to cached information for that `relative` entry via the platform returned.
	92	pub fn at_path<Find, E>(
	93	&mut self,
	94	relative: impl AsRef<Path>,
	95	is_dir: Option<bool>,
	96	find: Find,
	97	) -> std::io::Result<Platform<'_, 'paths>>
	98	where
	99	Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E>,
	100	E: std::error::Error + Send + Sync + 'static,
	101	{
	102	let mut delegate = platform::StackDelegate {
	103	state: &mut self.state,
	104	buf: &mut self.buf,
	105	is_dir: is_dir.unwrap_or(false),
	106	attribute_files_in_index: &self.attribute_files_in_index,
	107	find,
	108	};
	109	self.stack.make_relative_path_current(relative, &mut delegate)?;
	110	Ok(Platform { parent: self, is_dir })
	111	}
	112
	113	/// Panics on illformed UTF8 in `relative`
	114	// TODO: more docs
	115	pub fn at_entry<'r, Find, E>(
	116	&mut self,
	117	relative: impl Into<&'r BStr>,
	118	is_dir: Option<bool>,
	119	find: Find,
	120	) -> std::io::Result<Platform<'_, 'paths>>
	121	where
	122	Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E>,
	123	E: std::error::Error + Send + Sync + 'static,
	124	{
	125	let relative = relative.into();
	126	let relative_path = git_path::from_bstr(relative);
	127
	128	self.at_path(
	129	relative_path,
	130	is_dir.or_else(\|\| relative.ends_with_str("/").then(\|\| true)),
	131	// is_dir,
	132	find,
	133	)
	134	}
	135	}
	136
	137	mod platform;
	138	///
	139	pub mod state;

git-worktree/src/fs/cache/platform.rs+165−0

@@ -0,0 +1,165 @@
	1	use crate::fs;
	2	use crate::fs::cache::{Platform, State};
	3	use crate::fs::PathOidMapping;
	4	use bstr::ByteSlice;
	5	use git_hash::oid;
	6	use std::path::Path;
	7
	8	impl<'a, 'paths> Platform<'a, 'paths> {
	9	/// The full path to `relative` will be returned for use on the file system.
	10	pub fn path(&self) -> &'a Path {
	11	self.parent.stack.current()
	12	}
	13
	14	/// See if the currently set entry is excluded as per exclude and git-ignore files.
	15	///
	16	/// # Panics
	17	///
	18	/// If the cache was configured without exclude patterns.
	19	pub fn is_excluded(&self) -> bool {
	20	self.matching_exclude_pattern()
	21	.map_or(false, \|m\| m.pattern.is_negative())
	22	}
	23
	24	/// Check all exclude patterns to see if the currently set path matches any of them.
	25	///
	26	/// Note that this pattern might be negated, and means this path in included.
	27	///
	28	/// # Panics
	29	///
	30	/// If the cache was configured without exclude patterns.
	31	pub fn matching_exclude_pattern(&self) -> Option<git_attributes::Match<'_, ()>> {
	32	let ignore = self.parent.state.ignore_or_panic();
	33	let relative_path =
	34	git_path::to_unix_separators_on_windows(git_path::into_bstr(self.parent.stack.current_relative.as_path()));
	35	ignore.matching_exclude_pattern(relative_path.as_bstr(), self.is_dir, self.parent.case)
	36	}
	37	}
	38
	39	impl<'a, 'paths> std::fmt::Debug for Platform<'a, 'paths> {
	40	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
	41	std::fmt::Debug::fmt(&self.path(), f)
	42	}
	43	}
	44
	45	pub struct StackDelegate<'a, 'paths, Find> {
	46	pub state: &'a mut State,
	47	pub buf: &'a mut Vec<u8>,
	48	pub is_dir: bool,
	49	pub attribute_files_in_index: &'a Vec<PathOidMapping<'paths>>,
	50	pub find: Find,
	51	}
	52
	53	impl<'a, 'paths, Find, E> fs::stack::Delegate for StackDelegate<'a, 'paths, Find>
	54	where
	55	Find: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Result<git_object::BlobRef<'b>, E>,
	56	E: std::error::Error + Send + Sync + 'static,
	57	{
	58	fn push_directory(&mut self, stack: &fs::Stack) -> std::io::Result<()> {
	59	match &mut self.state {
	60	State::CreateDirectoryAndAttributesStack { attributes: _, .. } => {
	61	// TODO: attributes
	62	}
	63	State::AttributesAndIgnoreStack { ignore, attributes: _ } => {
	64	// TODO: attributes
	65	ignore.push_directory(
	66	&stack.root,
	67	&stack.current,
	68	self.buf,
	69	self.attribute_files_in_index,
	70	&mut self.find,
	71	)?
	72	}
	73	State::IgnoreStack(ignore) => ignore.push_directory(
	74	&stack.root,
	75	&stack.current,
	76	self.buf,
	77	self.attribute_files_in_index,
	78	&mut self.find,
	79	)?,
	80	}
	81	Ok(())
	82	}
	83
	84	fn push(&mut self, is_last_component: bool, stack: &fs::Stack) -> std::io::Result<()> {
	85	match &mut self.state {
	86	State::CreateDirectoryAndAttributesStack {
	87	#[cfg(debug_assertions)]
	88	test_mkdir_calls,
	89	unlink_on_collision,
	90	attributes: _,
	91	} => {
	92	#[cfg(debug_assertions)]
	93	{
	94	create_leading_directory(
	95	is_last_component,
	96	stack,
	97	self.is_dir,
	98	test_mkdir_calls,
	99	*unlink_on_collision,
	100	)?
	101	}
	102	#[cfg(not(debug_assertions))]
	103	{
	104	create_leading_directory(is_last_component, stack, self.is_dir, *unlink_on_collision)?
	105	}
	106	}
	107	State::AttributesAndIgnoreStack { .. } \| State::IgnoreStack(_) => {}
	108	}
	109	Ok(())
	110	}
	111
	112	fn pop_directory(&mut self) {
	113	match &mut self.state {
	114	State::CreateDirectoryAndAttributesStack { attributes: _, .. } => {
	115	// TODO: attributes
	116	}
	117	State::AttributesAndIgnoreStack { attributes: _, ignore } => {
	118	// TODO: attributes
	119	ignore.pop_directory();
	120	}
	121	State::IgnoreStack(ignore) => {
	122	ignore.pop_directory();
	123	}
	124	}
	125	}
	126	}
	127
	128	fn create_leading_directory(
	129	is_last_component: bool,
	130	stack: &fs::Stack,
	131	is_dir: bool,
	132	#[cfg(debug_assertions)] mkdir_calls: &mut usize,
	133	unlink_on_collision: bool,
	134	) -> std::io::Result<()> {
	135	if is_last_component && !is_dir {
	136	return Ok(());
	137	}
	138	#[cfg(debug_assertions)]
	139	{
	140	*mkdir_calls += 1;
	141	}
	142	match std::fs::create_dir(stack.current()) {
	143	Ok(()) => Ok(()),
	144	Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => {
	145	let meta = stack.current().symlink_metadata()?;
	146	if meta.is_dir() {
	147	Ok(())
	148	} else if unlink_on_collision {
	149	if meta.file_type().is_symlink() {
	150	crate::os::remove_symlink(stack.current())?;
	151	} else {
	152	std::fs::remove_file(stack.current())?;
	153	}
	154	#[cfg(debug_assertions)]
	155	{
	156	*mkdir_calls += 1;
	157	}
	158	std::fs::create_dir(stack.current())
	159	} else {
	160	Err(err)
	161	}
	162	}
	163	Err(err) => Err(err),
	164	}
	165	}

git-worktree/src/fs/cache/state.rs+287−0

@@ -0,0 +1,287 @@
	1	use crate::fs::cache::State;
	2	use crate::fs::PathOidMapping;
	3	use bstr::{BStr, BString, ByteSlice};
	4	use git_glob::pattern::Case;
	5	use git_hash::oid;
	6	use std::path::Path;
	7
	8	type AttributeMatchGroup = git_attributes::MatchGroup<git_attributes::Attributes>;
	9	type IgnoreMatchGroup = git_attributes::MatchGroup<git_attributes::Ignore>;
	10
	11	/// State related to attributes associated with files in the repository.
	12	#[derive(Default, Clone)]
	13	#[allow(unused)]
	14	pub struct Attributes {
	15	/// Attribute patterns that match the currently set directory (in the stack).
	16	pub stack: AttributeMatchGroup,
	17	/// Attribute patterns which aren't tied to the repository root, hence are global. They are consulted last.
	18	pub globals: AttributeMatchGroup,
	19	}
	20
	21	/// State related to the exclusion of files.
	22	#[derive(Default, Clone)]
	23	#[allow(unused)]
	24	pub struct Ignore {
	25	/// Ignore patterns passed as overrides to everything else, typically passed on the command-line and the first patterns to
	26	/// be consulted.
	27	overrides: IgnoreMatchGroup,
	28	/// Ignore patterns that match the currently set director (in the stack), which is pushed and popped as needed.
	29	stack: IgnoreMatchGroup,
	30	/// Ignore patterns which aren't tied to the repository root, hence are global. They are consulted last.
	31	globals: IgnoreMatchGroup,
	32	/// A matching stack of pattern indices which is empty if we have just been initialized to indicate that the
	33	/// currently set directory had a pattern matched. Note that this one could be negated.
	34	/// (index into match groups, index into list of pattern lists, index into pattern list)
	35	matched_directory_patterns_stack: Vec<Option<(usize, usize, usize)>>,
	36	/// The name of the file to look for in directories.
	37	exclude_file_name_for_directories: BString,
	38	/// The case to use when matching directories as they are pushed onto the stack. We run them against the exclude engine
	39	/// to know if an entire path can be ignored as a parent directory is ignored.
	40	case: Case,
	41	}
	42
	43	impl Ignore {
	44	/// The `exclude_file_name_for_directories` is an optional override for the filename to use when checking per-directory
	45	/// ignore files within the repository, defaults to`.gitignore`.
	46	// TODO: more docs
	47	pub fn new(
	48	overrides: IgnoreMatchGroup,
	49	globals: IgnoreMatchGroup,
	50	exclude_file_name_for_directories: Option<&BStr>,
	51	case: Case,
	52	) -> Self {
	53	Ignore {
	54	case,
	55	overrides,
	56	globals,
	57	stack: Default::default(),
	58	matched_directory_patterns_stack: Vec::with_capacity(6),
	59	exclude_file_name_for_directories: exclude_file_name_for_directories
	60	.map(ToOwned::to_owned)
	61	.unwrap_or_else(\|\| ".gitignore".into()),
	62	}
	63	}
	64	}
	65
	66	impl Ignore {
	67	pub(crate) fn pop_directory(&mut self) {
	68	self.matched_directory_patterns_stack.pop().expect("something to pop");
	69	self.stack.patterns.pop().expect("something to pop");
	70	}
	71	/// The match groups from lowest priority to highest.
	72	pub(crate) fn match_groups(&self) -> [&IgnoreMatchGroup; 3] {
	73	[&self.globals, &self.stack, &self.overrides]
	74	}
	75
	76	pub(crate) fn matching_exclude_pattern(
	77	&self,
	78	relative_path: &BStr,
	79	is_dir: Option<bool>,
	80	case: Case,
	81	) -> Option<git_attributes::Match<'_, ()>> {
	82	let groups = self.match_groups();
	83	if let Some((source, mapping)) = self
	84	.matched_directory_patterns_stack
	85	.iter()
	86	.rev()
	87	.filter_map(\|v\| *v)
	88	.map(\|(gidx, plidx, pidx)\| {
	89	let list = &groups[gidx].patterns[plidx];
	90	(list.source.as_deref(), &list.patterns[pidx])
	91	})
	92	.next()
	93	{
	94	if !mapping.pattern.is_negative() {
	95	return git_attributes::Match {
	96	pattern: &mapping.pattern,
	97	value: &mapping.value,
	98	sequence_number: mapping.sequence_number,
	99	source,
	100	}
	101	.into();
	102	}
	103	}
	104	groups
	105	.iter()
	106	.rev()
	107	.find_map(\|group\| group.pattern_matching_relative_path(relative_path.as_ref(), is_dir, case))
	108	}
	109
	110	/// Like `matching_exclude_pattern()` but without checking if the current directory is excluded.
	111	/// It returns a triple-index into our data structure from which a match can be reconstructed.
	112	pub(crate) fn matching_exclude_pattern_no_dir(
	113	&self,
	114	relative_path: &BStr,
	115	is_dir: Option<bool>,
	116	case: Case,
	117	) -> Option<(usize, usize, usize)> {
	118	let groups = self.match_groups();
	119	groups.iter().enumerate().rev().find_map(\|(gidx, group)\| {
	120	let basename_pos = relative_path.rfind(b"/").map(\|p\| p + 1);
	121	group
	122	.patterns
	123	.iter()
	124	.enumerate()
	125	.rev()
	126	.find_map(\|(plidx, pl)\| {
	127	pl.pattern_idx_matching_relative_path(relative_path, basename_pos, is_dir, case)
	128	.map(\|idx\| (plidx, idx))
	129	})
	130	.map(\|(plidx, pidx)\| (gidx, plidx, pidx))
	131	})
	132	}
	133
	134	pub(crate) fn push_directory<Find, E>(
	135	&mut self,
	136	root: &Path,
	137	dir: &Path,
	138	buf: &mut Vec<u8>,
	139	attribute_files_in_index: &[PathOidMapping<'_>],
	140	mut find: Find,
	141	) -> std::io::Result<()>
	142	where
	143	Find: for<'b> FnMut(&oid, &'b mut Vec<u8>) -> Result<git_object::BlobRef<'b>, E>,
	144	E: std::error::Error + Send + Sync + 'static,
	145	{
	146	let rela_dir = dir.strip_prefix(root).expect("dir in root");
	147	self.matched_directory_patterns_stack
	148	.push(self.matching_exclude_pattern_no_dir(git_path::into_bstr(rela_dir).as_ref(), Some(true), self.case));
	149
	150	let ignore_path_relative = rela_dir.join(".gitignore");
	151	let ignore_path_relative = git_path::to_unix_separators_on_windows(git_path::into_bstr(ignore_path_relative));
	152	let ignore_file_in_index =
	153	attribute_files_in_index.binary_search_by(\|t\| t.0.cmp(ignore_path_relative.as_ref()));
	154	let follow_symlinks = ignore_file_in_index.is_err();
	155	if !self
	156	.stack
	157	.add_patterns_file(dir.join(".gitignore"), follow_symlinks, Some(root), buf)?
	158	{
	159	match ignore_file_in_index {
	160	Ok(idx) => {
	161	let ignore_blob = find(&attribute_files_in_index[idx].1, buf)
	162	.map_err(\|err\| std::io::Error::new(std::io::ErrorKind::Other, err))?;
	163	let ignore_path = git_path::from_bstring(ignore_path_relative.into_owned());
	164	self.stack
	165	.add_patterns_buffer(ignore_blob.data, ignore_path, Some(root));
	166	}
	167	Err(_) => {
	168	// Need one stack level per component so push and pop matches.
	169	self.stack.patterns.push(Default::default())
	170	}
	171	}
	172	}
	173	Ok(())
	174	}
	175	}
	176
	177	impl Attributes {
	178	pub fn new(globals: AttributeMatchGroup) -> Self {
	179	Attributes {
	180	globals,
	181	stack: Default::default(),
	182	}
	183	}
	184	}
	185
	186	impl From<AttributeMatchGroup> for Attributes {
	187	fn from(group: AttributeMatchGroup) -> Self {
	188	Attributes::new(group)
	189	}
	190	}
	191
	192	impl State {
	193	/// Configure a state to be suitable for checking out files.
	194	pub fn for_checkout(unlink_on_collision: bool, attributes: Attributes) -> Self {
	195	State::CreateDirectoryAndAttributesStack {
	196	unlink_on_collision,
	197	#[cfg(debug_assertions)]
	198	test_mkdir_calls: 0,
	199	attributes,
	200	}
	201	}
	202
	203	/// Configure a state for adding files.
	204	pub fn for_add(attributes: Attributes, ignore: Ignore) -> Self {
	205	State::AttributesAndIgnoreStack { attributes, ignore }
	206	}
	207
	208	/// Configure a state for status retrieval.
	209	pub fn for_status(ignore: Ignore) -> Self {
	210	State::IgnoreStack(ignore)
	211	}
	212	}
	213
	214	impl State {
	215	/// Returns a vec of tuples of relative index paths along with the best usable OID for either ignore, attribute files or both.
	216	///
	217	/// - ignores entries which aren't blobs
	218	/// - ignores ignore entries which are not skip-worktree
	219	/// - within merges, picks 'our' stage both for ignore and attribute files.
	220	pub fn build_attribute_list<'paths>(
	221	&self,
	222	index: &git_index::State,
	223	paths: &'paths git_index::PathStorage,
	224	case: Case,
	225	) -> Vec<PathOidMapping<'paths>> {
	226	let a1_backing;
	227	let a2_backing;
	228	let names = match self {
	229	State::IgnoreStack(v) => {
	230	a1_backing = [(v.exclude_file_name_for_directories.as_bytes().as_bstr(), true)];
	231	a1_backing.as_ref()
	232	}
	233	State::AttributesAndIgnoreStack { ignore, .. } => {
	234	a2_backing = [
	235	(ignore.exclude_file_name_for_directories.as_bytes().as_bstr(), true),
	236	(".gitattributes".into(), false),
	237	];
	238	a2_backing.as_ref()
	239	}
	240	State::CreateDirectoryAndAttributesStack { .. } => {
	241	a1_backing = [(".gitattributes".into(), true)];
	242	a1_backing.as_ref()
	243	}
	244	};
	245
	246	index
	247	.entries()
	248	.iter()
	249	.filter_map(move \|entry\| {
	250	let path = entry.path_in(paths);
	251
	252	// Stage 0 means there is no merge going on, stage 2 means it's 'our' side of the merge, but then
	253	// there won't be a stage 0.
	254	if entry.mode == git_index::entry::Mode::FILE && (entry.stage() == 0 \|\| entry.stage() == 2) {
	255	let basename = path
	256	.rfind_byte(b'/')
	257	.map(\|pos\| path[pos + 1..].as_bstr())
	258	.unwrap_or(path);
	259	let is_ignore = names.iter().find_map(\|t\| {
	260	match case {
	261	Case::Sensitive => basename == t.0,
	262	Case::Fold => basename.eq_ignore_ascii_case(t.0),
	263	}
	264	.then(\|\| t.1)
	265	})?;
	266	// See https://github.com/git/git/blob/master/dir.c#L912:L912
	267	if is_ignore && !entry.flags.contains(git_index::entry::Flags::SKIP_WORKTREE) {
	268	return None;
	269	}
	270	Some((path, entry.id))
	271	} else {
	272	None
	273	}
	274	})
	275	.collect()
	276	}
	277
	278	pub(crate) fn ignore_or_panic(&self) -> &Ignore {
	279	match self {
	280	State::IgnoreStack(v) => v,
	281	State::AttributesAndIgnoreStack { ignore, .. } => ignore,
	282	State::CreateDirectoryAndAttributesStack { .. } => {
	283	unreachable!("BUG: must not try to check excludes without it being setup")
	284	}
	285	}
	286	}
	287	}

git-worktree/src/fs/mod.rs+15−3

+use bstr::BStr;
 use std::path::PathBuf;
 /// Common knowledge about the worktree that is needed across most interactions with the work tree
     pub symlink: bool,
 }
+#[derive(Clone)]
 pub struct Stack {
     /// The prefix/root for all paths we handle.
     root: PathBuf,
     current_relative: PathBuf,
     /// The amount of path components of 'current' beyond the roots components.
     valid_components: usize,
+    /// If set, we assume the `current` element is a directory to affect calls to `(push|pop)_directory()`.
+    current_is_directory: bool,
 }
 /// A cache for efficiently executing operations on directories and files which are encountered in sorted order.
 /// As directories are created, the cache will be adjusted to reflect the latest seen directory.
 ///
 /// The caching is only useful if consecutive calls to create a directory are using a sorted list of entries.
-#[allow(unused)]
+#[derive(Clone)]
-pub struct Cache {
+pub struct Cache<'paths> {
     stack: Stack,
     /// tells us what to do as we change paths.
-    mode: cache::Mode,
+    state: cache::State,
+    /// A buffer used when reading attribute or ignore files or their respective objects from the object database.
+    buf: Vec<u8>,
+    /// If case folding should happen when looking up attributes or exclusions.
+    case: git_glob::pattern::Case,
+    /// A lookup table for object ids to read from in some situations when looking up attributes or exclusions.
+    attribute_files_in_index: Vec<PathOidMapping<'paths>>,
 }
+pub(crate) type PathOidMapping<'paths> = (&'paths BStr, git_hash::ObjectId);
 ///
 pub mod cache;
 ///

git-worktree/src/fs/stack.rs+29−5

     }
 }
+pub trait Delegate {
+    fn push_directory(&mut self, stack: &Stack) -> std::io::Result<()>;
+    fn push(&mut self, is_last_component: bool, stack: &Stack) -> std::io::Result<()>;
+    fn pop_directory(&mut self);
+}
 impl Stack {
     /// Create a new instance with `root` being the base for all future paths we handle, assuming it to be valid which includes
     /// symbolic links to be included in it as well.
             current_relative: PathBuf::with_capacity(128),
             valid_components: 0,
             root,
+            current_is_directory: true,
         }
     }
     /// along with the stacks state for inspection to perform an operation that produces some data.
     ///
     /// The full path to `relative` will be returned along with the data returned by push_comp.
+    /// Note that this only works correctly for the delegate's `push_directory()` and `pop_directory()` methods if
+    /// `relative` paths are terminal, so point to their designated file or directory.
     pub fn make_relative_path_current(
         &mut self,
         relative: impl AsRef<Path>,
-        mut push_comp: impl FnMut(&mut std::iter::Peekable<std::path::Components<'_>>, &Self) -> std::io::Result<()>,
+        delegate: &mut impl Delegate,
-        mut pop_comp: impl FnMut(&Self),
     ) -> std::io::Result<()> {
         let relative = relative.as_ref();
         debug_assert!(
             relative.is_relative(),
             "only index paths are handled correctly here, must be relative"
         );
+        debug_assert!(!relative.to_string_lossy().is_empty(), "empty paths are not allowed");
+        if self.valid_components == 0 {
+            delegate.push_directory(self)?;
+        }
         let mut components = relative.components().peekable();
         let mut existing_components = self.current_relative.components();
         for _ in 0..self.valid_components - matching_components {
             self.current.pop();
             self.current_relative.pop();
-            pop_comp(&*self);
+            if self.current_is_directory {
+                delegate.pop_directory();
+            }
+            self.current_is_directory = true;
         }
         self.valid_components = matching_components;
+        if !self.current_is_directory && components.peek().is_some() {
+            delegate.push_directory(self)?;
+        }
         while let Some(comp) = components.next() {
+            let is_last_component = components.peek().is_none();
+            self.current_is_directory = !is_last_component;
             self.current.push(comp);
             self.current_relative.push(comp);
             self.valid_components += 1;
-            let res = push_comp(&mut components, &*self);
+            let res = delegate.push(is_last_component, self);
+            if self.current_is_directory {
+                delegate.push_directory(self)?;
+            }
             if let Err(err) = res {
                 self.current.pop();
                 self.current_relative.pop();
                 self.valid_components -= 1;
-                pop_comp(&*self);
                 return Err(err);
             }
         }

git-worktree/src/index/checkout.rs+4−4

@@ -1,5 +1,5 @@
1	use bstr::BString;	1	use bstr::BString;
2	use std::path::PathBuf;	2	use git_attributes::Attributes;
3		3
4	#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]	4	#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
5	pub struct Collision {	5	pub struct Collision {
@@ -57,8 +57,8 @@ pub struct Options { · 51 unmodified lines
57	///	57	///
58	/// Default true.	58	/// Default true.
59	pub check_stat: bool,	59	pub check_stat: bool,
60	/// The location of the per-user attributes file. It must exist if it is set, causing failure otherwise.	60	/// A group of attribute patterns that are applied globally, i.e. aren't rooted within the repository itself.
61	pub attributes_file: Option<PathBuf>,	61	pub attribute_globals: git_attributes::MatchGroup<Attributes>,
62	}	62	}
63		63
64	impl Default for Options {	64	impl Default for Options {
@@ -71,7 +71,7 @@ impl Default for Options { · 6 unmodified lines
71	trust_ctime: true,	71	trust_ctime: true,
72	check_stat: true,	72	check_stat: true,
73	overwrite_existing: false,	73	overwrite_existing: false,
74	attributes_file: None,	74	attribute_globals: Default::default(),
75	}	75	}
76	}	76	}
77	}	77	}

git-worktree/src/index/entry.rs+9−9

@@ -7,9 +7,9 @@ use io_close::Close; · 6 unmodified lines
7		7
8	use crate::{fs, index, os};	8	use crate::{fs, index, os};
9		9
10	pub struct Context<'a, Find> {	10	pub struct Context<'a, 'paths, Find> {
11	pub find: &'a mut Find,	11	pub find: &'a mut Find,
12	pub path_cache: &'a mut fs::Cache,	12	pub path_cache: &'a mut fs::Cache<'paths>,
13	pub buf: &'a mut Vec<u8>,	13	pub buf: &'a mut Vec<u8>,
14	}	14	}
15		15
@@ -17,7 +17,7 @@ pub struct Context<'a, Find> { · 1 unmodified line
17	pub fn checkout<Find, E>(	17	pub fn checkout<Find, E>(
18	entry: &mut Entry,	18	entry: &mut Entry,
19	entry_path: &BStr,	19	entry_path: &BStr,
20	Context { find, path_cache, buf }: Context<'_, Find>,	20	Context { find, path_cache, buf }: Context<'_, '_, Find>,
21	index::checkout::Options {	21	index::checkout::Options {
22	fs: crate::fs::Capabilities {	22	fs: crate::fs::Capabilities {
23	symlink,	23	symlink,
@@ -33,11 +33,11 @@ where · 9 unmodified lines
33	Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E>,	33	Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E>,
34	E: std::error::Error + Send + Sync + 'static,	34	E: std::error::Error + Send + Sync + 'static,
35	{	35	{
36	let dest_relative =	36	let dest_relative = git_path::try_from_bstr(entry_path).map_err(\|_\| index::checkout::Error::IllformedUtf8 {
37	git_features::path::from_byte_slice(entry_path).map_err(\|_\| index::checkout::Error::IllformedUtf8 {	37	path: entry_path.to_owned(),
38	path: entry_path.to_owned(),	38	})?;
39	})?;	39	let is_dir = Some(entry.mode == git_index::entry::Mode::COMMIT \|\| entry.mode == git_index::entry::Mode::DIR);
40	let dest = path_cache.at_entry(dest_relative, entry.mode)?.leading_dir();	40	let dest = path_cache.at_path(dest_relative, is_dir, &mut *find)?.path();
41		41
42	let object_size = match entry.mode {	42	let object_size = match entry.mode {
43	git_index::entry::Mode::FILE \| git_index::entry::Mode::FILE_EXECUTABLE => {	43	git_index::entry::Mode::FILE \| git_index::entry::Mode::FILE_EXECUTABLE => {
@@ -81,7 +81,7 @@ where · 37 unmodified lines
81	oid: entry.id,	81	oid: entry.id,
82	path: dest.to_path_buf(),	82	path: dest.to_path_buf(),
83	})?;	83	})?;
84	let symlink_destination = git_features::path::from_byte_slice(obj.data)	84	let symlink_destination = git_path::try_from_byte_slice(obj.data)
85	.map_err(\|_\| index::checkout::Error::IllformedUtf8 { path: obj.data.into() })?;	85	.map_err(\|_\| index::checkout::Error::IllformedUtf8 { path: obj.data.into() })?;
86		86
87	if symlink {	87	if symlink {

git-worktree/src/index/mod.rs+46−35

@@ -21,22 +21,36 @@ pub fn checkout<Find, E>( · 20 unmodified lines
21	should_interrupt: &AtomicBool,	21	should_interrupt: &AtomicBool,
22	options: checkout::Options,	22	options: checkout::Options,
23	) -> Result<checkout::Outcome, checkout::Error<E>>	23	) -> Result<checkout::Outcome, checkout::Error<E>>
		24	where
		25	Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E> + Send + Clone,
		26	E: std::error::Error + Send + Sync + 'static,
		27	{
		28	let paths = index.take_path_backing();
		29	let res = checkout_inner(index, &paths, dir, find, files, bytes, should_interrupt, options);
		30	index.return_path_backing(paths);
		31	res
		32	}
		33	#[allow(clippy::too_many_arguments)]
		34	fn checkout_inner<Find, E>(
		35	index: &mut git_index::State,
		36	paths: &git_index::PathStorage,
		37	dir: impl Into<std::path::PathBuf>,
		38	find: Find,
		39	files: &mut impl Progress,
		40	bytes: &mut impl Progress,
		41	should_interrupt: &AtomicBool,
		42	options: checkout::Options,
		43	) -> Result<checkout::Outcome, checkout::Error<E>>
24	where	44	where
25	Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E> + Send + Clone,	45	Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E> + Send + Clone,
26	E: std::error::Error + Send + Sync + 'static,	46	E: std::error::Error + Send + Sync + 'static,
27	{	47	{
28	let num_files = AtomicUsize::default();	48	let num_files = AtomicUsize::default();
29	let dir = dir.into();	49	let dir = dir.into();
30		50	let case = if options.fs.ignore_case {
31	let mut ctx = chunk::Context {	51	git_glob::pattern::Case::Fold
32	buf: Vec::new(),	52	} else {
33	path_cache: fs::Cache::new(	53	git_glob::pattern::Case::Sensitive
34	dir.clone(),
35	fs::cache::Mode::checkout(options.overwrite_existing, options.attributes_file.clone()),
36	),
37	find: find.clone(),
38	options: options.clone(),
39	num_files: &num_files,
40	};	54	};
41	let (chunk_size, thread_limit, num_threads) = git_features::parallel::optimize_chunk_size_and_thread_limit(	55	let (chunk_size, thread_limit, num_threads) = git_features::parallel::optimize_chunk_size_and_thread_limit(
42	100,	56	100,
@@ -45,15 +59,26 @@ where · 2 unmodified lines
45	None,	59	None,
46	);	60	);
47		61
48	let entries_with_paths = interrupt::Iter::new(index.entries_mut_with_paths(), should_interrupt);	62	let state = fs::cache::State::for_checkout(options.overwrite_existing, options.attribute_globals.clone().into());
		63	let attribute_files = state.build_attribute_list(index, paths, case);
		64	let mut ctx = chunk::Context {
		65	buf: Vec::new(),
		66	path_cache: fs::Cache::new(dir, state, case, Vec::with_capacity(512), attribute_files),
		67	find,
		68	options,
		69	num_files: &num_files,
		70	};
		71
49	let chunk::Outcome {	72	let chunk::Outcome {
50	mut collisions,	73	mut collisions,
51	mut errors,	74	mut errors,
52	mut bytes_written,	75	mut bytes_written,
53	delayed,	76	delayed,
54	} = if num_threads == 1 {	77	} = if num_threads == 1 {
		78	let entries_with_paths = interrupt::Iter::new(index.entries_mut_with_paths_in(paths), should_interrupt);
55	chunk::process(entries_with_paths, files, bytes, &mut ctx)?	79	chunk::process(entries_with_paths, files, bytes, &mut ctx)?
56	} else {	80	} else {
		81	let entries_with_paths = interrupt::Iter::new(index.entries_mut_with_paths_in(paths), should_interrupt);
57	in_parallel(	82	in_parallel(
58	git_features::iter::Chunks {	83	git_features::iter::Chunks {
59	inner: entries_with_paths,	84	inner: entries_with_paths,
@@ -61,23 +86,8 @@ where · 1 unmodified line
61	},	86	},
62	thread_limit,	87	thread_limit,
63	{	88	{
64	let num_files = &num_files;	89	let ctx = ctx.clone();
65	move \|_\| {	90	move \|_\| (progress::Discard, progress::Discard, ctx.clone())
66	(
67	progress::Discard,
68	progress::Discard,
69	chunk::Context {
70	find: find.clone(),
71	path_cache: fs::Cache::new(
72	dir.clone(),
73	fs::cache::Mode::checkout(options.overwrite_existing, options.attributes_file.clone()),
74	),
75	buf: Vec::new(),
76	options: options.clone(),
77	num_files,
78	},
79	)
80	}
81	},	91	},
82	\|chunk, (files, bytes, ctx)\| chunk::process(chunk.into_iter(), files, bytes, ctx),	92	\|chunk, (files, bytes, ctx)\| chunk::process(chunk.into_iter(), files, bytes, ctx),
83	chunk::Reduce {	93	chunk::Reduce {
@@ -103,7 +113,7 @@ where · 19 unmodified lines
103	}	113	}
104		114
105	Ok(checkout::Outcome {	115	Ok(checkout::Outcome {
106	files_updated: ctx.num_files.load(Ordering::Relaxed),	116	files_updated: num_files.load(Ordering::Relaxed),
107	collisions,	117	collisions,
108	errors,	118	errors,
109	bytes_written,	119	bytes_written,
@@ -186,9 +196,10 @@ mod chunk { · 76 unmodified lines
186	pub bytes_written: u64,	196	pub bytes_written: u64,
187	}	197	}
188		198
189	pub struct Context<'a, Find> {	199	#[derive(Clone)]
		200	pub struct Context<'a, 'paths, Find: Clone> {
190	pub find: Find,	201	pub find: Find,
191	pub path_cache: fs::Cache,	202	pub path_cache: fs::Cache<'paths>,
192	pub buf: Vec<u8>,	203	pub buf: Vec<u8>,
193	pub options: checkout::Options,	204	pub options: checkout::Options,
194	/// We keep these shared so that there is the chance for printing numbers that aren't looking like	205	/// We keep these shared so that there is the chance for printing numbers that aren't looking like
@@ -200,10 +211,10 @@ mod chunk { · 5 unmodified lines
200	entries_with_paths: impl Iterator<Item = (&'entry mut git_index::Entry, &'entry BStr)>,	211	entries_with_paths: impl Iterator<Item = (&'entry mut git_index::Entry, &'entry BStr)>,
201	files: &mut impl Progress,	212	files: &mut impl Progress,
202	bytes: &mut impl Progress,	213	bytes: &mut impl Progress,
203	ctx: &mut Context<'_, Find>,	214	ctx: &mut Context<'_, '_, Find>,
204	) -> Result<Outcome<'entry>, checkout::Error<E>>	215	) -> Result<Outcome<'entry>, checkout::Error<E>>
205	where	216	where
206	Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E>,	217	Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E> + Clone,
207	E: std::error::Error + Send + Sync + 'static,	218	E: std::error::Error + Send + Sync + 'static,
208	{	219	{
209	let mut delayed = Vec::new();	220	let mut delayed = Vec::new();
@@ -255,10 +266,10 @@ mod chunk { · 45 unmodified lines
255	buf,	266	buf,
256	options,	267	options,
257	num_files,	268	num_files,
258	}: &mut Context<'_, Find>,	269	}: &mut Context<'_, '_, Find>,
259	) -> Result<usize, checkout::Error<E>>	270	) -> Result<usize, checkout::Error<E>>
260	where	271	where
261	Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E>,	272	Find: for<'a> FnMut(&oid, &'a mut Vec<u8>) -> Result<git_object::BlobRef<'a>, E> + Clone,
262	E: std::error::Error + Send + Sync + 'static,	273	E: std::error::Error + Send + Sync + 'static,
263	{	274	{
264	let res = entry::checkout(	275	let res = entry::checkout(

git-worktree/tests/fixtures/generated-archives/make_ignore_and_attributes_setup.tar.xz+3−0

@@ -0,0 +1,3 @@
	1	version https://git-lfs.github.com/spec/v1
	2	oid sha256:ae297f2c067e2cc7b0c8eabfff721ff775a7d8266ffef979bde2458de2ab03c9
	3	size 10944

git-worktree/tests/fixtures/make_ignore_and_attributes_setup.sh+112−0

@@ -0,0 +1,112 @@
	1	#!/bin/bash
	2	set -eu -o pipefail
	3
	4	cat <<EOF >user.exclude
	5	# a custom exclude configured per user
	6	user-file-anywhere
	7	/user-file-from-top
	8
	9	user-dir-anywhere/
	10	/user-dir-from-top
	11
	12	user-subdir/file
	13	**/user-subdir-anywhere/file
	14	EOF
	15
	16	mkdir repo;
	17	(cd repo
	18	git init -q
	19	git config core.excludesFile ../user.exclude
	20
	21	cat <<EOF >.git/info/exclude
	22	# a sample .git/info/exclude
	23	file-anywhere
	24	/file-from-top
	25
	26	dir-anywhere/
	27	/dir-from-top
	28
	29	subdir/file
	30	**/subdir-anywhere/file
	31	EOF
	32
	33	cat <<EOF >.gitignore
	34	# a sample .gitignore
	35	top-level-local-file-anywhere
	36	EOF
	37
	38	mkdir dir-with-ignore
	39	cat <<EOF >dir-with-ignore/.gitignore
	40	# a sample .gitignore
	41	sub-level-local-file-anywhere
	42	sub-level-dir-anywhere/
	43	!/negated
	44	/negated-dir/
	45	!/negated-dir/
	46	EOF
	47
	48	git add .gitignore dir-with-ignore
	49	git commit --allow-empty -m "init"
	50
	51	# just add this git-ignore file, so it's a new file that doesn't exist on disk.
	52	mkdir other-dir-with-ignore
	53	skip_worktree_ignore=other-dir-with-ignore/.gitignore
	54	cat <<EOF >"$skip_worktree_ignore"
	55	# a sample .gitignore
	56	other-sub-level-local-file-anywhere
	57	other-sub-level-dir-anywhere/
	58	EOF
	59	git add $skip_worktree_ignore && git update-index --skip-worktree $skip_worktree_ignore && rm $skip_worktree_ignore
	60
	61	mkdir user-dir-anywhere user-dir-from-top dir-anywhere dir-from-top
	62	mkdir -p dir/user-dir-anywhere dir/dir-anywhere
	63
	64	git check-ignore -vn --stdin 2>&1 <<EOF >git-check-ignore.baseline \|\| :
	65	dir-with-ignore/sub-level-dir-anywhere/
	66	dir-with-ignore/foo/sub-level-dir-anywhere/
	67	dir-with-ignore/sub-level-dir-anywhere
	68	user-file-anywhere
	69	dir/user-file-anywhere
	70	user-file-from-top
	71	no-match/user-file-from-top
	72	user-dir-anywhere
	73	user-dir-from-top
	74	no-match/user-dir-from-top
	75	user-subdir/file
	76	subdir/user-subdir-anywhere/file
	77	user-dir-anywhere/hello
	78	dir/user-dir-anywhere/hello
	79	file-anywhere
	80	dir/file-anywhere
	81	file-from-top
	82	no-match/file-from-top
	83	dir-anywhere
	84	dir/dir-anywhere
	85	dir-from-top
	86	no-match/dir-from-top
	87	subdir/file
	88	subdir/subdir-anywhere/file
	89	top-level-local-file-anywhere
	90	dir/top-level-local-file-anywhere
	91	no-match/sub-level-local-file-anywhere
	92	dir-with-ignore/sub-level-local-file-anywhere
	93	dir-with-ignore/sub-dir/sub-level-local-file-anywhere
	94	other-dir-with-ignore/other-sub-level-local-file-anywhere
	95	other-dir-with-ignore/sub-level-local-file-anywhere
	96	other-dir-with-ignore/sub-dir/other-sub-level-local-file-anywhere
	97	other-dir-with-ignore/no-match/sub-level-local-file-anywhere
	98	non-existing/dir-anywhere
	99	dir-anywhere/hello
	100	dir/dir-anywhere/hello
	101	no-match/sub-level-dir-anywhere/hello
	102	no-match/other-sub-level-dir-anywhere/hello
	103	dir-with-ignore/sub-level-dir-anywhere/hello
	104	dir-with-ignore/sub-level-dir-anywhere/
	105	other-dir-with-ignore/sub-level-dir-anywhere/hello
	106	other-dir-with-ignore/other-sub-level-dir-anywhere/hello
	107	other-dir-with-ignore/other-sub-level-dir-anywhere/
	108	dir-with-ignore/negated
	109	dir-with-ignore/negated-dir/hello
	110	EOF
	111
	112	)

git-worktree/tests/worktree-multi-threaded.rs+2−0

@@ -1,2 +1,4 @@
		1	extern crate core;
		2
1	mod worktree;	3	mod worktree;
2	use worktree::*;	4	use worktree::*;

git-worktree/tests/worktree/fs/cache.rs+148−29

@@ -1,39 +1,49 @@
1	mod create_directory {	1	mod create_directory {
2	use std::path::Path;	2	use std::path::Path;
3		3
4	use git_index::entry::Mode;
5	use git_worktree::fs;	4	use git_worktree::fs;
6	use tempfile::{tempdir, TempDir};	5	use tempfile::{tempdir, TempDir};
7		6
		7	fn panic_on_find<'buf>(
		8	_oid: &git_hash::oid,
		9	_buf: &'buf mut Vec<u8>,
		10	) -> std::io::Result<git_object::BlobRef<'buf>> {
		11	unreachable!("find should nto be called")
		12	}
		13
8	#[test]	14	#[test]
9	fn root_is_assumed_to_exist_and_files_in_root_do_not_create_directory() {	15	fn root_is_assumed_to_exist_and_files_in_root_do_not_create_directory() -> crate::Result {
10	let dir = tempdir().unwrap();	16	let dir = tempdir()?;
11	let mut cache = fs::Cache::new(	17	let mut cache = fs::Cache::new(
12	dir.path().join("non-existing-root"),	18	dir.path().join("non-existing-root"),
13	fs::cache::Mode::checkout(false, None),	19	fs::cache::State::for_checkout(false, Default::default()),
		20	Default::default(),
		21	Vec::new(),
		22	Default::default(),
14	);	23	);
15	assert_eq!(cache.num_mkdir_calls(), 0);	24	assert_eq!(cache.num_mkdir_calls(), 0);
16		25
17	let path = cache.at_entry("hello", Mode::FILE).unwrap().leading_dir();	26	let path = cache.at_path("hello", Some(false), panic_on_find)?.path();
18	assert!(!path.parent().unwrap().exists(), "prefix itself is never created");	27	assert!(!path.parent().unwrap().exists(), "prefix itself is never created");
19	assert_eq!(cache.num_mkdir_calls(), 0);	28	assert_eq!(cache.num_mkdir_calls(), 0);
		29	Ok(())
20	}	30	}
21		31
22	#[test]	32	#[test]
23	fn directory_paths_are_created_in_full() {	33	fn directory_paths_are_created_in_full() {
24	let (mut cache, _tmp) = new_cache();	34	let (mut cache, _tmp) = new_cache();
25		35
26	for (name, mode) in &[	36	for (name, is_dir) in &[
27	("dir", Mode::DIR),	37	("dir", Some(true)),
28	("submodule", Mode::COMMIT),	38	("submodule", Some(true)),
29	("file", Mode::FILE),	39	("file", Some(false)),
30	("exe", Mode::FILE_EXECUTABLE),	40	("exe", Some(false)),
31	("link", Mode::SYMLINK),	41	("link", None),
32	] {	42	] {
33	let path = cache	43	let path = cache
34	.at_entry(Path::new("dir").join(name), *mode)	44	.at_path(Path::new("dir").join(name), *is_dir, panic_on_find)
35	.unwrap()	45	.unwrap()
36	.leading_dir();	46	.path();
37	assert!(path.parent().unwrap().is_dir(), "dir exists");	47	assert!(path.parent().unwrap().is_dir(), "dir exists");
38	}	48	}
39		49
@@ -41,29 +51,33 @@ mod create_directory { · 1 unmodified line
41	}	51	}
42		52
43	#[test]	53	#[test]
44	fn existing_directories_are_fine() {	54	fn existing_directories_are_fine() -> crate::Result {
45	let (mut cache, tmp) = new_cache();	55	let (mut cache, tmp) = new_cache();
46	std::fs::create_dir(tmp.path().join("dir")).unwrap();	56	std::fs::create_dir(tmp.path().join("dir"))?;
47		57
48	let path = cache.at_entry("dir/file", Mode::FILE).unwrap().leading_dir();	58	let path = cache.at_path("dir/file", Some(false), panic_on_find)?.path();
49	assert!(path.parent().unwrap().is_dir(), "directory is still present");	59	assert!(path.parent().unwrap().is_dir(), "directory is still present");
50	assert!(!path.exists(), "it won't create the file");	60	assert!(!path.exists(), "it won't create the file");
51	assert_eq!(cache.num_mkdir_calls(), 1);	61	assert_eq!(cache.num_mkdir_calls(), 1);
		62	Ok(())
52	}	63	}
53		64
54	#[test]	65	#[test]
55	fn symlinks_or_files_in_path_are_forbidden_or_unlinked_when_forced() {	66	fn symlinks_or_files_in_path_are_forbidden_or_unlinked_when_forced() -> crate::Result {
56	let (mut cache, tmp) = new_cache();	67	let (mut cache, tmp) = new_cache();
57	let forbidden = tmp.path().join("forbidden");	68	let forbidden = tmp.path().join("forbidden");
58	std::fs::create_dir(&forbidden).unwrap();	69	std::fs::create_dir(&forbidden)?;
59	symlink::symlink_dir(&forbidden, tmp.path().join("link-to-dir")).unwrap();	70	symlink::symlink_dir(&forbidden, tmp.path().join("link-to-dir"))?;
60	std::fs::write(tmp.path().join("file-in-dir"), &[]).unwrap();	71	std::fs::write(tmp.path().join("file-in-dir"), &[])?;
61		72
62	for dirname in &["file-in-dir", "link-to-dir"] {	73	for dirname in &["file-in-dir", "link-to-dir"] {
63	cache.unlink_on_collision(false);	74	cache.unlink_on_collision(false);
64	let relative_path = format!("{}/file", dirname);	75	let relative_path = format!("{}/file", dirname);
65	assert_eq!(	76	assert_eq!(
66	cache.at_entry(&relative_path, Mode::FILE).unwrap_err().kind(),	77	cache
		78	.at_path(&relative_path, Some(false), panic_on_find)
		79	.unwrap_err()
		80	.kind(),
67	std::io::ErrorKind::AlreadyExists	81	std::io::ErrorKind::AlreadyExists
68	);	82	);
69	}	83	}
@@ -76,7 +90,7 @@ mod create_directory { · 6 unmodified lines
76	for dirname in &["link-to-dir", "file-in-dir"] {	90	for dirname in &["link-to-dir", "file-in-dir"] {
77	cache.unlink_on_collision(true);	91	cache.unlink_on_collision(true);
78	let relative_path = format!("{}/file", dirname);	92	let relative_path = format!("{}/file", dirname);
79	let path = cache.at_entry(&relative_path, Mode::FILE).unwrap().leading_dir();	93	let path = cache.at_path(&relative_path, Some(false), panic_on_find)?.path();
80	assert!(path.parent().unwrap().is_dir(), "directory was forcefully created");	94	assert!(path.parent().unwrap().is_dir(), "directory was forcefully created");
81	assert!(!path.exists());	95	assert!(!path.exists());
82	}	96	}
@@ -85,26 +99,131 @@ mod create_directory { · 2 unmodified lines
85	4,	99	4,
86	"like before, but it unlinks what's there and tries again"	100	"like before, but it unlinks what's there and tries again"
87	);	101	);
		102	Ok(())
88	}	103	}
89		104
90	fn new_cache() -> (fs::Cache, TempDir) {	105	fn new_cache() -> (fs::Cache<'static>, TempDir) {
91	let dir = tempdir().unwrap();	106	let dir = tempdir().unwrap();
92	let cache = fs::Cache::new(dir.path(), fs::cache::Mode::checkout(false, None));	107	let cache = fs::Cache::new(
		108	dir.path(),
		109	fs::cache::State::for_checkout(false, Default::default()),
		110	Default::default(),
		111	Vec::new(),
		112	Default::default(),
		113	);
93	(cache, dir)	114	(cache, dir)
94	}	115	}
95	}	116	}
96		117
97	#[allow(unused)]	118	#[allow(unused)]
98	mod ignore_only {	119	mod ignore_and_attributes {
		120	use bstr::{BStr, ByteSlice};
99	use std::path::Path;	121	use std::path::Path;
100		122
		123	use git_glob::pattern::Case;
101	use git_index::entry::Mode;	124	use git_index::entry::Mode;
		125	use git_odb::pack::bundle::write::Options;
		126	use git_odb::FindExt;
		127	use git_testtools::hex_to_id;
102	use git_worktree::fs;	128	use git_worktree::fs;
103	use tempfile::{tempdir, TempDir};	129	use tempfile::{tempdir, TempDir};
104		130
105	fn new_cache() -> fs::Cache {	131	struct IgnoreExpectations<'a> {
106	let dir = git_testtools::scripted_fixture_repo_read_only("make_ignore_setup.sh").unwrap();	132	lines: bstr::Lines<'a>,
107	let cache = fs::Cache::new(dir, todo!()); // TODO: also test initialization	133	}
108	cache	134
		135	impl<'a> Iterator for IgnoreExpectations<'a> {
		136	type Item = (&'a BStr, Option<(&'a BStr, usize, &'a BStr)>);
		137
		138	fn next(&mut self) -> Option<Self::Item> {
		139	let line = self.lines.next()?;
		140	let (left, value) = line.split_at(line.find_byte(b'\t').unwrap());
		141	let value = value[1..].as_bstr();
		142
		143	let source_and_line = if left == b"::" {
		144	None
		145	} else {
		146	let mut tokens = left.split(\|b\| *b == b':');
		147	let source = tokens.next().unwrap().as_bstr();
		148	let line_number: usize = tokens.next().unwrap().to_str_lossy().parse().ok().unwrap();
		149	let pattern = tokens.next().unwrap().as_bstr();
		150	Some((source, line_number, pattern))
		151	};
		152	Some((value, source_and_line))
		153	}
		154	}
		155
		156	#[test]
		157	fn check_against_baseline() -> crate::Result {
		158	let dir = git_testtools::scripted_fixture_repo_read_only("make_ignore_and_attributes_setup.sh")?;
		159	let worktree_dir = dir.join("repo");
		160	let git_dir = worktree_dir.join(".git");
		161	let mut buf = Vec::new();
		162	let baseline = std::fs::read(git_dir.parent().unwrap().join("git-check-ignore.baseline"))?;
		163	let user_exclude_path = dir.join("user.exclude");
		164	assert!(user_exclude_path.is_file());
		165
		166	let mut index = git_index::File::at(git_dir.join("index"), Default::default())?;
		167	let odb = git_odb::at(git_dir.join("objects"))?;
		168	let case = git_glob::pattern::Case::Sensitive;
		169	let state = git_worktree::fs::cache::State::for_add(
		170	Default::default(), // TODO: attribute tests
		171	git_worktree::fs::cache::state::Ignore::new(
		172	git_attributes::MatchGroup::from_overrides(vec!["!force-include"]),
		173	git_attributes::MatchGroup::from_git_dir(&git_dir, Some(user_exclude_path), &mut buf)?,
		174	None,
		175	case,
		176	),
		177	);
		178	let paths_storage = index.take_path_backing();
		179	let attribute_files_in_index = state.build_attribute_list(&index.state, &paths_storage, case);
		180	assert_eq!(
		181	attribute_files_in_index,
		182	vec![(
		183	"other-dir-with-ignore/.gitignore".as_bytes().as_bstr(),
		184	hex_to_id("5c7e0ed672d3d31d83a3df61f13cc8f7b22d5bfd")
		185	)]
		186	);
		187	let mut cache = fs::Cache::new(&worktree_dir, state, case, buf, attribute_files_in_index);
		188
		189	for (relative_entry, source_and_line) in (IgnoreExpectations {
		190	lines: baseline.lines(),
		191	}) {
		192	let relative_path = git_path::from_byte_slice(relative_entry);
		193	let is_dir = worktree_dir.join(&relative_path).metadata().ok().map(\|m\| m.is_dir());
		194
		195	let platform = cache.at_entry(relative_entry, is_dir, \|oid, buf\| odb.find_blob(oid, buf))?;
		196
		197	let match_ = platform.matching_exclude_pattern();
		198	let is_excluded = platform.is_excluded();
		199	match (match_, source_and_line) {
		200	(None, None) => {
		201	assert!(!is_excluded);
		202	}
		203	(Some(m), Some((source_file, line, pattern))) => {
		204	assert_eq!(m.pattern.to_string(), pattern);
		205	assert_eq!(m.sequence_number, line);
		206	// Paths read from the index are relative to the repo, and they don't exist locally due tot skip-worktree
		207	if m.source.map_or(false, \|p\| p.exists()) {
		208	assert_eq!(
		209	m.source.map(\|p\| p.canonicalize().unwrap()),
		210	Some(worktree_dir.join(source_file.to_str_lossy().as_ref()).canonicalize()?)
		211	);
		212	}
		213	}
		214	(actual, expected) => {
		215	panic!(
		216	"actual {:?} didn't match {:?} at '{}'",
		217	actual, expected, relative_entry
		218	);
		219	}
		220	}
		221	}
		222
		223	cache.set_case(Case::Fold);
		224	let platform = cache.at_entry("User-file-ANYWHERE", Some(false), \|oid, buf\| odb.find_blob(oid, buf))?;
		225	let m = platform.matching_exclude_pattern().expect("match");
		226	assert_eq!(m.pattern.text, "user-file-anywhere");
		227	Ok(())
109	}	228	}
110	}	229	}

git-worktree/tests/worktree/fs/mod.rs+1−0

@@ -19,3 +19,4 @@ fn from_probing_cwd() { · 18 unmodified lines
19	}	19	}
20		20
21	mod cache;	21	mod cache;
		22	mod stack;

git-worktree/tests/worktree/fs/stack/mod.rs+144−0

@@ -0,0 +1,144 @@
	1	use git_worktree::fs::Stack;
	2	use std::path::{Path, PathBuf};
	3
	4	#[derive(Debug, Default, Eq, PartialEq)]
	5	struct Record {
	6	push_dir: usize,
	7	dirs: Vec<PathBuf>,
	8	push: usize,
	9	}
	10
	11	impl git_worktree::fs::stack::Delegate for Record {
	12	fn push_directory(&mut self, stack: &Stack) -> std::io::Result<()> {
	13	self.push_dir += 1;
	14	self.dirs.push(stack.current().into());
	15	Ok(())
	16	}
	17
	18	fn push(&mut self, _is_last_component: bool, _stack: &Stack) -> std::io::Result<()> {
	19	self.push += 1;
	20	Ok(())
	21	}
	22
	23	fn pop_directory(&mut self) {
	24	self.dirs.pop();
	25	}
	26	}
	27
	28	#[test]
	29	fn delegate_calls_are_consistent() -> crate::Result {
	30	let root = PathBuf::from(".");
	31	let mut s = Stack::new(&root);
	32
	33	assert_eq!(s.current(), root);
	34	assert_eq!(s.current_relative(), Path::new(""));
	35
	36	let mut r = Record::default();
	37	s.make_relative_path_current("a/b", &mut r)?;
	38	let mut dirs = vec![root.clone(), root.join("a")];
	39	assert_eq!(
	40	r,
	41	Record {
	42	push_dir: 2,
	43	dirs: dirs.clone(),
	44	push: 2,
	45	}
	46	);
	47
	48	s.make_relative_path_current("a/b2", &mut r)?;
	49	assert_eq!(
	50	r,
	51	Record {
	52	push_dir: 2,
	53	dirs: dirs.clone(),
	54	push: 3,
	55	}
	56	);
	57
	58	s.make_relative_path_current("c/d/e", &mut r)?;
	59	dirs.pop();
	60	dirs.extend([root.join("c"), root.join("c").join("d")]);
	61	assert_eq!(
	62	r,
	63	Record {
	64	push_dir: 4,
	65	dirs: dirs.clone(),
	66	push: 6,
	67	}
	68	);
	69
	70	dirs.push(root.join("c").join("d").join("x"));
	71	s.make_relative_path_current("c/d/x/z", &mut r)?;
	72	assert_eq!(
	73	r,
	74	Record {
	75	push_dir: 5,
	76	dirs: dirs.clone(),
	77	push: 8,
	78	}
	79	);
	80
	81	dirs.drain(dirs.len() - 3..).count();
	82	s.make_relative_path_current("f", &mut r)?;
	83	assert_eq!(s.current_relative(), Path::new("f"));
	84	assert_eq!(
	85	r,
	86	Record {
	87	push_dir: 5,
	88	dirs: dirs.clone(),
	89	push: 9,
	90	}
	91	);
	92
	93	dirs.push(root.join("x"));
	94	s.make_relative_path_current("x/z", &mut r)?;
	95	assert_eq!(
	96	r,
	97	Record {
	98	push_dir: 6,
	99	dirs: dirs.clone(),
	100	push: 11,
	101	}
	102	);
	103
	104	dirs.push(root.join("x").join("z"));
	105	s.make_relative_path_current("x/z/a", &mut r)?;
	106	assert_eq!(
	107	r,
	108	Record {
	109	push_dir: 7,
	110	dirs: dirs.clone(),
	111	push: 12,
	112	}
	113	);
	114
	115	dirs.push(root.join("x").join("z").join("a"));
	116	dirs.push(root.join("x").join("z").join("a").join("b"));
	117	s.make_relative_path_current("x/z/a/b/c", &mut r)?;
	118	assert_eq!(
	119	r,
	120	Record {
	121	push_dir: 9,
	122	dirs: dirs.clone(),
	123	push: 14,
	124	}
	125	);
	126
	127	dirs.drain(dirs.len() - 2..).count();
	128	s.make_relative_path_current("x/z", &mut r)?;
	129	assert_eq!(
	130	r,
	131	Record {
	132	push_dir: 9,
	133	dirs: dirs.clone(),
	134	push: 14,
	135	}
	136	);
	137	assert_eq!(
	138	dirs.last(),
	139	Some(&PathBuf::from("./x/z")),
	140	"the stack is state so keeps thinking it's a directory which is consistent. Git does it differently though."
	141	);
	142
	143	Ok(())
	144	}

gitoxide-core/src/organize.rs+1−1

@@ -257,7 +257,7 @@ where · 256 unmodified lines
257	progress.fail(format!(	257	progress.fail(format!(
258	"Error when handling directory {:?}: {}",	258	"Error when handling directory {:?}: {}",
259	path_to_move.display(),	259	path_to_move.display(),
260	err.to_string()	260	err
261	));	261	));
262	num_errors += 1;	262	num_errors += 1;
263	}	263	}

gitoxide-core/src/pack/receive.rs+2−1

     sync::{atomic::AtomicBool, Arc},
 };
+pub use git_repository as git;
 use git_repository::{
     hash::ObjectId,
     objs::bstr::{BString, ByteSlice},
 fn write_raw_refs(refs: &[Ref], directory: PathBuf) -> std::io::Result<()> {
     let assure_dir_exists = |path: &BString| {
         assert!(!path.starts_with_str("/"), "no ref start with a /, they are relative");
-        let path = directory.join(git_features::path::from_byte_slice_or_panic_on_windows(path));
+        let path = directory.join(git::path::from_byte_slice(path));
         std::fs::create_dir_all(path.parent().expect("multi-component path")).map(|_| path)
     };
     for r in refs {

gitoxide-core/src/repository/commit.rs+1−4

-use std::path::PathBuf;
 use anyhow::{Context, Result};
 use git_repository as git;
 pub fn describe(
-    repo: impl Into<PathBuf>,
+    repo: git::Repository,
     rev_spec: Option<&str>,
     mut out: impl std::io::Write,
     mut err: impl std::io::Write,
         long_format,
     }: describe::Options,
 ) -> Result<()> {
-    let repo = git::open(repo)?.apply_environment();
     let commit = match rev_spec {
         Some(spec) => repo.rev_parse(spec)?.object()?.try_into_commit()?,
         None => repo.head_commit()?,

gitoxide-core/src/repository/exclude.rs+68−0

@@ -0,0 +1,68 @@
	1	use anyhow::{bail, Context};
	2	use std::io;
	3
	4	use crate::OutputFormat;
	5	use git_repository as git;
	6	use git_repository::prelude::FindExt;
	7
	8	pub mod query {
	9	use crate::OutputFormat;
	10	use std::ffi::OsString;
	11
	12	pub struct Options {
	13	pub format: OutputFormat,
	14	pub overrides: Vec<OsString>,
	15	pub show_ignore_patterns: bool,
	16	}
	17	}
	18
	19	pub fn query(
	20	repo: git::Repository,
	21	pathspecs: impl Iterator<Item = git::path::Spec>,
	22	mut out: impl io::Write,
	23	query::Options {
	24	overrides,
	25	format,
	26	show_ignore_patterns,
	27	}: query::Options,
	28	) -> anyhow::Result<()> {
	29	if format != OutputFormat::Human {
	30	bail!("JSON output isn't implemented yet");
	31	}
	32
	33	let worktree = repo
	34	.worktree()
	35	.current()
	36	.with_context(\|\| "Cannot check excludes without a current worktree")?;
	37	let index = worktree.open_index()?;
	38	let mut cache = worktree.excludes(
	39	&index.state,
	40	Some(git::attrs::MatchGroup::<git::attrs::Ignore>::from_overrides(overrides)),
	41	)?;
	42
	43	let prefix = repo.prefix().expect("worktree - we have an index by now")?;
	44
	45	for mut spec in pathspecs {
	46	for path in spec.apply_prefix(&prefix).items() {
	47	// TODO: what about paths that end in /? Pathspec might handle it, it's definitely something git considers
	48	// even if the directory doesn't exist. Seems to work as long as these are kept in the spec.
	49	let is_dir = git::path::from_bstr(path).metadata().ok().map(\|m\| m.is_dir());
	50	let entry = cache.at_entry(path, is_dir, \|oid, buf\| repo.objects.find_blob(oid, buf))?;
	51	let match_ = entry
	52	.matching_exclude_pattern()
	53	.and_then(\|m\| (show_ignore_patterns \|\| !m.pattern.is_negative()).then(\|\| m));
	54	match match_ {
	55	Some(m) => writeln!(
	56	out,
	57	"{}:{}:{}\t{}",
	58	m.source.map(\|p\| p.to_string_lossy()).unwrap_or_default(),
	59	m.sequence_number,
	60	m.pattern,
	61	path
	62	)?,
	63	None => writeln!(out, "::\t{}", path)?,
	64	}
	65	}
	66	}
	67	Ok(())
	68	}

gitoxide-core/src/repository/mailmap.rs+2−3

-use std::{io, path::PathBuf};
+use std::io;
 use git_repository as git;
 #[cfg(feature = "serde1")]
 }
 pub fn entries(
-    repository: PathBuf,
+    repo: git::Repository,
     format: OutputFormat,
     #[cfg_attr(not(feature = "serde1"), allow(unused_variables))] out: impl io::Write,
     mut err: impl io::Write,
         writeln!(err, "Defaulting to JSON as human format isn't implemented").ok();
     }
-    let repo = git::open(repository)?.apply_environment();
     let mut mailmap = git::mailmap::Snapshot::default();
     if let Err(e) = repo.load_mailmap_into(&mut mailmap) {
         writeln!(err, "Error while loading mailmap, the first error is: {}", e).ok();

gitoxide-core/src/repository/mod.rs+2−0

@@ -16,3 +16,5 @@ pub mod verify; · 15 unmodified lines
16	pub mod odb;	16	pub mod odb;
17		17
18	pub mod mailmap;	18	pub mod mailmap;
		19
		20	pub mod exclude;

gitoxide-core/src/repository/odb.rs+3−6

-use std::{io, path::PathBuf};
+use std::io;
 use anyhow::bail;
 use git_repository as git;
 #[cfg_attr(not(feature = "serde1"), allow(unused_variables))]
 pub fn info(
-    repository: PathBuf,
+    repo: git::Repository,
     format: OutputFormat,
     out: impl io::Write,
     mut err: impl io::Write,
         writeln!(err, "Only JSON is implemented - using that instead")?;
     }
-    let repo = git::open(repository)?.apply_environment();
     let store = repo.objects.store_ref();
     let stats = info::Statistics {
         path: store.path().into(),
     Ok(())
 }
-pub fn entries(repository: PathBuf, format: OutputFormat, mut out: impl io::Write) -> anyhow::Result<()> {
+pub fn entries(repo: git::Repository, format: OutputFormat, mut out: impl io::Write) -> anyhow::Result<()> {
     if format != OutputFormat::Human {
         bail!("Only human output format is supported at the moment");
     }
-    let repo = git::open(repository)?.apply_environment();
     for object in repo.objects.iter()? {
         let object = object?;
         writeln!(out, "{}", object)?;

gitoxide-core/src/repository/tree.rs+3−5

-use std::{borrow::Cow, io, path::PathBuf};
+use std::{borrow::Cow, io};
 use anyhow::bail;
 use git_repository as git;
 #[cfg_attr(not(feature = "serde1"), allow(unused_variables))]
 pub fn info(
-    repository: PathBuf,
+    repo: git::Repository,
     treeish: Option<&str>,
     extended: bool,
     format: OutputFormat,
         writeln!(err, "Only JSON is implemented - using that instead")?;
     }
-    let repo = git::open(repository)?.apply_environment();
     let tree = treeish_to_tree(treeish, &repo)?;
     let mut delegate = entries::Traverse::new(extended.then(|| &repo), None);
 }
 pub fn entries(
-    repository: PathBuf,
+    repo: git::Repository,
     treeish: Option<&str>,
     recursive: bool,
     extended: bool,
         bail!("Only human output format is supported at the moment");
     }
-    let repo = git::open(repository)?.apply_environment();
     let tree = treeish_to_tree(treeish, &repo)?;
     if recursive {

gitoxide-core/src/repository/verify.rs+2−3

-use std::{path::PathBuf, sync::atomic::AtomicBool};
+use std::sync::atomic::AtomicBool;
 use git_repository as git;
 use git_repository::Progress;
 pub const PROGRESS_RANGE: std::ops::RangeInclusive<u8> = 1..=3;
 pub fn integrity(
-    repo: PathBuf,
+    repo: git::Repository,
     mut out: impl std::io::Write,
     progress: impl Progress,
     should_interrupt: &AtomicBool,
         algorithm,
     }: Context,
 ) -> anyhow::Result<()> {
-    let repo = git_repository::open(repo)?;
     #[cfg_attr(not(feature = "serde1"), allow(unused))]
     let mut outcome = repo.objects.store_ref().verify_integrity(
         progress,

src/plumbing/main.rs+177−130

 use anyhow::Result;
 use clap::Parser;
+use git_repository::bstr::io::BufReadExt;
 use gitoxide_core as core;
 use gitoxide_core::pack::verify;
                 },
             ),
         },
-        Subcommands::Repository(repo::Platform { repository, cmd }) => match cmd {
+        Subcommands::Repository(repo::Platform { repository, cmd }) => {
-            repo::Subcommands::Commit { cmd } => match cmd {
+            use git_repository as git;
-                repo::commit::Subcommands::Describe {
+            let repository = git::ThreadSafeRepository::discover(repository)?;
-                    annotated_tags,
+            match cmd {
-                    all_refs,
+                repo::Subcommands::Commit { cmd } => match cmd {
-                    first_parent,
+                    repo::commit::Subcommands::Describe {
-                    always,
+                        annotated_tags,
-                    long,
+                        all_refs,
-                    statistics,
+                        first_parent,
-                    max_candidates,
+                        always,
-                    rev_spec,
+                        long,
+                        statistics,
+                        max_candidates,
+                        rev_spec,
+                    } => prepare_and_run(
+                        "repository-commit-describe",
+                        verbose,
+                        progress,
+                        progress_keep_open,
+                        None,
+                        move |_progress, out, err| {
+                            core::repository::commit::describe(
+                                repository.into(),
+                                rev_spec.as_deref(),
+                                out,
+                                err,
+                                core::repository::commit::describe::Options {
+                                    all_tags: !annotated_tags,
+                                    all_refs,
+                                    long_format: long,
+                                    first_parent,
+                                    statistics,
+                                    max_candidates,
+                                    always,
+                                },
+                            )
+                        },
+                    ),
+                },
+                repo::Subcommands::Exclude { cmd } => match cmd {
+                    repo::exclude::Subcommands::Query {
+                        patterns,
+                        pathspecs,
+                        show_ignore_patterns,
+                    } => prepare_and_run(
+                        "repository-exclude-query",
+                        verbose,
+                        progress,
+                        progress_keep_open,
+                        None,
+                        move |_progress, out, _err| {
+                            use git::bstr::ByteSlice;
+                            core::repository::exclude::query(
+                                repository.into(),
+                                if pathspecs.is_empty() {
+                                    Box::new(
+                                        stdin_or_bail()?
+                                            .byte_lines()
+                                            .filter_map(Result::ok)
+                                            .filter_map(|line| git::path::Spec::from_bytes(line.as_bstr())),
+                                    ) as Box<dyn Iterator<Item = git::path::Spec>>
+                                } else {
+                                    Box::new(pathspecs.into_iter())
+                                },
+                                out,
+                                core::repository::exclude::query::Options {
+                                    format,
+                                    show_ignore_patterns,
+                                    overrides: patterns,
+                                },
+                            )
+                        },
+                    ),
+                },
+                repo::Subcommands::Mailmap { cmd } => match cmd {
+                    repo::mailmap::Subcommands::Entries => prepare_and_run(
+                        "repository-mailmap-entries",
+                        verbose,
+                        progress,
+                        progress_keep_open,
+                        None,
+                        move |_progress, out, err| {
+                            core::repository::mailmap::entries(repository.into(), format, out, err)
+                        },
+                    ),
+                },
+                repo::Subcommands::Odb { cmd } => match cmd {
+                    repo::odb::Subcommands::Entries => prepare_and_run(
+                        "repository-odb-entries",
+                        verbose,
+                        progress,
+                        progress_keep_open,
+                        None,
+                        move |_progress, out, _err| core::repository::odb::entries(repository.into(), format, out),
+                    ),
+                    repo::odb::Subcommands::Info => prepare_and_run(
+                        "repository-odb-info",
+                        verbose,
+                        progress,
+                        progress_keep_open,
+                        None,
+                        move |_progress, out, err| core::repository::odb::info(repository.into(), format, out, err),
+                    ),
+                },
+                repo::Subcommands::Tree { cmd } => match cmd {
+                    repo::tree::Subcommands::Entries {
+                        treeish,
+                        recursive,
+                        extended,
+                    } => prepare_and_run(
+                        "repository-tree-entries",
+                        verbose,
+                        progress,
+                        progress_keep_open,
+                        None,
+                        move |_progress, out, _err| {
+                            core::repository::tree::entries(
+                                repository.into(),
+                                treeish.as_deref(),
+                                recursive,
+                                extended,
+                                format,
+                                out,
+                            )
+                        },
+                    ),
+                    repo::tree::Subcommands::Info { treeish, extended } => prepare_and_run(
+                        "repository-tree-info",
+                        verbose,
+                        progress,
+                        progress_keep_open,
+                        None,
+                        move |_progress, out, err| {
+                            core::repository::tree::info(
+                                repository.into(),
+                                treeish.as_deref(),
+                                extended,
+                                format,
+                                out,
+                                err,
+                            )
+                        },
+                    ),
+                },
+                repo::Subcommands::Verify {
+                    args:
+                        pack::VerifyOptions {
+                            statistics,
+                            algorithm,
+                            decode,
+                            re_encode,
+                        },
                 } => prepare_and_run(
-                    "repository-commit-describe",
+                    "repository-verify",
                     verbose,
                     progress,
                     progress_keep_open,
-                    None,
+                    core::repository::verify::PROGRESS_RANGE,
-                    move |_progress, out, err| {
+                    move |progress, out, _err| {
-                        core::repository::commit::describe(
+                        core::repository::verify::integrity(
-                            repository,
+                            repository.into(),
-                            rev_spec.as_deref(),
                             out,
-                            err,
+                            progress,
-                            core::repository::commit::describe::Options {
+                            &should_interrupt,
-                                all_tags: !annotated_tags,
+                            core::repository::verify::Context {
-                                all_refs,
+                                output_statistics: statistics.then(|| format),
-                                long_format: long,
+                                algorithm,
-                                first_parent,
+                                verify_mode: verify_mode(decode, re_encode),
-                                statistics,
+                                thread_limit,
-                                max_candidates,
-                                always,
                             },
                         )
                     },
                 ),
-            },
+            }
-            repo::Subcommands::Mailmap { cmd } => match cmd {
+        }
-                repo::mailmap::Subcommands::Entries => prepare_and_run(
-                    "repository-mailmap-entries",
-                    verbose,
-                    progress,
-                    progress_keep_open,
-                    None,
-                    move |_progress, out, err| core::repository::mailmap::entries(repository, format, out, err),
-                ),
-            },
-            repo::Subcommands::Odb { cmd } => match cmd {
-                repo::odb::Subcommands::Entries => prepare_and_run(
-                    "repository-odb-entries",
-                    verbose,
-                    progress,
-                    progress_keep_open,
-                    None,
-                    move |_progress, out, _err| core::repository::odb::entries(repository, format, out),
-                ),
-                repo::odb::Subcommands::Info => prepare_and_run(
-                    "repository-odb-info",
-                    verbose,
-                    progress,
-                    progress_keep_open,
-                    None,
-                    move |_progress, out, err| core::repository::odb::info(repository, format, out, err),
-                ),
-            },
-            repo::Subcommands::Tree { cmd } => match cmd {
-                repo::tree::Subcommands::Entries {
-                    treeish,
-                    recursive,
-                    extended,
-                } => prepare_and_run(
-                    "repository-tree-entries",
-                    verbose,
-                    progress,
-                    progress_keep_open,
-                    None,
-                    move |_progress, out, _err| {
-                        core::repository::tree::entries(
-                            repository,
-                            treeish.as_deref(),
-                            recursive,
-                            extended,
-                            format,
-                            out,
-                        )
-                    },
-                ),
-                repo::tree::Subcommands::Info { treeish, extended } => prepare_and_run(
-                    "repository-tree-info",
-                    verbose,
-                    progress,
-                    progress_keep_open,
-                    None,
-                    move |_progress, out, err| {
-                        core::repository::tree::info(repository, treeish.as_deref(), extended, format, out, err)
-                    },
-                ),
-            },
-            repo::Subcommands::Verify {
-                args:
-                    pack::VerifyOptions {
-                        statistics,
-                        algorithm,
-                        decode,
-                        re_encode,
-                    },
-            } => prepare_and_run(
-                "repository-verify",
-                verbose,
-                progress,
-                progress_keep_open,
-                core::repository::verify::PROGRESS_RANGE,
-                move |progress, out, _err| {
-                    core::repository::verify::integrity(
-                        repository,
-                        out,
-                        progress,
-                        &should_interrupt,
-                        core::repository::verify::Context {
-                            output_statistics: statistics.then(|| format),
-                            algorithm,
-                            verify_mode: verify_mode(decode, re_encode),
-                            thread_limit,
-                        },
-                    )
-                },
-            ),
-        },
         Subcommands::Pack(subcommands) => match subcommands {
             pack::Subcommands::Create {
                 repository,
                     progress_keep_open,
                     core::pack::create::PROGRESS_RANGE,
                     move |progress, out, _err| {
-                        let input = if has_tips {
+                        let input = if has_tips { None } else { stdin_or_bail()?.into() };
-                            None
-                        } else {
-                            if atty::is(atty::Stream::Stdin) {
-                                anyhow::bail!(
-                                    "Refusing to read from standard input as no path is given, but it's a terminal."
-                                )
-                            }
-                            Some(BufReader::new(stdin()))
-                        };
                         let repository = repository.unwrap_or_else(|| PathBuf::from("."));
                         let context = core::pack::create::Context {
                             thread_limit,
                         directory,
                         refs_directory,
                         refs.into_iter().map(|r| r.into()).collect(),
-                        git_features::progress::DoOrDiscard::from(progress),
+                        progress,
                         core::pack::receive::Context {
                             thread_limit,
                             format,
                     core::remote::refs::list(
                         protocol,
                         &url,
-                        git_features::progress::DoOrDiscard::from(progress),
+                        progress,
                         core::remote::refs::Context {
                             thread_limit,
                             format,
     Ok(())
 }
+fn stdin_or_bail() -> anyhow::Result<std::io::BufReader<std::io::Stdin>> {
+    if atty::is(atty::Stream::Stdin) {
+        anyhow::bail!("Refusing to read from standard input while a terminal is connected")
+    }
+    Ok(BufReader::new(stdin()))
+}
 fn verify_mode(decode: bool, re_encode: bool) -> verify::Mode {
     match (decode, re_encode) {
         (true, false) => verify::Mode::HashCrc32Decode,

src/plumbing/options.rs+30−0

@@ -370,6 +370,36 @@ pub mod repo { · 369 unmodified lines
370	#[clap(subcommand)]	370	#[clap(subcommand)]
371	cmd: mailmap::Subcommands,	371	cmd: mailmap::Subcommands,
372	},	372	},
		373	/// Interact with the exclude files like .gitignore.
		374	Exclude {
		375	#[clap(subcommand)]
		376	cmd: exclude::Subcommands,
		377	},
		378	}
		379
		380	pub mod exclude {
		381	use git_repository as git;
		382	use std::ffi::OsString;
		383
		384	#[derive(Debug, clap::Subcommand)]
		385	pub enum Subcommands {
		386	/// Check if path-specs are excluded and print the result similar to `git check-ignore`.
		387	Query {
		388	/// Show actual ignore patterns instead of un-excluding an entry.
		389	///
		390	/// That way one can understand why an entry might not be excluded.
		391	#[clap(long, short = 'i')]
		392	show_ignore_patterns: bool,
		393	/// Additional patterns to use for exclusions. They have the highest priority.
		394	///
		395	/// Useful for undoing previous patterns using the '!' prefix.
		396	#[clap(long, short = 'p')]
		397	patterns: Vec<OsString>,
		398	/// The git path specifications to check for exclusion, or unset to read from stdin one per line.
		399	#[clap(parse(try_from_os_str = std::convert::TryFrom::try_from))]
		400	pathspecs: Vec<git::path::Spec>,
		401	},
		402	}
373	}	403	}
374		404
375	pub mod mailmap {	405	pub mod mailmap {

src/porcelain/main.rs+3−3

@@ -53,7 +53,7 @@ pub fn main() -> Result<()> { · 52 unmodified lines
53	hours::estimate(	53	hours::estimate(
54	&working_dir,	54	&working_dir,
55	&refname,	55	&refname,
56	git_features::progress::DoOrDiscard::from(progress),	56	progress,
57	hours::Context {	57	hours::Context {
58	show_pii,	58	show_pii,
59	omit_unify_identities,	59	omit_unify_identities,
@@ -75,7 +75,7 @@ pub fn main() -> Result<()> { · 15 unmodified lines
75	organize::discover(	75	organize::discover(
76	root.unwrap_or_else(\|\| [std::path::Component::CurDir].iter().collect()),	76	root.unwrap_or_else(\|\| [std::path::Component::CurDir].iter().collect()),
77	out,	77	out,
78	git_features::progress::DoOrDiscard::from(progress),	78	progress,
79	debug,	79	debug,
80	)	80	)
81	},	81	},
@@ -102,7 +102,7 @@ pub fn main() -> Result<()> { · 20 unmodified lines
102	},	102	},
103	repository_source.unwrap_or_else(\|\| [std::path::Component::CurDir].iter().collect()),	103	repository_source.unwrap_or_else(\|\| [std::path::Component::CurDir].iter().collect()),
104	destination_directory.unwrap_or_else(\|\| [std::path::Component::CurDir].iter().collect()),	104	destination_directory.unwrap_or_else(\|\| [std::path::Component::CurDir].iter().collect()),
105	git_features::progress::DoOrDiscard::from(progress),	105	progress,
106	)	106	)
107	},	107	},
108	)	108	)

src/shared.rs+45−2

@@ -52,19 +52,62 @@ pub mod pretty { · 51 unmodified lines
52		52
53	use crate::shared::ProgressRange;	53	use crate::shared::ProgressRange;
54		54
		55	#[cfg(feature = "small")]
		56	pub fn prepare_and_run<T>(
		57	name: &str,
		58	verbose: bool,
		59	progress: bool,
		60	#[cfg_attr(not(feature = "prodash-render-tui"), allow(unused_variables))] progress_keep_open: bool,
		61	range: impl Into<Option<ProgressRange>>,
		62	run: impl FnOnce(
		63	progress::DoOrDiscard<prodash::tree::Item>,
		64	&mut dyn std::io::Write,
		65	&mut dyn std::io::Write,
		66	) -> Result<T>,
		67	) -> Result<T> {
		68	crate::shared::init_env_logger();
		69
		70	match (verbose, progress) {
		71	(false, false) => {
		72	let stdout = stdout();
		73	let mut stdout_lock = stdout.lock();
		74	let stderr = stderr();
		75	let mut stderr_lock = stderr.lock();
		76	run(progress::DoOrDiscard::from(None), &mut stdout_lock, &mut stderr_lock)
		77	}
		78	(true, false) => {
		79	let progress = crate::shared::progress_tree();
		80	let sub_progress = progress.add_child(name);
		81
		82	use crate::shared::{self, STANDARD_RANGE};
		83	let handle = shared::setup_line_renderer_range(&progress, range.into().unwrap_or(STANDARD_RANGE));
		84
		85	let mut out = Vec::<u8>::new();
		86	let res = run(progress::DoOrDiscard::from(Some(sub_progress)), &mut out, &mut stderr());
		87	handle.shutdown_and_wait();
		88	std::io::Write::write_all(&mut stdout(), &out)?;
		89	res
		90	}
		91	#[cfg(not(feature = "prodash-render-tui"))]
		92	(true, true) \| (false, true) => {
		93	unreachable!("BUG: This branch can't be run without a TUI built-in")
		94	}
		95	}
		96	}
		97
		98	#[cfg(not(feature = "small"))]
55	pub fn prepare_and_run<T: Send + 'static>(	99	pub fn prepare_and_run<T: Send + 'static>(
56	name: &str,	100	name: &str,
57	verbose: bool,	101	verbose: bool,
58	progress: bool,	102	progress: bool,
59	#[cfg_attr(not(feature = "prodash-render-tui"), allow(unused_variables))] progress_keep_open: bool,	103	#[cfg_attr(not(feature = "prodash-render-tui"), allow(unused_variables))] progress_keep_open: bool,
60	#[cfg_attr(not(feature = "prodash-render-line"), allow(unused_variables))] range: impl Into<Option<ProgressRange>>,	104	range: impl Into<Option<ProgressRange>>,
61	run: impl FnOnce(	105	run: impl FnOnce(
62	progress::DoOrDiscard<prodash::tree::Item>,	106	progress::DoOrDiscard<prodash::tree::Item>,
63	&mut dyn std::io::Write,	107	&mut dyn std::io::Write,
64	&mut dyn std::io::Write,	108	&mut dyn std::io::Write,
65	) -> Result<T>	109	) -> Result<T>
66	+ Send	110	+ Send
67	+ std::panic::UnwindSafe
68	+ 'static,	111	+ 'static,
69	) -> Result<T> {	112	) -> Result<T> {
70	crate::shared::init_env_logger();	113	crate::shared::init_env_logger();

tests/tools/src/lib.rs+1−1

@@ -13,7 +13,7 @@ use once_cell::sync::Lazy; · 12 unmodified lines
13	use parking_lot::Mutex;	13	use parking_lot::Mutex;
14	pub use tempfile;	14	pub use tempfile;
15		15
16	type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;	16	pub type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
17		17
18	static SCRIPT_IDENTITY: Lazy<Mutex<BTreeMap<PathBuf, u32>>> = Lazy::new(\|\| Mutex::new(BTreeMap::new()));	18	static SCRIPT_IDENTITY: Lazy<Mutex<BTreeMap<PathBuf, u32>>> = Lazy::new(\|\| Mutex::new(BTreeMap::new()));
19		19