Cleanup and bump minor version

Author: idanarye

CHANGELOG.md

@@ -4,9 +4,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## 0.2.0 - 2019-02-06
+### Changed
+- Upgraded `syn` version to support Rust 2018.
+- [**BREAKING**] Changed attribute style to `#[builder(...)]`:
+  - `#[default]` -> `#[builder(default)]`
+  - `#[default=...]` -> `#[builder(default=...)]`
+- [**BREAKING**] `default` no longer needs to be a string.
+  - But you need to change your code anyways because the attribute style was changed.
 
 ## 0.1.1 - 2018-07-24
+### Fixed
 - Allow missing docs in structs that derive `TypedBuilder`.
 
 ## 0.1.0 - 2017-10-05

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "typed-builder"
 description = "Compile-time type-checked builder derive"
-version = "0.1.1"
+version = "0.2.0"
 authors = ["IdanArye <[email protected]>"]
 license = "MIT"
 repository = "https://github.com/idanarye/rust-typed-builder"

README.md

@@ -15,12 +15,12 @@ struct Foo {
     // Mandatory Field:
     x: i32,
 
-    // #[default] without parameter - use the type's default
-    #[default]
+    // #[builder(default)] without parameter - use the type's default
+    #[builder(default)]
     y: Option<i32>,
 
-    // Or you can set the default(encoded as string)
-    #[default="20"]
+    // Or you can set the default
+    #[builder(default=20)]
     z: i32,
 }
 ```
@@ -48,7 +48,7 @@ Foo::builder().x(1).y(2).y(3); // y is specified twice
 * All setters are accepting `Into` values.
 * Compile time verification that all fields are set before calling `.build()`.
 * Compile time verification that no field is set more than once.
-* Ability to annotate fields with `#[default]` to make them optional and specify a default value when the user does not set them.
+* Ability to annotate fields with `#[builder(default)]` to make them optional and specify a default value when the user does not set them.
 * Generates simple documentation for the `.builder()` method.
 
 # Limitations

examples/example.rs

@@ -1,6 +1,7 @@
-#[macro_use]
 extern crate typed_builder;
 
+use typed_builder::TypedBuilder;
+
 #[derive(PartialEq, TypedBuilder)]
 struct Foo {
     // Mandatory Field:

src/builder_attr.rs

@@ -4,7 +4,7 @@ use syn::parse::Error;
 use syn::spanned::Spanned;
 use quote::quote;
 
-use util::{expr_to_single_string, path_to_single_string};
+use crate::util::{expr_to_single_string, path_to_single_string};
 
 #[derive(Debug, Default)]
 pub struct BuilderAttr {

src/field_info.rs

@@ -4,8 +4,8 @@ use syn::spanned::Spanned;
 use syn::parse::Error;
 use quote::quote;
 
-use util::{make_identifier, map_only_one, path_to_single_string, ident_to_type};
-use builder_attr::BuilderAttr;
+use crate::util::{make_identifier, map_only_one, path_to_single_string, ident_to_type};
+use crate::builder_attr::BuilderAttr;
 
 #[derive(Debug)]
 pub struct FieldInfo<'a> {
@@ -47,7 +47,6 @@ impl<'a> FieldInfo<'a> {
     }
 
     pub fn type_param(&self) -> syn::TypeParam {
-        // syn::TypeParam::Type(self.generic_ident.clone().into())
         self.generic_ident.clone().into()
     }
 
@@ -64,15 +63,4 @@ impl<'a> FieldInfo<'a> {
             elems: types,
         }.into()
     }
-
-    pub fn empty_type() -> syn::Type {
-        syn::TypeTuple {
-            paren_token: Default::default(),
-            elems: Default::default(),
-        }.into()
-    }
-
-    pub fn empty_ty_param() -> syn::TypeParam {
-        syn::TypeParam::from(syn::Ident::new("x", proc_macro2::Span::call_site()))
-    }
 }

src/lib.rs

@@ -9,9 +9,8 @@
 //!
 //! Trying to set the same fields twice will generate a compile-time error. Trying to build without
 //! setting one of the fields will also generate a compile-time error - unless that field is marked
