prepare for macro support (#301)

Author: Byron

git-attributes/src/lib.rs

@@ -20,6 +20,6 @@ pub mod ignore;
 
 pub mod parse;
 
-pub fn parse(buf: &[u8]) -> parse::attribute::Lines<'_> {
-    parse::attribute::Lines::new(buf)
+pub fn parse(buf: &[u8]) -> parse::Lines<'_> {
+    parse::Lines::new(buf)
 }

git-attributes/src/parse/attribute.rs

@@ -1,6 +1,15 @@
 use bstr::{BStr, BString, ByteSlice};
 use std::borrow::Cow;
 
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
+#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
+pub enum Kind {
+    /// A pattern to match paths against
+    Pattern(BString),
+    /// The name of the macro to define, always a valid attribute name
+    Macro(BString),
+}
+
 mod error {
     use bstr::BString;
     use quick_error::quick_error;
@@ -100,7 +109,7 @@ impl<'a> Lines<'a> {
 }
 
 impl<'a> Iterator for Lines<'a> {
-    type Item = Result<(BString, crate::ignore::pattern::Mode, Iter<'a>, usize), Error>;
+    type Item = Result<(Kind, crate::ignore::pattern::Mode, Iter<'a>, usize), Error>;
 
     fn next(&mut self) -> Option<Self::Item> {
         for line in self.lines.by_ref() {
@@ -131,7 +140,7 @@ impl<'a> Iterator for Lines<'a> {
 fn parse_line(
     line: &BStr,
     line_number: usize,
-) -> Option<Result<(BString, crate::ignore::pattern::Mode, Iter<'_>), Error>> {
+) -> Option<Result<(Kind, crate::ignore::pattern::Mode, Iter<'_>), Error>> {
     if line.is_empty() {
         return None;
     }
@@ -149,7 +158,7 @@ fn parse_line(
     };
 
     let (pattern, flags) = super::ignore::parse_line(line.as_ref())?;
-    Ok((pattern, flags, Iter::new(attrs, line_number))).into()
+    Ok((Kind::Pattern(pattern), flags, Iter::new(attrs, line_number))).into()
 }
 
 const BLANKS: &[u8] = b" \t\r";

git-attributes/src/parse/mod.rs

@@ -1,6 +1,7 @@
 pub mod ignore;
 
-pub mod attribute;
+mod attribute;
+pub use attribute::{Error, Iter, Kind, Lines};
 
 pub fn ignore(buf: &[u8]) -> ignore::Lines<'_> {
     ignore::Lines::new(buf)

git-attributes/tests/parse/attribute.rs

@@ -1,14 +1,14 @@
-use bstr::{BStr, BString, ByteSlice};
+use bstr::{BStr, ByteSlice};
 use git_attributes::ignore::pattern::Mode;
 use git_attributes::{ignore, parse, State};
 use git_testtools::fixture_path;
 
 #[test]
 fn byte_order_marks_are_no_patterns() {
-    assert_eq!(line("\u{feff}hello"), (r"hello".into(), Mode::NO_SUB_DIR, vec![], 1));
+    assert_eq!(line("\u{feff}hello"), (pattern(r"hello"), Mode::NO_SUB_DIR, vec![], 1));
     assert_eq!(
         line("\u{feff}\"hello\""),
-        (r"hello".into(), Mode::NO_SUB_DIR, vec![], 1)
+        (pattern(r"hello"), Mode::NO_SUB_DIR, vec![], 1)
     );
 }
 
@@ -18,11 +18,11 @@ fn line_numbers_are_counted_correctly() {
     assert_eq!(
         try_lines(&String::from_utf8(ignore).unwrap()).unwrap(),
         vec![
-            (r"*.[oa]".into(), Mode::NO_SUB_DIR, vec![], 2),
-            (r"*.html".into(), Mode::NO_SUB_DIR | Mode::ENDS_WITH, vec![], 5),
-            (r"!foo.html".into(), Mode::NO_SUB_DIR, vec![], 8),
-            (r"#a/path".into(), Mode::empty(), vec![], 10),
-            (r"/*".into(), Mode::empty(), vec![], 11),
+            (pattern(r"*.[oa]"), Mode::NO_SUB_DIR, vec![], 2),
+            (pattern(r"*.html"), Mode::NO_SUB_DIR | Mode::ENDS_WITH, vec![], 5),
+            (pattern(r"!foo.html"), Mode::NO_SUB_DIR, vec![], 8),
+            (pattern(r"#a/path"), Mode::empty(), vec![], 10),
+            (pattern(r"/*"), Mode::empty(), vec![], 11),
         ]
     );
 }
@@ -32,9 +32,9 @@ fn line_endings_can_be_windows_or_unix() {
     assert_eq!(
         try_lines("unix\nwindows\r\nlast").unwrap(),
         vec![
-            (r"unix".into(), Mode::NO_SUB_DIR, vec![], 1),
-            (r"windows".into(), Mode::NO_SUB_DIR, vec![], 2),
-            (r"last".into(), Mode::NO_SUB_DIR, vec![], 3)
+            (pattern(r"unix"), Mode::NO_SUB_DIR, vec![], 1),
+            (pattern(r"windows"), Mode::NO_SUB_DIR, vec![], 2),
+            (pattern(r"last"), Mode::NO_SUB_DIR, vec![], 3)
         ]
     );
 }
@@ -51,47 +51,44 @@ fn comment_lines_are_ignored() {
 
 #[test]
 fn leading_whitespace_is_ignored() {
-    assert_eq!(line(" \r\tp"), (r"p".into(), Mode::NO_SUB_DIR, vec![], 1));
-    assert_eq!(line(" \r\t\"p\""), (r"p".into(), Mode::NO_SUB_DIR, vec![], 1));
+    assert_eq!(line(" \r\tp"), (pattern(r"p"), Mode::NO_SUB_DIR, vec![], 1));
+    assert_eq!(line(" \r\t\"p\""), (pattern(r"p"), Mode::NO_SUB_DIR, vec![], 1));
 }
 
 #[test]
 fn comment_can_be_escaped_like_gitignore_or_quoted() {
     assert_eq!(
         line(r"\#hello"),
-        (r"#hello".into(), Mode::NO_SUB_DIR, vec![], 1),
+        (pattern(r"#hello"), Mode::NO_SUB_DIR, vec![], 1),
         "undocumented, but definitely works"
     );
-    assert_eq!(line("\"# hello\""), (r"# hello".into(), Mode::NO_SUB_DIR, vec![], 1));
+    assert_eq!(line("\"# hello\""), (pattern(r"# hello"), Mode::NO_SUB_DIR, vec![], 1));
 }
 
 #[test]
 fn exclamation_marks_must_be_escaped_or_error_unlike_gitignore() {
-    assert_eq!(line(r"\!hello"), (r"!hello".into(), Mode::NO_SUB_DIR, vec![], 1));
+    assert_eq!(line(r"\!hello"), (pattern(r"!hello"), Mode::NO_SUB_DIR, vec![], 1));
     assert!(matches!(
         try_line(r"!hello"),
-        Err(parse::attribute::Error::PatternNegation { line_number: 1, .. })
+        Err(parse::Error::PatternNegation { line_number: 1, .. })
     ));
     assert!(
         matches!(
             try_line(r#""!hello""#),
-            Err(parse::attribute::Error::PatternNegation { line_number: 1, .. }),
+            Err(parse::Error::PatternNegation { line_number: 1, .. }),
         ),
         "even in quotes they trigger…"
     );
     assert_eq!(
         line(r#""\\!hello""#),
-        (r"!hello".into(), Mode::NO_SUB_DIR, vec![], 1),
+        (pattern(r"!hello"), Mode::NO_SUB_DIR, vec![], 1),
         "…and must be double-escaped, once to get through quote, then to get through parse ignore line"
     );
 }
 
 #[test]
 fn invalid_escapes_in_quotes_are_an_error() {
-    assert!(matches!(
-        try_line(r#""\!hello""#),
-        Err(parse::attribute::Error::Unquote(_)),
-    ),);
+    assert!(matches!(try_line(r#""\!hello""#), Err(parse::Error::Unquote(_)),),);
 }
 
 #[test]
@@ -104,19 +101,19 @@ fn custom_macros_can_be_defined() {
 fn attribute_names_must_not_begin_with_dash_and_must_be_ascii_only() {
     assert!(matches!(
         try_line(r"p !-a"),
-        Err(parse::attribute::Error::AttributeName { line_number: 1, .. })
+        Err(parse::Error::AttributeName { line_number: 1, .. })
     ));
     assert!(
         matches!(
             try_line(r#"p !!a"#),
-            Err(parse::attribute::Error::AttributeName { line_number: 1, .. })
+            Err(parse::Error::AttributeName { line_number: 1, .. })
         ),
         "exclamation marks aren't allowed either"
     );
     assert!(
         matches!(
             try_line(r#"p 你好"#),
-            Err(parse::attribute::Error::AttributeName { line_number: 1, .. })
+            Err(parse::Error::AttributeName { line_number: 1, .. })
         ),
         "nor is utf-8 encoded characters - gitoxide could consider to relax this when established"
     );
@@ -126,32 +123,32 @@ fn attribute_names_must_not_begin_with_dash_and_must_be_ascii_only() {
 fn attributes_are_parsed_behind_various_whitespace_characters() {
     assert_eq!(
         line(r#"p a b"#),
-        ("p".into(), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
+        (pattern("p"), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
         "behind space"
     );
     assert_eq!(
         line(r#""p" a b"#),
-        ("p".into(), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
+        (pattern("p"), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
         "behind space"
     );
     assert_eq!(
         line("p\ta\tb"),
-        ("p".into(), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
+        (pattern("p"), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
         "behind tab"
     );
     assert_eq!(
         line("\"p\"\ta\tb"),
-        ("p".into(), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
+        (pattern("p"), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
         "behind tab"
     );
     assert_eq!(
         line("p \t a \t b"),
-        ("p".into(), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
+        (pattern("p"), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
         "behind a mix of space and tab"
     );
     assert_eq!(
         line("\"p\" \t a \t b"),
-        ("p".into(), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
+        (pattern("p"), Mode::NO_SUB_DIR, vec![set("a"), set("b")], 1),
         "behind a mix of space and tab"
     );
 }
@@ -161,7 +158,7 @@ fn attributes_come_in_different_flavors_due_to_prefixes() {
     assert_eq!(
         line(r#"p set -unset !unspecified -set"#),
         (
-            "p".into(),
+            pattern("p"),
             Mode::NO_SUB_DIR,
             vec![set("set"), unset("unset"), unspecified("unspecified"), unset("set")],
             1
@@ -175,7 +172,7 @@ fn attributes_can_have_values() {
     assert_eq!(
         line(r#"p a=one b=2 c=你好 "#),
         (
-            "p".into(),
+            pattern("p"),
             Mode::NO_SUB_DIR,
             vec![value("a", "one"), value("b", "2"), value("c", "你好")],
             1
@@ -189,7 +186,7 @@ fn attributes_see_state_adjustments_over_value_assignments() {
     assert_eq!(
         line(r#"p set -unset=a !unspecified=b"#),
         (
-            "p".into(),
+            pattern("p"),
             Mode::NO_SUB_DIR,
             vec![set("set"), unset("unset"), unspecified("unspecified")],
             1
@@ -199,12 +196,15 @@ fn attributes_see_state_adjustments_over_value_assignments() {
 
 #[test]
 fn trailing_whitespace_in_attributes_is_ignored() {
-    assert_eq!(line("p a \r\t"), ("p".into(), Mode::NO_SUB_DIR, vec![set("a")], 1),);
-    assert_eq!(line("\"p\" a \r\t"), ("p".into(), Mode::NO_SUB_DIR, vec![set("a")], 1),);
+    assert_eq!(line("p a \r\t"), (pattern("p"), Mode::NO_SUB_DIR, vec![set("a")], 1),);
+    assert_eq!(
+        line("\"p\" a \r\t"),
+        (pattern("p"), Mode::NO_SUB_DIR, vec![set("a")], 1),
+    );
 }
 
 type ExpandedAttribute<'a> = (
-    BString,
+    parse::Kind,
     ignore::pattern::Mode,
     Vec<(&'a BStr, git_attributes::State<'a>)>,
     usize,
@@ -226,7 +226,11 @@ fn value<'a, 'b>(attr: &'a str, value: &'b str) -> (&'a BStr, State<'b>) {
     (attr.as_bytes().as_bstr(), State::Value(value.as_bytes().as_bstr()))
 }
 
-fn try_line(input: &str) -> Result<ExpandedAttribute, parse::attribute::Error> {
+fn pattern(name: &str) -> parse::Kind {
+    parse::Kind::Pattern(name.into())
+}
+
+fn try_line(input: &str) -> Result<ExpandedAttribute, parse::Error> {
     let mut lines = git_attributes::parse(input.as_bytes());
     let res = expand(lines.next().unwrap())?;
     assert!(lines.next().is_none(), "expected only one line");
@@ -240,13 +244,13 @@ fn line(input: &str) -> ExpandedAttribute {
     res
 }
 
-fn try_lines(input: &str) -> Result<Vec<ExpandedAttribute>, parse::attribute::Error> {
+fn try_lines(input: &str) -> Result<Vec<ExpandedAttribute>, parse::Error> {
     git_attributes::parse(input.as_bytes()).map(expand).collect()
 }
 
 fn expand(
-    input: Result<(BString, ignore::pattern::Mode, parse::attribute::Iter<'_>, usize), parse::attribute::Error>,
-) -> Result<ExpandedAttribute<'_>, parse::attribute::Error> {
+    input: Result<(parse::Kind, ignore::pattern::Mode, parse::Iter<'_>, usize), parse::Error>,
+) -> Result<ExpandedAttribute<'_>, parse::Error> {
     let (pattern, mode, attrs, line_no) = input?;
     let attrs = attrs.collect::<Result<Vec<_>, _>>()?;
     Ok((pattern, mode, attrs, line_no))