Close #10 - add default_code syntax.

Author: idanarye

CHANGELOG.md

@@ -4,6 +4,11 @@ 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]
+### Added
+- `#[builder(default_code = "...")]` syntax for defaults that cannot be parsed
+  as attributes no matter what.
+
 ## 0.2.0 - 2019-02-06
 ### Changed
 - Upgraded `syn` version to support Rust 2018.

README.md

@@ -22,13 +22,17 @@ struct Foo {
     // Or you can set the default
     #[builder(default=20)]
     z: i32,
+
+    // If the default cannot be parsed, you must encode it as a string:
+    #[builder(default_code="vec![30, 40]")]
+    w: Vec<u32>,
 }
 ```
 
 Build in any order:
 ```rust
-Foo::builder().x(1).y(2).z(3).build();
-Foo::builder().z(1).x(2).y(3).build();
+Foo::builder().x(1).y(2).z(3).w(vec![4, 5]).build();
+Foo::builder().z(1).x(2).w(vec![4, 5]).y(3).build();
 ```
 
 Omit optional fields(the one marked with `#[default]`):

examples/example.rs

@@ -11,25 +11,29 @@ struct Foo {
     #[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,
+
+    // If the default cannot be parsed, you must encode it as a string
+    #[builder(default_code="vec![30, 40]")]
+    w: Vec<u32>,
 }
 
 fn main() {
     assert!(
-        Foo::builder().x(1).y(2).z(3).build()
-        == Foo { x: 1, y: Some(2), z: 3 });
+        Foo::builder().x(1).y(2).z(3).w(vec![4, 5]).build()
+        == Foo { x: 1, y: Some(2), z: 3, w: vec![4, 5] });
 
     // Change the order of construction:
     assert!(
-        Foo::builder().z(1).x(2).y(3).build()
-        == Foo { x: 2, y: Some(3), z: 1 });
+        Foo::builder().z(1).x(2).w(vec![4, 5]).y(3).build()
+        == Foo { x: 2, y: Some(3), z: 1, w: vec![4, 5] });
 
     // Optional fields are optional:
     assert!(
         Foo::builder().x(1).build()
-        == Foo { x: 1, y: None, z: 20 });
+        == Foo { x: 1, y: None, z: 20, w: vec![30, 40] });
 
     // This will not compile - because we did not set x:
     // Foo::builder().build();

src/builder_attr.rs

@@ -48,6 +48,16 @@ impl BuilderAttr {
                         self.default = Some(*assign.right);
                         Ok(())
                     }
+                    "default_code" => {
+                        if let syn::Expr::Lit(syn::ExprLit{lit: syn::Lit::Str(code), ..}) = *assign.right {
+                            use std::str::FromStr;
+                            let tokenized_code = TokenStream::from_str(&code.value())?;
+                            self.default = Some(syn::parse(tokenized_code.into()).map_err(|e| Error::new_spanned(code, format!("{}", e)))?);
+                        } else {
+                            return Err(Error::new_spanned(assign.right, "Expected string"));
+                        }
+                        Ok(())
+                    },
                     _ => {
                         Err(Error::new_spanned(&assign, format!("Unknown parameter {:?}", name)))
                     }

src/lib.rs

@@ -30,22 +30,26 @@
 //!     // Or you can set the default
 //!     #[builder(default=20)]
 //!     z: i32,
+//!
+//!     // If the default cannot be parsed, you must encode it as a string
+//!     #[builder(default_code="vec![30, 40]")]
+//!     w: Vec<u32>,
 //! }
 //!
 //! fn main() {
 //!     assert!(
-//!         Foo::builder().x(1).y(2).z(3).build()
-//!         == Foo { x: 1, y: Some(2), z: 3 });
+//!         Foo::builder().x(1).y(2).z(3).w(vec![4, 5]).build()
+//!         == Foo { x: 1, y: Some(2), z: 3, w: vec![4, 5] });
 //!
 //!     // Change the order of construction:
 //!     assert!(
-//!         Foo::builder().z(1).x(2).y(3).build()
-//!         == Foo { x: 2, y: Some(3), z: 1 });
+//!         Foo::builder().z(1).x(2).w(vec![4, 5]).y(3).build()
+//!         == Foo { x: 2, y: Some(3), z: 1, w: vec![4, 5] });
 //!
 //!     // Optional fields are optional:
 //!     assert!(
 //!         Foo::builder().x(1).build()
-//!         == Foo { x: 1, y: None, z: 20 });
+//!         == Foo { x: 1, y: None, z: 20, w: vec![30, 40] });
 //!
 //!     // This will not compile - because we did not set x:
 //!     // Foo::builder().build();

tests/tests.rs

@@ -54,10 +54,13 @@ fn test_default() {
         x: Option<i32>,
         #[builder(default=10)]
         y: i32,
+        #[builder(default_code="vec![20, 30, 40]")]
+        z: Vec<i32>
     }
 
-    assert!(Foo::builder().build() == Foo { x: None, y: 10 });
-    assert!(Foo::builder().x(1).build() == Foo { x: Some(1), y: 10 });
-    assert!(Foo::builder().y(2).build() == Foo { x: None, y: 2 });
-    assert!(Foo::builder().x(1).y(2).build() == Foo { x: Some(1), y: 2 });
+    assert!(Foo::builder().build() == Foo { x: None, y: 10, z: vec![20, 30, 40] });
+    assert!(Foo::builder().x(1).build() == Foo { x: Some(1), y: 10, z: vec![20, 30, 40] });
+    assert!(Foo::builder().y(2).build() == Foo { x: None, y: 2, z: vec![20, 30, 40] });
+    assert!(Foo::builder().x(1).y(2).build() == Foo { x: Some(1), y: 2, z: vec![20, 30, 40] });
+    assert!(Foo::builder().z(vec![1, 2, 3]).build() == Foo { x: None, y: 10, z: vec![1, 2, 3] });
 }