-//! as `#[default]`, in which case the `::default()` value of it's type will be picked. If you want
-//! to set a different default, use `#[default="..."]` - note that it has to be encoded in a
-//! string, so `1` is `#[default="1"]` and `"hello"` is `#[default="\"hello\""]`.
+//! as `#[builder(default)]`, in which case the `::default()` value of it's type will be picked. If
+//! you want to set a different default, use `#[builder(default=...)]`.
 //!
 //! # Examples
 //!
@@ -28,7 +27,7 @@
 //!     #[builder(default)]
 //!     y: Option<i32>,
 //!
-//!     // Or you can set the default(encoded as string)
+//!     // Or you can set the default
 //!     #[builder(default=20)]
 //!     z: i32,
 //! }
@@ -99,20 +98,11 @@ fn impl_my_derive(ast: &syn::DeriveInput) -> Result<TokenStream, Error> {
                 syn::Fields::Named(fields) => {
                     let struct_info = struct_info::StructInfo::new(&ast, fields.named.iter())?;
                     let builder_creation = struct_info.builder_creation_impl()?;
-                    // println!("builder_creation\n==============\n{}\n==============", builder_creation);
                     let conversion_helper = struct_info.conversion_helper_impl()?;
-                    // println!("conversion_helper\n==============\n{}\n==============", conversion_helper);
                     let fields = struct_info.fields.iter().map(|f| struct_info.field_impl(f).unwrap());
-                    // for field in fields {
-                        // println!("field\n==============\n{}\n==============", quote!(#field));
-                    // }
                     let fields = quote!(#(#fields)*);
-                    // println!("Fields be {}", fields);
-                    // println!("fields\n==============\n{}\n==============", fields);
                     let build_method = struct_info.build_method_impl();
 
-                    // eprintln!("===\n{}\n===", builder_creation);
-                    // println!("{}", builder_creation);
                     quote!{
                         #builder_creation
                         #conversion_helper
@@ -126,45 +116,6 @@ fn impl_my_derive(ast: &syn::DeriveInput) -> Result<TokenStream, Error> {
         }
         syn::Data::Enum(_) => return Err(Error::new(ast.span(), "SmartBuilder is not supported for enums")),
         syn::Data::Union(_) => return Err(Error::new(ast.span(), "SmartBuilder is not supported for unions")),
-        // syn::Data::Struct(syn::VariantData::Struct(ref body)) => {
-            // let struct_info = struct_info::StructInfo::new(&ast, body);
-            // let builder_creation = struct_info.builder_creation_impl();
-            // let conversion_helper = struct_info.conversion_helper_impl();
-            // let fields = struct_info.fields.iter().map(|f| struct_info.field_impl(f));
-            // let build_method = struct_info.build_method_impl();
-            // quote!{
-                // #builder_creation
-                // #conversion_helper
-                // #( #fields )*
-                // #build_method
-            // }
-        // },
-        // syn::Data::Struct(syn::VariantData::Unit) => panic!("SmartBuilder is not supported for unit types"),
-        // syn::Data::Struct(syn::VariantData::Tuple(_)) => panic!("SmartBuilder is not supported for tuples"),
-        // syn::Data::Enum(_) => panic!("SmartBuilder is not supported for enums"),
     };
-    // println!("{}", data);
     Ok(data)
-    // Ok(quote!())
 }
-// fn impl_my_derive(ast: &syn::DeriveInput) -> TokenStream {
-
-    // match ast.body {
-        // syn::Body::Struct(syn::VariantData::Struct(ref body)) => {
-            // let struct_info = struct_info::StructInfo::new(&ast, body);
-            // let builder_creation = struct_info.builder_creation_impl();
-            // let conversion_helper = struct_info.conversion_helper_impl();
-            // let fields = struct_info.fields.iter().map(|f| struct_info.field_impl(f));
-            // let build_method = struct_info.build_method_impl();
-            // quote!{
-                // #builder_creation
-                // #conversion_helper
-                // #( #fields )*
-                // #build_method
-            // }
-        // },
-        // syn::Body::Struct(syn::VariantData::Unit) => panic!("SmartBuilder is not supported for unit types"),
-        // syn::Body::Struct(syn::VariantData::Tuple(_)) => panic!("SmartBuilder is not supported for tuples"),
-        // syn::Body::Enum(_) => panic!("SmartBuilder is not supported for enums"),
-    // }
-// }

src/struct_info.rs

@@ -5,8 +5,8 @@ use syn::parse::Error;
 use syn::spanned::Spanned;
 use quote::{quote, ToTokens};
 
-use field_info::FieldInfo;
-use util::{make_identifier, empty_type, make_punctuated_single, modify_types_generics_hack};
+use crate::field_info::FieldInfo;
+use crate::util::{make_identifier, empty_type, make_punctuated_single, modify_types_generics_hack};
 
 #[derive(Debug)]
 pub struct StructInfo<'a> {
@@ -41,18 +41,15 @@ impl<'a> StructInfo<'a> {
 
     pub fn builder_creation_impl(&self) -> Result<TokenStream, Error> {
         let modif = self.modify_generics(|g| g.params.push(self.fields[0].generic_ty_param()));
-        // println!("modif {:?}", modif);
         let init_empties = {
             let names = self.fields.iter().map(|f| f.name);
             quote!(#( #names: () ),*)
         };
-        // println!("empties {}", init_empties);
         let builder_generics = {
             let names = self.fields.iter().map(|f| f.name);
             let generic_idents = self.fields.iter().map(|f| &f.generic_ident);
             quote!(#( #names: #generic_idents ),*)
         };
-        // println!("builder_generics {}", builder_generics);
         let StructInfo { ref vis, ref name, ref builder_name, .. } = *self;
         let (impl_generics, ty_generics, where_clause) = self.generics.split_for_impl();
         let b_generics = self.modify_generics(|g| {
@@ -62,17 +59,9 @@ impl<'a> StructInfo<'a> {
         });
         let generics_with_empty = modify_types_generics_hack(&ty_generics, |args| {
             for _ in self.fields.iter() {
-                args.push(syn::GenericArgument::Type(FieldInfo::empty_type()));
+                args.push(syn::GenericArgument::Type(empty_type()));
             }
         });
-        // println!("b_generics {:?}", b_generics);
-        // let generics_with_empty = self.modify_generics(|g| {
-            // for _ in self.fields.iter() {
-                // g.params.push(FieldInfo::empty_ty_param().into());
-            // }
-        // });
-        // let (_, generics_with_empty, _) = generics_with_empty.split_for_impl();
-        // println!("generics_with_empty {:?}", generics_with_empty);
         let phantom_generics = self.generics.params.iter().map(|param| {
             match param {
                 syn::GenericParam::Lifetime(lifetime) => quote!(&#lifetime ()),
@@ -85,12 +74,6 @@ impl<'a> StructInfo<'a> {
                     quote!(#cnst)
                 },
             }
-            // let lifetimes = self.generics.lifetimes().map(|l| &l.lifetime);
-            // let types = self.generics.params.clone();//.iter().map(|t| &t.ident);
-            // quote!{
-                // #( ::std::marker::PhantomData<&#lifetimes ()>, )*
-                // #( ::std::marker::PhantomData<#types>, )*
-            // }
         });
         let doc = self.builder_doc();
         Ok(quote! {
@@ -233,7 +216,6 @@ impl<'a> StructInfo<'a> {
                             ident: self.conversion_helper_trait_name.clone(),
                             arguments: syn::PathArguments::AngleBracketed(
                                 syn::AngleBracketedGenericArguments{
-                                    // colon2_token: Some(Default::default()),
                                     colon2_token: None,
                                     lt_token: Default::default(),
                                     args: make_punctuated_single(syn::GenericArgument::Type(field.ty.clone())),

src/util.rs

@@ -8,7 +8,7 @@ pub fn make_identifier(kind: &str, name: &syn::Ident) -> syn::Ident {
     syn::Ident::new(&format!("TypedBuilder_{}_{}", kind, name), proc_macro2::Span::call_site())
 }
 
-// Panic if there is more than one.
+// Returns error if there is more than one.
 pub fn map_only_one<S, T, F>(iter: &[S], dlg: F) -> Result<Option<T>, Error>
 where F: Fn(&S) -> Result<Option<T>, Error>,
       S: Spanned,

tests/tests.rs

@@ -1,6 +1,7 @@
-#[macro_use]
 extern crate typed_builder;
 
+use typed_builder::TypedBuilder;
+
 #[test]
 fn test_simple() {
     #[derive(PartialEq, TypedBuilder)]