prepare writing of time as part of signature

Author: Byron

README.md

@@ -69,7 +69,7 @@ The CLI uses various crates, please see _'Development Status'_ for details.
 * **git-ref**
   * Handle symbolic references and packed references
   * discover them in typical folder structures
-  * [ ] name validation
+  * [x] name validation
   * [ ] API documentation with examples
 * **git-index**
   * read and write a git-index file

git-object/src/borrowed/object.rs

@@ -4,7 +4,7 @@ pub use error::Error;
 use crate::BStr;
 use crate::{
     borrowed,
-    borrowed::{Blob, Commit, Tag, Tree},
+    borrowed::{parse, Blob, Commit, Tag, Tree},
     Time,
 };
 
@@ -17,6 +17,12 @@ pub struct Signature<'a> {
     pub time: Time,
 }
 
+impl<'a> Signature<'a> {
+    pub fn from_bytes(d: &'a [u8]) -> Result<Signature<'a>, Error> {
+        parse::signature(d).map(|(_, t)| t).map_err(Error::from)
+    }
+}
+
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub enum Object<'a> {

git-object/src/owned/mod.rs

@@ -1,5 +1,8 @@
 //! Owned objects for use with serialization.
 
+pub(crate) const NL: &[u8; 1] = b"\n";
+pub(crate) const SPACE: &[u8; 1] = b" ";
+
 mod convert;
 mod object;
 mod ser;

git-object/src/owned/object.rs

@@ -1,6 +1,48 @@
 use crate::Time;
 use bstr::BString;
 
+pub mod signature {
+    use super::Signature;
+    use crate::owned::SPACE;
+    use bstr::{BStr, ByteSlice};
+    use quick_error::quick_error;
+    use std::io;
+
+    quick_error! {
+        #[derive(Debug)]
+        pub enum Error {
+            IllegalCharacter {
+                description("Signature name or email must not contain '<', '>' or \\n")
+            }
+        }
+    }
+
+    impl From<Error> for io::Error {
+        fn from(err: Error) -> Self {
+            io::Error::new(io::ErrorKind::Other, err)
+        }
+    }
+
+    impl Signature {
+        pub fn write_to(&self, mut out: impl io::Write) -> io::Result<()> {
+            out.write_all(validated_token(self.name.as_bstr())?)?;
+            out.write_all(SPACE)?;
+            out.write_all(&b"<"[..])?;
+            out.write_all(validated_token(self.email.as_bstr())?)?;
+            out.write_all(&b">"[..])?;
+            self.time.write_to(out)?;
+            Ok(())
+        }
+    }
+
+    fn validated_token(name: &BStr) -> Result<&BStr, Error> {
+        if name.find_byteset(b"<>\n").is_some() {
+            return Err(Error::IllegalCharacter);
+        }
+        Ok(name)
+    }
+}
+
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
 pub struct Signature {

git-object/src/owned/ser.rs

@@ -1,3 +1,4 @@
+use crate::owned::{NL, SPACE};
 use bstr::{BString, ByteSlice};
 use quick_error::quick_error;
 use std::io;
@@ -20,9 +21,6 @@ impl Into<io::Error> for Error {
     }
 }
 
-const NL: &[u8; 1] = b"\n";
-const SPACE: &[u8; 1] = b" ";
-
 pub fn trusted_header_field(name: &[u8], value: &[u8], mut out: impl io::Write) -> io::Result<()> {
     out.write_all(name)?;
     out.write_all(&SPACE[..])?;

git-object/src/owned/tag.rs

@@ -37,15 +37,15 @@ pub struct Tag {
 }
 
 impl Tag {
-    pub fn to_write(&self, mut out: impl io::Write) -> io::Result<()> {
+    pub fn write_to(&self, mut out: impl io::Write) -> io::Result<()> {
         let mut hex_buf: [u8; 40] = [0; 40];
         self.target
             .encode_to_40_bytes_slice(&mut hex_buf[..])
             .expect("20 to 40 bytes hex encoding to always work");
 
         ser::trusted_header_field(b"object", &hex_buf, &mut out)?;
         ser::trusted_header_field(b"type", self.target_kind.to_bytes(), &mut out)?;
-        ser::header_field(b"type", validated_name(self.name.as_ref())?, &mut out)?;
+        ser::header_field(b"tag", validated_name(self.name.as_ref())?, &mut out)?;
         unimplemented!("tag to_write")
     }
 }

git-object/src/types.rs

@@ -1,6 +1,7 @@
 use crate::ByteSlice;
-use nom::{lib::std::fmt::Formatter, lib::std::ops::Deref};
 use quick_error::quick_error;
+use std::ops::Deref;
+use std::{fmt, io};
 
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
 #[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]
@@ -20,6 +21,12 @@ pub struct Time {
     pub sign: Sign,
 }
 
+impl Time {
+    pub fn write_to(&self, out: impl io::Write) -> io::Result<()> {
+        unimplemented!("time write to")
+    }
+}
+
 pub const SHA1_SIZE: usize = 20;
 
 /// A SHA1 identifying objects
@@ -60,8 +67,8 @@ impl Deref for Id {
     }
 }
 
-impl std::fmt::Display for Id {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+impl fmt::Display for Id {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut buf = [0u8; 40];
         self.encode_to_40_bytes_slice(&mut buf).unwrap();
         write!(f, "{}", &buf.as_bstr())
@@ -106,8 +113,8 @@ impl Kind {
     }
 }
 
-impl std::fmt::Display for Kind {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+impl fmt::Display for Kind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(std::str::from_utf8(self.to_bytes()).expect("valid utf8 in kind name"))
     }
 }

git-object/tests/owned/mod.rs

@@ -1,3 +1,21 @@
+mod object {
+    mod signature {
+        mod to_write {
+            use bstr::ByteSlice;
+            use git_object::{borrowed, owned};
+
+            #[test]
+            fn round_trip() {
+                let input = b"Sebastian Thiel <byronimo@gmail.com> 1528473343 +0230";
+                let signature: owned::Signature = borrowed::Signature::from_bytes(input).unwrap().into();
+                let mut output = Vec::new();
+                signature.write_to(&mut output).unwrap();
+                assert_eq!(input.as_bstr(), output.as_bstr());
+            }
+        }
+    }
+}
+
 mod tag {
     use crate::fixture_bytes;
     use bstr::ByteSlice;
@@ -8,7 +26,7 @@ mod tag {
         let input = fixture_bytes("tag/empty.txt");
         let tag: owned::Tag = borrowed::Tag::from_bytes(&input).unwrap().into();
         let mut output = Vec::new();
-        tag.to_write(&mut output).unwrap();
+        tag.write_to(&mut output).unwrap();
         assert_eq!(input.as_bstr(), output.as_bstr());
     }
 }