Tweak

Author: casey

crates/filepack-cbor/src/input.rs

@@ -14,20 +14,20 @@ pub(crate) struct Input {
 }
 
 impl Input {
-  pub(crate) fn derive_decode(&self) -> Result<proc_macro2::TokenStream> {
+  pub(crate) fn decode(&self) -> Result<proc_macro2::TokenStream> {
     match self.data {
-      Data::Enum(_) => self.derive_decode_enum(),
+      Data::Enum(_) => self.decode_enum(),
       Data::Struct(_) => {
         if self.is_transparent()? {
-          self.derive_decode_transparent()
+          self.decode_transparent()
         } else {
-          self.derive_decode_struct()
+          self.decode_struct()
         }
       }
     }
   }
 
-  pub(crate) fn derive_decode_enum(&self) -> Result<proc_macro2::TokenStream> {
+  pub(crate) fn decode_enum(&self) -> Result<proc_macro2::TokenStream> {
     let name = &self.ident;
 
     let repr = self.parse_repr()?;
@@ -48,7 +48,7 @@ impl Input {
     })
   }
 
-  pub(crate) fn derive_decode_struct(&self) -> Result<proc_macro2::TokenStream> {
+  pub(crate) fn decode_struct(&self) -> Result<proc_macro2::TokenStream> {
     let name = &self.ident;
 
     let fields = self.parse_fields()?;
@@ -80,7 +80,7 @@ impl Input {
     })
   }
 
-  pub(crate) fn derive_decode_transparent(&self) -> Result<proc_macro2::TokenStream> {
+  pub(crate) fn decode_transparent(&self) -> Result<proc_macro2::TokenStream> {
     let name = &self.ident;
 
     let member = self.transparent_member()?;
@@ -99,20 +99,20 @@ impl Input {
     })
   }
 
-  pub(crate) fn derive_encode(&self) -> Result<proc_macro2::TokenStream> {
+  pub(crate) fn encode(&self) -> Result<proc_macro2::TokenStream> {
     match self.data {
-      Data::Enum(_) => self.derive_encode_enum(),
+      Data::Enum(_) => self.encode_enum(),
       Data::Struct(_) => {
         if self.is_transparent()? {
-          self.derive_encode_transparent()
+          self.encode_transparent()
         } else {
-          self.derive_encode_struct()
+          self.encode_struct()
         }
       }
     }
   }
 
-  pub(crate) fn derive_encode_enum(&self) -> Result<proc_macro2::TokenStream> {
+  pub(crate) fn encode_enum(&self) -> Result<proc_macro2::TokenStream> {
     let name = &self.ident;
 
     let repr = self.parse_repr()?;
@@ -126,7 +126,7 @@ impl Input {
     })
   }
 
-  pub(crate) fn derive_encode_struct(&self) -> Result<proc_macro2::TokenStream> {
+  pub(crate) fn encode_struct(&self) -> Result<proc_macro2::TokenStream> {
     let name = &self.ident;
 
     let fields = self.parse_fields()?;
@@ -164,7 +164,7 @@ impl Input {
     })
   }
 
-  pub(crate) fn derive_encode_transparent(&self) -> Result<proc_macro2::TokenStream> {
+  pub(crate) fn encode_transparent(&self) -> Result<proc_macro2::TokenStream> {
     let name = &self.ident;
 
     let member = self.transparent_member()?;

crates/filepack-cbor/src/lib.rs

@@ -17,37 +17,22 @@ mod input;
 mod parsed_field;
 
 #[proc_macro_derive(Decode, attributes(cbor, n))]
-pub fn derive_decode(input: TokenStream) -> TokenStream {
+pub fn decode(input: TokenStream) -> TokenStream {
   let input = syn::parse_macro_input!(input as DeriveInput);
 
   let input = match Input::from_derive_input(&input) {
     Ok(input) => input,
     Err(err) => return err.write_errors().into(),
   };
 
-  match input.derive_decode() {
-    Ok(tokens) => tokens.into(),
-    Err(err) => err.to_compile_error().into(),
-  }
-}
-
-#[proc_macro_derive(Encode, attributes(cbor, n))]
-pub fn derive_encode(input: TokenStream) -> TokenStream {
-  let input = syn::parse_macro_input!(input as DeriveInput);
-
-  let input = match Input::from_derive_input(&input) {
-    Ok(input) => input,
-    Err(err) => return err.write_errors().into(),
-  };
-
-  match input.derive_encode() {
+  match input.decode() {
     Ok(tokens) => tokens.into(),
     Err(err) => err.to_compile_error().into(),
   }
 }
 
 #[proc_macro_derive(DecodeFromStr)]
-pub fn derive_decode_from_str(input: TokenStream) -> TokenStream {
+pub fn decode_from_str(input: TokenStream) -> TokenStream {
   let input = syn::parse_macro_input!(input as DeriveInput);
 
   let name = &input.ident;
@@ -68,8 +53,23 @@ pub fn derive_decode_from_str(input: TokenStream) -> TokenStream {
   .into()
 }
 
+#[proc_macro_derive(Encode, attributes(cbor, n))]
+pub fn encode(input: TokenStream) -> TokenStream {
+  let input = syn::parse_macro_input!(input as DeriveInput);
+
+  let input = match Input::from_derive_input(&input) {
+    Ok(input) => input,
+    Err(err) => return err.write_errors().into(),
+  };
+
+  match input.encode() {
+    Ok(tokens) => tokens.into(),
+    Err(err) => err.to_compile_error().into(),
+  }
+}
+
 #[proc_macro_derive(EncodeDisplay)]
-pub fn derive_encode_display(input: TokenStream) -> TokenStream {
+pub fn encode_display(input: TokenStream) -> TokenStream {
   let input = syn::parse_macro_input!(input as DeriveInput);
 
   let name = &input.ident;

src/derive.rs

@@ -84,6 +84,43 @@ fn all_required() {
   );
 }
 
+#[test]
+fn decode_from_str() {
+  #[derive(Debug, DecodeFromStr, PartialEq)]
+  struct Foo(String);
+
+  #[derive(Debug, Snafu)]
+  #[snafu(display("bar error"))]
+  struct FooError;
+
+  impl FromStr for Foo {
+    type Err = FooError;
+
+    fn from_str(s: &str) -> Result<Self, FooError> {
+      if s == "foo" {
+        Ok(Foo(s.to_string()))
+      } else {
+        Err(FooError)
+      }
+    }
+  }
+
+  assert_eq!(
+    Foo::decode_from_slice(&[0x63, 0x66, 0x6f, 0x6f]).unwrap(),
+    Foo("foo".to_string()),
+  );
+
+  let err = Foo::decode_from_slice(&[0x63, 0x62, 0x61, 0x72]).unwrap_err();
+
+  assert_matches!(
+    err,
+    DecodeError::FromStr {
+      name: "Foo",
+      ref source,
+    } if source.to_string() == "bar error",
+  );
+}
+
 #[test]
 fn decode_with_optional() {
   fn decode_offset(decoder: &mut Decoder) -> Result<u64, DecodeError> {
@@ -124,6 +161,20 @@ fn decode_with_required() {
   );
 }
 
+#[test]
+fn encode_display() {
+  #[derive(EncodeDisplay)]
+  struct Foo;
+
+  impl Display for Foo {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+      write!(f, "foo")
+    }
+  }
+
+  assert_eq!(Foo.encode_to_vec(), [0x63, 0x66, 0x6f, 0x6f]);
+}
+
 #[test]
 fn encode_with_optional() {
   struct Foreign(u64);
@@ -171,57 +222,6 @@ fn encode_with_required() {
   );
 }
 
-#[test]
-fn decode_from_str() {
-  #[derive(Debug, DecodeFromStr, PartialEq)]
-  struct Foo(String);
-
-  #[derive(Debug, Snafu)]
-  #[snafu(display("bar error"))]
-  struct FooError;
-
-  impl FromStr for Foo {
-    type Err = FooError;
-
-    fn from_str(s: &str) -> Result<Self, FooError> {
-      if s == "foo" {
-        Ok(Foo(s.to_string()))
-      } else {
-        Err(FooError)
-      }
-    }
-  }
-
-  assert_eq!(
-    Foo::decode_from_slice(&[0x63, 0x66, 0x6f, 0x6f]).unwrap(),
-    Foo("foo".to_string()),
-  );
-
-  let err = Foo::decode_from_slice(&[0x63, 0x62, 0x61, 0x72]).unwrap_err();
-
-  assert_matches!(
-    err,
-    DecodeError::FromStr {
-      name: "Foo",
-      ref source,
-    } if source.to_string() == "bar error",
-  );
-}
-
-#[test]
-fn encode_display() {
-  #[derive(EncodeDisplay)]
-  struct Foo;
-
-  impl Display for Foo {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-      write!(f, "foo")
-    }
-  }
-
-  assert_eq!(Foo.encode_to_vec(), [0x63, 0x66, 0x6f, 0x6f]);
-}
-
 #[test]
 fn enum_invalid_discriminant() {
   #[derive(Debug, Decode, FromRepr)]