very basic parsing of attributes (#301)

Author: Byron

git-attributes/src/parse/attribute.rs

@@ -28,23 +28,21 @@ pub struct Lines<'a> {
 }
 
 pub struct Iter<'a> {
-    attrs: bstr::Split<'a>,
+    attrs: bstr::Fields<'a>,
 }
 
 impl<'a> Iter<'a> {
     pub fn new(attrs: &'a BStr) -> Self {
-        Iter {
-            attrs: attrs.split_str(b" "),
-        }
+        Iter { attrs: attrs.fields() }
     }
 }
 
 impl<'a> Iterator for Iter<'a> {
     type Item = Result<(&'a BStr, crate::State<'a>), Error>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let _attr = self.attrs.next().filter(|a| !a.is_empty())?;
-        todo!("parse attribute")
+        let attr = self.attrs.next().filter(|a| !a.is_empty())?;
+        Some(Ok((attr.as_bstr(), crate::State::Set)))
     }
 }
 
@@ -64,6 +62,7 @@ impl<'a> Iterator for Lines<'a> {
     fn next(&mut self) -> Option<Self::Item> {
         for line in self.lines.by_ref() {
             self.line_no += 1;
+            let line = skip_blanks(line.into());
             if line.first() == Some(&b'#') {
                 continue;
             }
@@ -86,26 +85,29 @@ impl<'a> Iterator for Lines<'a> {
     }
 }
 
-fn parse_line(line: &[u8]) -> Option<Result<(BString, crate::ignore::pattern::Mode, Iter<'_>), Error>> {
+fn parse_line(line: &BStr) -> Option<Result<(BString, crate::ignore::pattern::Mode, Iter<'_>), Error>> {
     if line.is_empty() {
         return None;
     }
 
-    let line = line.as_bstr();
     let (line, attrs): (Cow<'_, _>, _) = if line.starts_with(b"\"") {
         let (unquoted, consumed) = match git_quote::ansi_c::undo(line) {
             Ok(res) => res,
             Err(err) => return Some(Err(err.into())),
         };
         (unquoted, &line[consumed..])
     } else {
-        let mut tokens = line.splitn(2, |n| *n == b' ');
-        (
-            tokens.next().expect("at least a line").as_bstr().into(),
-            tokens.next().unwrap_or_default().as_bstr(),
-        )
+        line.find_byteset(BLANKS)
+            .map(|pos| (line[..pos].as_bstr().into(), line[pos..].as_bstr()))
+            .unwrap_or((line.into(), [].as_bstr()))
     };
 
     let (pattern, flags) = super::ignore::parse_line(line.as_ref())?;
     Ok((pattern, flags, Iter::new(attrs))).into()
 }
+
+const BLANKS: &[u8] = b" \t\r";
+
+fn skip_blanks(line: &BStr) -> &BStr {
+    line.find_not_byteset(BLANKS).map(|pos| &line[pos..]).unwrap_or(line)
+}

git-attributes/tests/parse/attribute.rs

@@ -1,6 +1,6 @@
-use bstr::{BStr, BString};
+use bstr::{BStr, BString, ByteSlice};
 use git_attributes::ignore::pattern::Mode;
-use git_attributes::{ignore, parse};
+use git_attributes::{ignore, parse, State};
 use git_testtools::fixture_path;
 
 #[test]
@@ -43,6 +43,16 @@ fn line_endings_can_be_windows_or_unix() {
 fn comment_lines_are_ignored() {
     assert!(git_attributes::parse(b"# hello world").next().is_none());
     assert!(git_attributes::parse(b"# \"hello world\"").next().is_none());
+    assert!(
+        git_attributes::parse(b" \t\r# \"hello world\"").next().is_none(),
+        "also behind leading whitespace"
+    );
+}
+
+#[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));
 }
 
 #[test]
@@ -56,7 +66,7 @@ fn comment_can_be_escaped_like_gitignore_or_quoted() {
 }
 
 #[test]
-fn esclamation_marks_must_be_escaped_or_error_unlike_gitignore() {
+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!(matches!(
         try_line(r"!hello"),
@@ -72,7 +82,7 @@ fn esclamation_marks_must_be_escaped_or_error_unlike_gitignore() {
     assert_eq!(
         line(r#""\\!hello""#),
         (r"!hello".into(), Mode::NO_SUB_DIR, vec![], 1),
-        "…and must be escaped"
+        "…and must be double-escaped, once to get through quote, then to get through parse ignore line"
     );
 }
 
@@ -86,9 +96,48 @@ fn invalid_escapes_in_quotes_are_an_error() {
 
 #[test]
 #[ignore]
+fn custom_macros_can_be_defined() {
+    todo!("name validation, leave rejecting them based on location to the caller")
+}
+
+#[test]
 fn attributes_are_parsed_behind_various_whitespace_characters() {
-    // see https://github.com/git/git/blob/master/attr.c#L280:L280
-    todo!()
+    assert_eq!(
+        line(r#"p a b"#),
+        ("p".into(), 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),
+        "behind space"
+    );
+    assert_eq!(
+        line("p\ta\tb"),
+        ("p".into(), 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),
+        "behind tab"
+    );
+    assert_eq!(
+        line("p \t a \t b"),
+        ("p".into(), 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),
+        "behind a mix of space and tab"
+    );
+}
+
+#[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),);
 }
 
 type ExpandedAttribute<'a> = (
@@ -98,6 +147,10 @@ type ExpandedAttribute<'a> = (
     usize,
 );
 
+fn set(attr: &str) -> (&BStr, State) {
+    (attr.as_bytes().as_bstr(), State::Set)
+}
+
 fn try_line(input: &str) -> Result<ExpandedAttribute, parse::attribute::Error> {
     let mut lines = git_attributes::parse(input.as_bytes());
     let res = expand(lines.next().unwrap())?;