more varied range testing (#427)

Sebastian Thiel committed 4 years ago

Commit bb0a5541 parent 2e498312 files · +50 −12Browse files

Unified · Split

2 files

git-revision/src/spec.rs +10 −10
git-revision/tests/spec/parse.rs +40 −2

             let mut cursor = input;
             let mut sep_pos = None;
             let mut consecutive_hex_chars = Some(0);
-            while let Some((pos, b)) = cursor
+            while let Some((pos, b)) = cursor.iter().enumerate().find(|(_, b)| {
-                .iter()
+                if b"@~^:.".contains(b) {
-                .inspect(|b| {
+                    true
-                    if let Some(pos) = consecutive_hex_chars.as_mut() {
+                } else {
+                    if let Some(num) = consecutive_hex_chars.as_mut() {
                         if b.is_ascii_hexdigit() {
-                            *pos += 1;
+                            *num += 1;
                         } else {
                             consecutive_hex_chars = None;
                         }
                     }
-                })
+                    false
-                .enumerate()
+                }
-                .find(|(_, b)| b"@~^:.".contains(b))
+            }) {
-            {
                 if *b != b'.' || cursor.get(pos + 1) == Some(&b'.') {
                     sep_pos = Some(pos);
                     break;
                             .and_then(|prefix| delegate.set_prefix(prefix))
                     })
                     .flatten()
-                    .or_else(|| delegate.set_ref(name))
+                    .or_else(|| name.is_empty().then(|| ()).or_else(|| delegate.set_ref(name)))
                     .ok_or(Error::Delegate)?;
             }

git-revision/tests/spec/parse.rs+40−2

 fn empty_specs_are_valid() {
     // they should of course be invalid for the delegate. CLIs may pre-process the input as well if they wish
     // but git itself doesn't do that.
-    for spec in ["", " ", "\n\t"] {
+    for spec in [" ", "\n\t"] {
         let rec = parse(spec);
         assert_eq!(rec.calls, 1);
     }
+    let rec = parse("");
+    assert_eq!(rec.calls, 0, "but we do not bother to call the delegate with nothing");
 }
 #[test]
         .unwrap_err();
         assert!(
             matches!(err, spec::parse::Error::Delegate),
-            "Delegates can refuse spec kind changes to abort parsing early"
+            "Delegates can refuse spec kind changes to abort parsing early in case they want single-specs only"
         );
     }
         let rec = parse("^HEAD");
         assert_eq!(rec.kind.unwrap(), spec::Kind::Range);
         assert_eq!(rec.resolve_ref_input.unwrap(), "HEAD");
+        assert_eq!(rec.prefix, None);
+        assert_eq!(rec.calls, 2);
     }
     #[test]
         let rec = parse("HEAD..");
         assert_eq!(rec.kind.unwrap(), spec::Kind::Range);
         assert_eq!(rec.resolve_ref_input.unwrap(), "HEAD");
+        assert_eq!(rec.prefix, None);
+        assert_eq!(rec.calls, 2);
     }
     #[test]
         let rec = parse("HEAD...");
         assert_eq!(rec.kind.unwrap(), spec::Kind::MergeBase);
         assert_eq!(rec.resolve_ref_input.unwrap(), "HEAD");
+        assert_eq!(rec.prefix, None);
+        assert_eq!(rec.calls, 2);
     }
     #[test]
         assert_eq!(rec.kind.unwrap(), spec::Kind::MergeBase);
         assert_eq!(rec.resolve_ref_input.unwrap(), "HEAD");
         assert_eq!(rec.resolve_ref_input2.unwrap(), "HEAD");
+        assert_eq!(rec.calls, 3);
+        let rec = parse("r1...abcd");
+        assert_eq!(rec.kind.unwrap(), spec::Kind::MergeBase);
+        assert_eq!(rec.resolve_ref_input.unwrap(), "r1");
+        assert_eq!(rec.prefix, prefix("abcd").into());
+        assert_eq!(rec.calls, 3);
     }
     #[test]
         assert_eq!(rec.kind.unwrap(), spec::Kind::Range);
         assert_eq!(rec.resolve_ref_input.unwrap(), "HEAD");
         assert_eq!(rec.resolve_ref_input2.unwrap(), "HEAD");
+        assert_eq!(rec.calls, 3);
+        let rec = parse("r1..r2");
+        assert_eq!(rec.kind.unwrap(), spec::Kind::Range);
+        assert_eq!(rec.resolve_ref_input.unwrap(), "r1");
+        assert_eq!(rec.resolve_ref_input2.unwrap(), "r2");
+        assert_eq!(rec.calls, 3);
+        let rec = parse("abcd..1234");
+        assert_eq!(rec.kind.unwrap(), spec::Kind::Range);
+        assert_eq!(rec.prefix, prefix("abcd").into());
+        assert_eq!(rec.prefix2, prefix("1234").into());
+        assert_eq!(rec.calls, 3);
+        let rec = parse("r1..abcd");
+        assert_eq!(rec.kind.unwrap(), spec::Kind::Range);
+        assert_eq!(rec.resolve_ref_input.unwrap(), "r1");
+        assert_eq!(rec.prefix, prefix("abcd").into());
+        assert_eq!(rec.calls, 3);
+    }
+    fn prefix(hex: &str) -> git_hash::Prefix {
+        git_hash::Prefix::from_hex(hex).unwrap()
     }
 }