Ran rustfmt on the whole tree and added a note about compatibility (#44)

* Ran rustfmt on the whole tree and added a note about compatibility

* Removing a doc-comment

.travis.yml

@@ -3,6 +3,7 @@ rust:
   - stable
   - beta
   - nightly
+  - 1.26.0
 matrix:
   allow_failures:
     - rust: nightly

README.md

@@ -7,6 +7,12 @@
 Strum is a set of macros and traits for working with
 enums and strings easier in Rust.
 
+# Compatibility
+
+Strum is compatible with versions of rustc >= 1.26.0. That's the earliest version of stable rust that supports
+impl trait. Pull Requests that improve compatibility with older versions are welcome, but new feature work
+will focus on the current version of rust with an effort to avoid breaking compatibility with older versions.
+
 # Including Strum in Your Project
 
 Import strum and strum_macros into your project by adding the following lines to your
@@ -14,8 +20,8 @@ Cargo.toml. Strum_macros contains the macros needed to derive all the traits in
 
 ```toml
 [dependencies]
-strum = "0.13.0"
+strum = "0.14.0"
-strum_macros = "0.13.0"
+strum_macros = "0.14.0"
 ```
 
 And add these lines to the root of your project, either lib.rs or main.rs.

strum/Cargo.toml

@@ -13,7 +13,7 @@ homepage = "https://github.com/Peternator7/strum"
 readme = "../README.md"
 
 [dev-dependencies]
-strum_macros = { path = "../strum_macros", version = "0.13.0" }
+strum_macros = { path = "../strum_macros", version = "0.14.0" }
 
 [badges]
 travis-ci = { repository = "Peternator7/strum" }

strum_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strum_macros"
-version = "0.13.0"
+version = "0.14.0"
 authors = ["Peter Glotfelty <peglotfe@microsoft.com>"]
 license = "MIT"
 

strum_macros/src/enum_count.rs

@@ -6,6 +6,7 @@ pub(crate) fn enum_count_inner(ast: &syn::DeriveInput) -> TokenStream {
         syn::Data::Enum(ref v) => v.variants.len(),
         _ => panic!("EnumCount can only be used with enums"),
     };
+
     // Used in the quasi-quotation below as `#name`
     let name = &ast.ident;
     let const_name = &syn::Ident::new(
@@ -17,7 +18,7 @@ pub(crate) fn enum_count_inner(ast: &syn::DeriveInput) -> TokenStream {
     let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
 
     quote! {
-            // The generated impl
+            // Implementation
             impl #impl_generics ::strum::EnumCount for #name #ty_generics #where_clause {
                 fn count() -> usize {
                     #n

strum_macros/src/enum_discriminants.rs

@@ -19,6 +19,7 @@ pub fn enum_discriminants_inner(ast: &syn::DeriveInput) -> TokenStream {
     let discriminant_attrs = get_meta_list(type_meta.iter(), "strum_discriminants")
         .flat_map(|meta| extract_list_metas(meta).collect::<Vec<_>>())
         .collect::<Vec<&syn::Meta>>();
+
     let derives = get_meta_list(discriminant_attrs.iter().map(|&m| m), "derive")
         .flat_map(extract_list_metas)
         .filter_map(get_meta_ident)
@@ -44,7 +45,8 @@ pub fn enum_discriminants_inner(ast: &syn::DeriveInput) -> TokenStream {
         filter_metas(discriminant_attrs.iter().map(|&m| m), |meta| match meta {
             syn::Meta::List(ref metalist) => metalist.ident != "derive" && metalist.ident != "name",
             _ => true,
-        }).map(|meta| quote! { #[ #meta ] })
+        })
+        .map(|meta| quote! { #[ #meta ] })
         .collect::<Vec<_>>();
 
     // Add the variants without fields, but exclude the `strum` meta item
@@ -99,7 +101,8 @@ pub fn enum_discriminants_inner(ast: &syn::DeriveInput) -> TokenStream {
             };
 
             quote! { #name::#ident #params => #discriminants_name::#ident }
-        }).collect::<Vec<_>>();
+        })
+        .collect::<Vec<_>>();
     let from_fn_body = quote! { match val { #(#arms),* } };
 
     let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();

strum_macros/src/enum_properties.rs

@@ -20,7 +20,8 @@ fn extract_properties(meta: &[Meta]) -> Vec<(&syn::Ident, &syn::Lit)> {
                 }
             }
             _ => None,
-        }).flat_map(|prop| prop)
+        })
+        .flat_map(|prop| prop)
         .filter_map(|prop| match *prop {
             NestedMeta::Meta(Meta::List(MetaList {
                 ref ident,
@@ -34,14 +35,16 @@ fn extract_properties(meta: &[Meta]) -> Vec<(&syn::Ident, &syn::Lit)> {
                 }
             }
             _ => None,
-        }).flat_map(|prop| prop)
+        })
+        .flat_map(|prop| prop)
         // Only look at key value pairs
         .filter_map(|prop| match *prop {
             NestedMeta::Meta(Meta::NameValue(MetaNameValue {
                 ref ident, ref lit, ..
             })) => Some((ident, lit)),
             _ => None,
-        }).collect()
+        })
+        .collect()
 }
 
 pub fn enum_properties_inner(ast: &syn::DeriveInput) -> TokenStream {

strum_macros/src/helpers.rs

@@ -107,7 +107,8 @@ pub fn extract_attrs(meta: &[Meta], attr: &str, prop: &str) -> Vec<String> {
                 }
             }
             _ => None,
