A baseline test for attribute matching.

It still needs the API to be tested against.

Author: Byron

gix-attributes/Cargo.toml

@@ -18,7 +18,7 @@ serde1 = ["serde", "bstr/serde", "gix-glob/serde1"]
 
 [dependencies]
 gix-features = { version = "^0.28.0", path = "../gix-features" }
-gix-path = { version = "^0.7.2", path = "../gix-path" }
+gix-path = { version = "^0.7.3", path = "../gix-path" }
 gix-quote = { version = "^0.4.3", path = "../gix-quote" }
 gix-glob = { version = "^0.5.5", path = "../gix-glob" }
 

gix-attributes/src/name.rs

@@ -1,4 +1,4 @@
-use bstr::BString;
+use bstr::{BStr, BString, ByteSlice};
 
 use crate::{Name, NameRef};
 
@@ -20,6 +20,25 @@ impl AsRef<str> for NameRef<'_> {
     }
 }
 
+impl<'a> TryFrom<&'a BStr> for NameRef<'a> {
+    type Error = Error;
+
+    fn try_from(attr: &'a BStr) -> Result<Self, Self::Error> {
+        fn attr_valid(attr: &BStr) -> bool {
+            if attr.first() == Some(&b'-') {
+                return false;
+            }
+
+            attr.bytes()
+                .all(|b| matches!(b, b'-' | b'.' | b'_' | b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9'))
+        }
+
+        attr_valid(attr)
+            .then(|| NameRef(attr.to_str().expect("no illformed utf8")))
+            .ok_or_else(|| Error { attribute: attr.into() })
+    }
+}
+
 impl<'a> Name {
     /// Provide our ref-type.
     pub fn as_ref(&'a self) -> NameRef<'a> {

gix-attributes/tests/fixtures/generated-archives/make_attributes_baseline.tar.xz

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

gix-attributes/tests/fixtures/make_attributes_baseline.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+set -eu -o pipefail
+
+mkdir basics;
+
+function baseline() {
+  {
+    echo "$1"
+    git -c core.attributesFile=user.attributes check-attr -a "$1"
+    echo
+  } >> baseline
+}
+
+
+(cd basics
+  git init
+
+  # based on https://github.com/git/git/blob/140b9478dad5d19543c1cb4fd293ccec228f1240/t/t0003-attributes.sh#L45
+	mkdir -p a/b/d a/c b
+	(
+		echo "[attr]notest !test"
+		echo "\" d \"	test=d"
+		echo " e	test=e"
+		echo " e\"	test=e"
+		echo "f	test=f"
+		echo "a/i test=a/i"
+		echo "onoff test -test"
+		echo "offon -test test"
+		echo "no notest"
+		echo "A/e/F test=A/e/F"
+	) > .gitattributes
+	(
+		echo "g test=a/g"
+		echo "b/g test=a/b/g"
+	) > a/.gitattributes
+	(
+		echo "h test=a/b/h"
+		echo "d/* test=a/b/d/*"
+		echo "d/yes notest"
+	) > a/b/.gitattributes
+	(
+		echo "global test=global"
+	) > user.attributes
+
+	git add . && git commit -qm c1
+
+  baseline " d "
+  baseline e
+  baseline "e\""
+  baseline a/i
+  baseline onoff
+  baseline offon
+  baseline no
+  baseline A/e/F
+  baseline a/g
+  baseline a/b/g
+  baseline a/b/h
+  baseline a/b/d/ANY
+  baseline a/b/d/yes
+  baseline global
+)

gix-attributes/tests/match_group/attributes.rs

@@ -0,0 +1,68 @@
+#[test]
+fn baseline() -> crate::Result {
+    baseline::validate("basics")
+}
+
+mod baseline {
+    use bstr::{BStr, ByteSlice};
+    use gix_attributes::StateRef;
+
+    pub fn validate(name: &str) -> crate::Result {
+        let dir = gix_testtools::scripted_fixture_read_only("make_attributes_baseline.sh")?;
+        let repo_dir = dir.join(name);
+        let input = std::fs::read(repo_dir.join("baseline"))?;
+        // TODO: everything with ignorecase (tolower, expect same results)
+
+        for (rela_path, attributes) in (Expectations { lines: input.lines() }) {
+            dbg!(rela_path, attributes);
+        }
+
+        Ok(())
+    }
+
+    pub struct Expectations<'a> {
+        pub lines: bstr::Lines<'a>,
+    }
+
+    impl<'a> Iterator for Expectations<'a> {
+        type Item = (
+            &'a BStr,
+            // Names might refer to attributes or macros
+            Vec<(gix_attributes::NameRef<'a>, gix_attributes::StateRef<'a>)>,
+        );
+
+        fn next(&mut self) -> Option<Self::Item> {
+            let path = self.lines.next()?;
+            let mut assignments = Vec::new();
+            loop {
+                let line = self.lines.next()?;
+                if line.is_empty() {
+                    return Some((path.as_bstr(), assignments));
+                }
+
+                let mut prev = None;
+                let mut tokens = line.splitn(3, |b| {
+                    let is_match = *b == b' ' && prev.take() == Some(b':');
+                    prev = Some(*b);
+                    is_match
+                });
+
+                if let Some(((_path, attr), info)) = tokens.next().zip(tokens.next()).zip(tokens.next()) {
+                    let state = match info {
+                        b"set" => StateRef::Set,
+                        b"unset" => StateRef::Unset,
+                        b"unspecified" => StateRef::Unspecified,
+                        _ => StateRef::Value(info.as_bstr()),
+                    };
+                    let attr = attr.trim_end_with(|b| b == ':');
+                    assignments.push((
+                        gix_attributes::NameRef::try_from(attr.as_bstr()).expect("valid attributes"),
+                        state,
+                    ));
+                } else {
+                    unreachable!("invalid line format: {line:?}", line = line.as_bstr())
+                }
+            }
+        }
+    }
+}

gix-attributes/tests/match_group/mod.rs

@@ -1 +1,2 @@
+mod attributes;
 mod ignore;