Clippy

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "activitystreams"
 description = "Activity Streams in Rust"
-version = "0.5.0"
+version = "0.6.0"
 license = "GPL-3.0"
 authors = ["asonix <asonix@asonix.dog>"]
 repository = "https://git.asonix.dog/Aardwolf/activitystreams"
@@ -17,7 +17,7 @@ primitives = ["chrono", "mime", "serde", "thiserror", "url"]
 types = ["derive", "kinds", "primitives"]
 
 [dependencies]
-activitystreams-derive = { version = "0.5.0", path = "activitystreams-derive", optional = true}
+activitystreams-derive = { version = "0.6.0", path = "activitystreams-derive", optional = true}
 chrono = { version = "0.4", optional = true }
 mime = { version = "0.3", optional = true }
 serde = { version = "1.0", features = ["derive"], optional = true }

README.md

@@ -9,7 +9,7 @@ __A set of Traits and Types that make up the ActivityStreams and ActivityPub spe
 
 First, add ActivityStreams to your dependencies
 ```toml
-activitystreams = "0.5.0"
+activitystreams = "0.6.0"
 ```
 
 ### Types
@@ -177,7 +177,7 @@ There are a number of features that can be disabled in this crate. By default, e
 enabled.
 
 ```toml
-activitystreams = { version = "0.5.0", default-features = "false", features = ["derive"] }
+activitystreams = { version = "0.6.0", default-features = "false", features = ["derive"] }
 ```
 
 | feature    | what you get                                              |

activitystreams-derive/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "activitystreams-derive"
 description = "Derive macros for activitystreams"
-version = "0.5.0"
+version = "0.6.0"
 license = "GPL-3.0"
 authors = ["asonix <asonix.dev@gmail.com>"]
 repository = "https://git.asonix.dog/Aardwolf/activitystreams"

activitystreams-derive/README.md

@@ -10,7 +10,7 @@ Add the required crates to your `Cargo.toml`
 ```toml
 # Cargo.toml
 
-activitystreams = "0.5.0"
+activitystreams = "0.6.0"
 serde = { version = "1.0", features = ["derive"] }
 ```
 

activitystreams-derive/src/lib.rs