-        }).flat_map(|nested| nested)
+        })
+        .flat_map(|nested| nested)
         // Get all the inner elements as long as they start with ser.
         .filter_map(|meta| match *meta {
             NestedMeta::Meta(Meta::NameValue(MetaNameValue {
@@ -122,7 +123,8 @@ pub fn extract_attrs(meta: &[Meta], attr: &str, prop: &str) -> Vec<String> {
                 }
             }
             _ => None,
-        }).collect()
+        })
+        .collect()
 }
 
 pub fn unique_attr(attrs: &[Meta], attr: &str, prop: &str) -> Option<String> {

strum_tests/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "strum_tests"
-version = "0.13.0"
+version = "0.14.0"
 authors = ["Peter Glotfelty <peglotfe@microsoft.com>"]
 
 [dependencies]

strum_tests/src/lib.rs

@@ -1 +1,17 @@
+extern crate strum;
+#[macro_use]
+extern crate strum_macros;
 
+#[allow(dead_code)]
+#[derive(Debug, Eq, PartialEq, EnumString, ToString, EnumCount, EnumDiscriminants)]
+pub enum Color {
+    /// Docs on red
+    #[strum(to_string = "RedRed")]
+    Red,
+    #[strum(serialize = "b", to_string = "blue")]
+    Blue { hue: usize },
+    #[strum(serialize = "y", serialize = "yellow")]
+    Yellow,
+    #[strum(disabled = "true")]
+    Green(String),
+}

strum_tests/src/main.rs

@@ -3,8 +3,9 @@ extern crate strum;
 extern crate strum_macros;
 
 #[allow(dead_code)]
-#[derive(Debug, Eq, PartialEq, EnumString, ToString)]
+#[derive(Debug, Eq, PartialEq, EnumString, ToString, EnumCount, EnumDiscriminants)]
 enum Color {
+    /// Random Docs
     #[strum(to_string = "RedRed")]
     Red,
     #[strum(serialize = "b", to_string = "blue")]

strum_tests/tests/enum_discriminants.rs

@@ -124,7 +124,7 @@ fn split_attributes_test() {
 #[strum_discriminants(
     name(PassThroughBoo),
     derive(Display, EnumIter, EnumString),
-    strum(serialize_all = "snake_case"),
+    strum(serialize_all = "snake_case")
 )]
 enum PassThrough {
     DarkBlack(bool),
@@ -168,7 +168,7 @@ fn from_ref_test() {
 struct Rara;
 
 #[derive(Debug, Eq, PartialEq, EnumDiscriminants)]
-#[strum_discriminants(name(EnumIntoComplexVars),)]
+#[strum_discriminants(name(EnumIntoComplexVars))]
 enum EnumIntoComplex<'a, T: 'a> {
     A(&'a T),
 }