[git-ref] clear it out and move existing functionality to git-object

This removes an uncanny dependency.
Maybe now we have it the other way around.

Possibly there should be a new crate to contain shared validation
code? Maybe it should just be duplicated? No, that could mean code
drift.

It makes sense for the functionality to be included in the crate
that needs it, so lets see what kind of input validation needs to
happen for refs to work and if it truly is the same.

As it's pretty stable there shouldn't be too much worry about somewhat
similar code to exist in various crates.

Author: Byron

Cargo.lock

@@ -18,7 +18,6 @@ serde1 = ["serde", "bstr/serde1", "smallvec/serde", "git-hash/serde1"]
 all-features = true
 
 [dependencies]
-git-ref = { version = "^0.5.0", path = "../git-ref" }
 git-hash = { version = "^0.3.0", path = "../git-hash" }
 quick-error = "2.0.0"
 hex = "0.4.2"

git-object/Cargo.toml

@@ -16,3 +16,5 @@ pub use types::{tree, Error, Kind, Sign, Time};
 
 ///
 pub mod commit;
+///
+pub mod tag;

git-object/src/lib.rs

@@ -10,7 +10,7 @@ quick_error! {
         StartsWithDash {
             display("Tags must not start with a dash: '-'")
         }
-        InvalidRefName(err: git_ref::validate::NameError) {
+        InvalidRefName(err: crate::tag::validate::NameError) {
             display("The tag name was no valid reference name")
             from()
             source(err)
@@ -65,7 +65,7 @@ impl Tag {
 }
 
 fn validated_name(name: &BStr) -> Result<&BStr, Error> {
-    git_ref::validate::name(name)?;
+    crate::tag::validate::name(name)?;
     if name[0] == b'-' {
         return Err(Error::StartsWithDash);
     }

git-object/src/mutable/tag.rs

@@ -0,0 +1,68 @@
+///
+pub mod validate {
+    use bstr::{BStr, BString};
+    use quick_error::quick_error;
+
+    quick_error! {
+        /// The error returned by [`name()`]
+        #[derive(Debug)]
+        #[allow(missing_docs)]
+        pub enum NameError {
+            InvalidByte(name: BString) {
+                display("A ref must not contain invalid bytes or ascii control characters: '{}'", name)
+            }
+            DoubleDot {
+                display("A ref must not contain '..' as it may be mistaken for a range")
+            }
+            LockFileSuffix {
+                display("A ref must not end with '.lock'")
+            }
+            ReflogPortion {
+                display("A ref must not contain '@{{' which is a part of a ref-log")
+            }
+            Asterisk {
+                display("A ref must not contain '*' character")
+            }
+            StartsWithDot {
+                display("A ref must not start with a '.'")
+            }
+            EndsWithSlash {
+                display("A ref must not end with a '/'")
+            }
+            Empty {
+                display("A ref must not be empty")
+            }
+        }
+    }
+
+    /// Assure the given `bytes` resemble a valid git ref name, which are returned unchanged on success.
+    pub fn name(bytes: &BStr) -> Result<&BStr, NameError> {
+        if bytes.is_empty() {
+            return Err(NameError::Empty);
+        }
+
+        let mut last = 0;
+        for byte in bytes.iter() {
+            match byte {
+                b'\\' | b'^' | b':' | b'[' | b'?' | b' ' | b'~' | b'\0'..=b'\x1F' | b'\x7F' => {
+                    return Err(NameError::InvalidByte(bytes.into()))
+                }
+                b'*' => return Err(NameError::Asterisk),
+                b'.' if last == b'.' => return Err(NameError::DoubleDot),
+                b'{' if last == b'@' => return Err(NameError::ReflogPortion),
+                _ => {}
+            }
+            last = *byte;
+        }
+        if bytes[0] == b'.' {
+            return Err(NameError::StartsWithDot);
+        }
+        if *bytes.last().expect("non-empty") == b'/' {
+            return Err(NameError::EndsWithSlash);
+        }
+        if bytes.ends_with(b".lock") {
+            return Err(NameError::LockFileSuffix);
+        }
+        Ok(bytes)
+    }
+}

git-object/src/tag.rs

@@ -2,6 +2,7 @@ use std::path::PathBuf;
 
 mod immutable;
 mod mutable;
+mod tag;
 
 type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
 

git-object/tests/object.rs

@@ -0,0 +1 @@
+mod validate;

git-object/tests/tag/mod.rs

@@ -1,7 +1,7 @@
 mod name {
     mod valid {
         use bstr::ByteSlice;
-        use git_ref::validate;
+        use git_object::tag::validate;
 
         macro_rules! mktest {
             ($name:ident, $input:expr) => {
@@ -26,7 +26,7 @@ mod name {
 
     mod invalid {
         use bstr::ByteSlice;
-        use git_ref::validate;
+        use git_object::tag::validate;
 
         macro_rules! mktest {
             ($name:ident, $input:literal, $expected:ident) => {

git-ref/tests/validated/mod.rs renamed to git-object/tests/tag/validate.rs

@@ -1,6 +1,3 @@
 //! Various functionality related to git references
 #![forbid(unsafe_code)]
 #![deny(missing_docs, rust_2018_idioms)]
-
-///
-pub mod validate;