@@ -303,7 +303,7 @@ pub fn ref_derive(input: TokenStream) -> TokenStream {
 ///     where
 ///         T: Object + serde::ser::Serialize;
 ///
-///     pub fn to_concrete<T>(self) -> Result<T, std::io::Error>
+///     pub fn into_concrete<T>(self) -> Result<T, std::io::Error>
 ///     where
 ///         T: Object + serde::de::DeserializeOwned;
 ///
@@ -344,7 +344,7 @@ pub fn wrapper_type(_: TokenStream, input: TokenStream) -> TokenStream {
             ///
             /// Before this method is called, the type should be verified via the `kind` or
             /// `is_kind` methods
-            pub fn to_concrete<T>(self) -> Result<T, std::io::Error>
+            pub fn into_concrete<T>(self) -> Result<T, std::io::Error>
             where
                 T: #trait_name + serde::de::DeserializeOwned,
             {
@@ -360,7 +360,7 @@ pub fn wrapper_type(_: TokenStream, input: TokenStream) -> TokenStream {
             ///     apub::Image,
             /// };
             /// if my_wrapper_type.is_kind(ImageType) {
-            ///     let image = my_wrapper_type.to_concrete::<Image>()?;
+            ///     let image = my_wrapper_type.into_concrete::<Image>()?;
             ///     ...
             /// }
             /// ```
@@ -374,7 +374,7 @@ pub fn wrapper_type(_: TokenStream, input: TokenStream) -> TokenStream {
             /// ```ignore
             /// match my_wrapper_type.kind() {
             ///     Some("Image") => {
-            ///         let image = my_wrapper_type.to_concrete::<Image>()?;
+            ///         let image = my_wrapper_type.into_concrete::<Image>()?;
             ///         ...
             ///     }
             ///     _ => ...,
@@ -500,7 +500,6 @@ pub fn unit_string(input: TokenStream) -> TokenStream {
 fn from_value(attr: Attribute) -> Ident {
     let group = attr
         .tokens
-        .clone()
         .into_iter()
         .filter_map(|token_tree| match token_tree {
             TokenTree::Group(group) => Some(group),
@@ -511,7 +510,6 @@ fn from_value(attr: Attribute) -> Ident {
 
     group
         .stream()
-        .clone()
         .into_iter()
         .filter_map(|token_tree| match token_tree {
             TokenTree::Ident(ident) => Some(ident),
@@ -521,11 +519,11 @@ fn from_value(attr: Attribute) -> Ident {
         .unwrap()
 }
 
-fn to_doc(s: &String) -> proc_macro2::TokenStream {
+fn to_doc(s: &str) -> proc_macro2::TokenStream {
     format!("/// {}", s).parse().unwrap()
 }
 
-fn many_docs(v: &Vec<String>) -> proc_macro2::TokenStream {
+fn many_docs(v: &[String]) -> proc_macro2::TokenStream {
     v.iter()
         .map(|d| {
             let d = to_doc(d);
@@ -572,9 +570,7 @@ fn many_docs(v: &Vec<String>) -> proc_macro2::TokenStream {
 ///     }
 /// }
 ///
-/// fn main() {
 /// let _ = HelloProperties::default();
-/// }
 /// ```
 #[proc_macro]
 pub fn properties(tokens: TokenStream) -> TokenStream {
@@ -598,7 +594,7 @@ pub fn properties(tokens: TokenStream) -> TokenStream {
                 (ty, None)
             } else {
                 let enum_ty = Ident::new(&camelize(&format!("{}_{}_enum", name, fname)), fname.span());
-                let doc_lines = many_docs(&vec![
+                let doc_lines = many_docs(&[
                     format!("Variations for the `{}` field from `{}", fname, name),
                     String::new(),
                     format!("`{}` isn't functional, meaning it can be represented as either a single `{}` or a vector of `{}`.", fname, ty, ty),
@@ -668,12 +664,12 @@ pub fn properties(tokens: TokenStream) -> TokenStream {
                     })
                     .collect();
 
-                let term_doc_lines = many_docs(&vec![
+                let term_doc_lines = many_docs(&[
                     format!("Terminating variations for the `{}` field from `{}`", fname, name),
                     String::new(),
                     format!("Since {} can be one of multiple types, this enum represents all possibilities of {}", fname, fname),
                 ]);
-                let doc_lines = many_docs(&vec![
+                let doc_lines = many_docs(&[
                     format!("Non-Terminating variations for the `{}` field from `{}`", fname, name),
                     String::new(),
                     format!("`{}` isn't functional, meaning it can be represented as either a single `{}` or a vector of `{}`", fname, term_ty, term_ty),
@@ -732,7 +728,7 @@ pub fn properties(tokens: TokenStream) -> TokenStream {
                     })
                     .collect();
 
-                let doc_lines = many_docs(&vec![
+                let doc_lines = many_docs(&[
                     format!("Variations for the `{}` field from `{}`", fname, name),
                     String::new(),
                     format!("`{}` isn't functional, meaning it can only be represented as a single `{}`", fname, ty),
@@ -889,8 +885,7 @@ pub fn properties(tokens: TokenStream) -> TokenStream {
                         #set_many
                     }
                 }
-            } else {
+            } else if field.description.functional {
-                if field.description.functional {
                 let doc_line = to_doc(&format!("Set the `{}` with a type that can be converted into `{}`", fname, v_ty.to_token_stream()));
                 let set = quote! {
                     #doc_line
@@ -982,7 +977,6 @@ pub fn properties(tokens: TokenStream) -> TokenStream {
                     #set_many
                 }
             }
-            }
         } else if field.description.functional {
             let tokens: proc_macro2::TokenStream = field
                 .description
@@ -1365,7 +1359,7 @@ impl Parse for Description {
     }
 }
 
-fn parse_kw<T: Peek + Copy, U: Parse>(input: &ParseStream, t: T) -> Result<bool> {
+fn parse_kw<T: Peek + Copy, U: Parse>(input: ParseStream, t: T) -> Result<bool> {
     let lookahead = input.lookahead1();
     if lookahead.peek(t) {
         input.parse::<U>()?;
@@ -1377,7 +1371,7 @@ fn parse_kw<T: Peek + Copy, U: Parse>(input: &ParseStream, t: T) -> Result<bool>
     Ok(false)
 }
 
-fn parse_string_array<T: Peek + Copy, U: Parse>(input: &ParseStream, t: T) -> Result<Vec<String>> {
+fn parse_string_array<T: Peek + Copy, U: Parse>(input: ParseStream, t: T) -> Result<Vec<String>> {
     let lookahead = input.lookahead1();
     if lookahead.peek(t) {
         input.parse::<U>()?;
@@ -1393,7 +1387,7 @@ fn parse_string_array<T: Peek + Copy, U: Parse>(input: &ParseStream, t: T) -> Re
 }
 
 fn parse_string_group<T: Peek + Copy, U: Parse>(
-    input: &ParseStream,
+    input: ParseStream,
     t: T,
 ) -> Result<Option<String>> {
     let lookahead = input.lookahead1();
@@ -1410,7 +1404,7 @@ fn parse_string_group<T: Peek + Copy, U: Parse>(
     Ok(None)
 }
 
-fn optional_comma(input: &ParseStream) -> Result<()> {
+fn optional_comma(input: ParseStream) -> Result<()> {
     let lookahead = input.lookahead1();
     if lookahead.peek(Token![,]) {
         input.parse::<Token![,]>()?;

examples/de.rs

@@ -56,7 +56,7 @@ fn main() -> Result<(), Error> {
     let v: Vec<Ext<Page, ApObjectProperties>> = cprops
         .get_many_items_base_boxes()
         .unwrap()
-        .map(|base_box| base_box.clone().to_concrete())
+        .map(|base_box| base_box.clone().into_concrete())
         .collect::<Result<Vec<_>, std::io::Error>>()?;
 
     let cprops: &mut CollectionProperties = collection.as_mut();

src/ext.rs

@@ -90,7 +90,6 @@
 //! impl<T> Extension<T> for PublicKeyExtension where T: Actor {}
 //!
 //! // Now that these types are defined, we can put them to use!
-//! fn main() {
 //! let person = Person::new();
 //!
 //! // let's just create a dummy key for this example
@@ -105,7 +104,6 @@
 //! // Note that calling `extend` on person here is possible because the Extensible trait is in
 //! // scope
 //! let person_with_key = person.extend(public_key.to_ext());
-//! }
 //! ```
 
 use crate::{

src/object/mod.rs

@@ -64,7 +64,7 @@ impl AnyImage {
         serde_json::from_value(serde_json::to_value(t)?)
     }
 
-    pub fn to_concrete<T>(self) -> Result<T, serde_json::Error>
+    pub fn into_concrete<T>(self) -> Result<T, serde_json::Error>
     where
         T: Object + serde::de::DeserializeOwned,
     {

src/primitives/xsd_duration.rs

@@ -165,9 +165,9 @@ fn parse_next(s: &str, c: char) -> Result<(i64, &str), XsdDurationError> {
 impl std::fmt::Display for XsdDuration {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let (s, mut duration) = if chrono::Duration::seconds(0) > self.0 {
-            (format!("P-"), self.0 * -1)
+            ("P-".to_string(), self.0 * -1)
         } else {
-            (format!("P"), self.0)
+            ("P".to_string(), self.0)
         };
 
         let s = if duration.num_days() > 0 {

src/primitives/xsd_string.rs

@@ -45,11 +45,6 @@
 pub struct XsdString(String);
 
 impl XsdString {
-    /// Get an XsdString from an &str
-    pub fn from_str(s: &str) -> Self {
-        s.into()
-    }
-
     /// Get an XsdString from a String
     pub fn from_string(s: String) -> Self {
         s.into()
@@ -61,11 +56,19 @@ impl XsdString {
     }
 
     /// Consume the XsdString and get a String
-    pub fn to_string(self) -> String {
+    pub fn into_string(self) -> String {
         self.into()
     }
 }
 
+impl std::str::FromStr for XsdString {
+    type Err = std::convert::Infallible;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(s.into())
+    }
+}
+
 impl From<String> for XsdString {
     fn from(s: String) -> Self {
         XsdString(s)