Merge branch 'worktree-stack'

Cargo.toml

@@ -135,6 +135,7 @@ members = [
     "git-chunk",
     "git-quote",
     "git-object",
+    "git-glob",
     "git-diff",
     "git-traverse",
     "git-index",

Makefile

@@ -91,6 +91,7 @@ check: ## Build all code in suitable configurations
 	cd git-index && cargo check --features serde1
 	cd git-revision && cargo check --features serde1
 	cd git-attributes && cargo check --features serde1
+	cd git-glob && cargo check --features serde1
 	cd git-mailmap && cargo check --features serde1
 	cd git-worktree && cargo check --features serde1
 	cd git-actor && cargo check --features serde1

README.md

@@ -119,6 +119,7 @@ Crates that seem feature complete and need to see some more use before they can
   * [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-quote](https://github.com/Byron/gitoxide/blob/main/crate-status.md#git-quote)
+  * [git-glob](https://github.com/Byron/gitoxide/blob/main/crate-status.md#git-glob)
 * **idea**
   * [git-note](https://github.com/Byron/gitoxide/blob/main/crate-status.md#git-note)
   * [git-pathspec](https://github.com/Byron/gitoxide/blob/main/crate-status.md#git-pathspec)

crate-status.md

@@ -1,5 +1,4 @@
 ### git-actor
-
 * [x] read and write a signature that uniquely identifies an actor within a git repository
 
 ### git-hash
@@ -28,7 +27,6 @@
     * [ ] Some examples
 
 ### git-pack
-
 * **packs**
     * [x] traverse pack index
     * [x] 'object' abstraction
@@ -73,7 +71,6 @@
     * [ ] Some examples
 
 ### git-odb
-
 * **loose object store**
     * [x] traverse
     * [x] read
@@ -210,25 +207,21 @@ Check out the [performance discussion][git-traverse-performance] as well.
     * [ ] Some examples
 
 ### git-attributes
-
 * [x] parse git-ignore files (aka git-attributes without the attributes or negation)
 * [x] parse git-attributes files
 * [ ] create an attributes stack, ideally one that includes 'ignored' status from .gitignore files.
    * [ ] support for built-in `binary` macro for `-text -diff -merge`
 
 ### git-quote
-
 * **ansi-c**
   * [x] quote
   * [ ] unquote
 
 ### git-mailmap
-
 * [x] parsing
 * [x] lookup and mapping of author names
 
 ### git-pathspec
-
 * [ ] parse
 * [ ] check for match
 
@@ -238,6 +231,10 @@ A mechanism to associate metadata with any object, and keep revisions of it usin
 
 * [ ] CRUD for git notes
 
+### git-glob
+* [ ] parse pattern
+* [ ] a type for pattern matching
+
 ### git-worktree
 * handle the working tree/checkout
   - [x] checkout an index of files, executables and symlinks just as fast as git
@@ -263,7 +260,6 @@ A mechanism to associate metadata with any object, and keep revisions of it usin
 * parse specifications into revisions (like `git rev-parse`)
 
 ### git-submodule
-
 * CRUD for submodules
 * try to handle with all the nifty interactions and be a little more comfortable than what git offers, lay a foundation for smarter git submodules.
 

git-actor/src/signature/mod.rs

@@ -1,7 +1,8 @@
 mod _ref {
-    use crate::{signature::decode, Signature, SignatureRef};
     use bstr::ByteSlice;
 
+    use crate::{signature::decode, Signature, SignatureRef};
+
     impl<'a> SignatureRef<'a> {
         /// Deserialize a signature from the given `data`.
         pub fn from_bytes<E>(data: &'a [u8]) -> Result<SignatureRef<'a>, nom::Err<E>>

git-attributes/Cargo.toml

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

git-attributes/src/lib.rs

@@ -18,8 +18,6 @@ pub enum State<'a> {
     Unspecified,
 }
 
-pub mod ignore;
-
 pub mod parse;
 
 pub fn parse(buf: &[u8]) -> parse::Lines<'_> {

git-attributes/src/parse/attribute.rs

@@ -6,8 +6,9 @@ use bstr::{BStr, BString, ByteSlice};
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub enum Kind {
     /// A pattern to match paths against
-    Pattern(BString, crate::ignore::pattern::Mode),
+    Pattern(git_glob::Pattern),
     /// The name of the macro to define, always a valid attribute name
+    // TODO: turn it into its own type for maximum safety
     Macro(BString),
 }
 
@@ -162,14 +163,14 @@ fn parse_line(line: &BStr, line_number: usize) -> Option<Result<(Kind, Iter<'_>,
                 _ => unreachable!("BUG: check_attr() must only return attribute errors"),
             }),
         None => {
-            let (pattern, flags) = super::ignore::parse_line(line.as_ref())?;
-            if flags.contains(crate::ignore::pattern::Mode::NEGATIVE) {
+            let pattern = git_glob::Pattern::from_bytes(line.as_ref())?;
+            if pattern.mode.contains(git_glob::pattern::Mode::NEGATIVE) {
                 Err(Error::PatternNegation {
                     line: line.into_owned(),
                     line_number,
                 })
             } else {
-                Ok(Kind::Pattern(pattern, flags))
+                Ok(Kind::Pattern(pattern))
             }
         }
     };

git-attributes/src/parse/ignore.rs

@@ -1,6 +1,4 @@
-use bstr::{BString, ByteSlice};
-
-use crate::ignore;
+use bstr::ByteSlice;
 
 pub struct Lines<'a> {
     lines: bstr::Lines<'a>,
@@ -18,85 +16,19 @@ impl<'a> Lines<'a> {
 }
 
 impl<'a> Iterator for Lines<'a> {
-    type Item = (BString, ignore::pattern::Mode, usize);
+    type Item = (git_glob::Pattern, usize);
 
     fn next(&mut self) -> Option<Self::Item> {
         for line in self.lines.by_ref() {
             self.line_no += 1;
             if line.first() == Some(&b'#') {
                 continue;
             }
-            match parse_line(line) {
+            match git_glob::Pattern::from_bytes(line) {
                 None => continue,
-                Some((line, flags)) => return Some((line, flags, self.line_no)),
+                Some(pattern) => return Some((pattern, self.line_no)),
             }
         }
         None
     }
 }
-
-#[inline]
-pub(crate) fn parse_line(mut line: &[u8]) -> Option<(BString, ignore::pattern::Mode)> {
-    let mut mode = ignore::pattern::Mode::empty();
-    if line.is_empty() {
-        return None;
-    };
-    if line.first() == Some(&b'!') {
-        mode |= ignore::pattern::Mode::NEGATIVE;
-        line = &line[1..];
-    } else if line.first() == Some(&b'\\') {
-        let second = line.get(1);
-        if second == Some(&b'!') || second == Some(&b'#') {
-            line = &line[1..];
-        }
-    }
-    if line.iter().all(|b| b.is_ascii_whitespace()) {
-        return None;
-    }
-    let mut line = truncate_non_escaped_trailing_spaces(line);
-    if line.last() == Some(&b'/') {
-        mode |= ignore::pattern::Mode::MUST_BE_DIR;
-        line.pop();
-    }
-    if !line.contains(&b'/') {
-        mode |= ignore::pattern::Mode::NO_SUB_DIR;
-    }
-    if line.first() == Some(&b'*') && line[1..].find_byteset(br"*?[\").is_none() {
-        mode |= ignore::pattern::Mode::ENDS_WITH;
-    }
-    Some((line, mode))
-}
-
-/// We always copy just because that's ultimately needed anyway, not because we always have to.
-fn truncate_non_escaped_trailing_spaces(buf: &[u8]) -> BString {
-    match buf.rfind_not_byteset(br"\ ") {
-        Some(pos) if pos + 1 == buf.len() => buf.into(), // does not end in (escaped) whitespace
-        None => buf.into(),
-        Some(start_of_non_space) => {
-            // This seems a bit strange but attempts to recreate the git implementation while
-            // actually removing the escape characters before spaces. We leave other backslashes
-            // for escapes to be handled by `glob/globset`.
-            let mut res: BString = buf[..start_of_non_space + 1].into();
-
-            let mut trailing_bytes = buf[start_of_non_space + 1..].iter();
-            let mut bare_spaces = 0;
-            while let Some(b) = trailing_bytes.next() {
-                match b {
-                    b' ' => {
-                        bare_spaces += 1;
-                    }
-                    b'\\' => {
-                        res.extend(std::iter::repeat(b' ').take(bare_spaces));
-                        bare_spaces = 0;
-                        // Skip what follows, like git does, but keep spaces if possible.
-                        if trailing_bytes.next() == Some(&b' ') {
-                            res.push(b' ');
-                        }
-                    }
-                    _ => unreachable!("BUG: this must be either backslash or space"),
-                }
-            }
-            res
-        }
-    }
-}