parse all kinds of attributes, lacking name validation (#301)

Author: Byron

git-attributes/src/parse/attribute.rs

@@ -42,10 +42,29 @@ impl<'a> Iterator for Iter<'a> {
 
     fn next(&mut self) -> Option<Self::Item> {
         let attr = self.attrs.next().filter(|a| !a.is_empty())?;
-        Some(Ok((attr.as_bstr(), crate::State::Set)))
+        parse_attr(attr).into()
     }
 }
 
+fn parse_attr(attr: &[u8]) -> Result<(&BStr, crate::State<'_>), Error> {
+    let mut tokens = attr.splitn(2, |b| *b == b'=');
+    let attr = tokens.next().expect("attr itself").as_bstr();
+    let possibly_value = tokens.next();
+    let (attr, state) = if attr.first() == Some(&b'-') {
+        (&attr[1..], crate::State::Unset)
+    } else if attr.first() == Some(&b'!') {
+        (&attr[1..], crate::State::Unspecified)
+    } else {
+        (
+            attr,
+            possibly_value
+                .map(|v| crate::State::Value(v.as_bstr()))
+                .unwrap_or(crate::State::Set),
+        )
+    };
+    Ok((attr, state))
+}
+
 impl<'a> Lines<'a> {
     pub fn new(buf: &'a [u8]) -> Self {
         let bom = unicode_bom::Bom::from(buf);

git-attributes/tests/parse/attribute.rs

@@ -134,6 +134,47 @@ fn attributes_are_parsed_behind_various_whitespace_characters() {
     );
 }
 
+#[test]
+fn attributes_come_in_different_flavors_due_to_prefixes() {
+    assert_eq!(
+        line(r#"p set -unset !unspecified -set"#),
+        (
+            "p".into(),
+            Mode::NO_SUB_DIR,
+            vec![set("set"), unset("unset"), unspecified("unspecified"), unset("set")],
+            1
+        ),
+        "the parser doesn't care about double-mentions either"
+    );
+}
+
+#[test]
+fn attributes_can_have_values() {
+    assert_eq!(
+        line(r#"p a=one b=2 c=你好 "#),
+        (
+            "p".into(),
+            Mode::NO_SUB_DIR,
+            vec![value("a", "one"), value("b", "2"), value("c", "你好")],
+            1
+        ),
+        "only non-whitespace ascii values are allowed, no escaping or anything fancy is possible there"
+    );
+}
+
+#[test]
+fn attributes_see_state_adjustments_over_value_assignments() {
+    assert_eq!(
+        line(r#"p set -unset=a !unspecified=b"#),
+        (
+            "p".into(),
+            Mode::NO_SUB_DIR,
+            vec![set("set"), unset("unset"), unspecified("unspecified")],
+            1
+        )
+    );
+}
+
 #[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),);
@@ -151,6 +192,18 @@ fn set(attr: &str) -> (&BStr, State) {
     (attr.as_bytes().as_bstr(), State::Set)
 }
 
+fn unset(attr: &str) -> (&BStr, State) {
+    (attr.as_bytes().as_bstr(), State::Unset)
+}
+
+fn unspecified(attr: &str) -> (&BStr, State) {
+    (attr.as_bytes().as_bstr(), State::Unspecified)
+}
+
+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> {
     let mut lines = git_attributes::parse(input.as_bytes());
     let res = expand(lines.next().unwrap())?;