Add try_setter option and generate appropriate methods

.travis.yml

@@ -10,7 +10,7 @@ matrix:
     - rust: 1.15.0
       env: JOB=build CARGO_FEATURES="struct_default"
     - rust: nightly
-      env: JOB=build CARGO_FEATURES="compiletests logging"
+      env: JOB=build CARGO_FEATURES="nightlytests logging"
     - rust: nightly
       env: JOB=style_check
   allow_failures:

derive_builder/CHANGELOG.md

@@ -2,6 +2,16 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [0.4.3] - 2017-04-13
+
+### Added
+- try_setters, e.g. `#[builder(try_setter)]`. These setters are exposed alongside the
+  normal field setters and allow callers to pass in values which have fallible 
+  conversions to the needed type through `TryInto`. This attribute can be used on any 
+  Rust channel, but will only emit setters on nightly when `#![feature(try_from)]` is 
+  declared in the consuming crate's root; this will change when Rust issue 
+  [#33417](https://github.com/rust-lang/rust/issues/33417) is resolved.
+
 ## [0.4.2] - 2017-04-10
 
 ### Fixed

derive_builder/Cargo.toml

@@ -25,7 +25,6 @@ proc-macro = true
 logging = [ "log", "env_logger", "derive_builder_core/logging" ]
 struct_default = []
 skeptic_tests = ["skeptic"]
-try_setter = []
 
 [dependencies]
 syn = "0.11"

derive_builder/examples/try_setter.rs

@@ -0,0 +1,52 @@
+//! This example illustrates the use of try-setters.
+#![feature(try_from)]
+
+#[macro_use]
+extern crate derive_builder;
+
+use std::convert::{From, TryFrom};
+use std::net::{IpAddr, AddrParseError};
+use std::str::FromStr;
+use std::string::ToString;
+
+/// Temporary newtype hack around lack of TryFrom implementations
+/// in std. The rust-lang issue on the subject says that there will be a
+/// blanket impl for everything that currently implements FromStr, which
+/// will make this feature much more useful for input validation.
+#[derive(Debug, Clone, PartialEq)]
+pub struct MyAddr(IpAddr);
+
+impl From<IpAddr> for MyAddr {
+    fn from(v: IpAddr) -> Self {
+        MyAddr(v)
+    }
+}
+
+impl<'a> TryFrom<&'a str> for MyAddr {
+    type Err = AddrParseError;
+
+    fn try_from(v: &str) -> Result<Self, AddrParseError> {
+        Ok(MyAddr(IpAddr::from_str(v)?))
+    }
+}
+
+#[derive(Builder, Debug, PartialEq)]
+#[builder(try_setter, setter(into))]
+struct Lorem {
+    pub name: String,
+    pub addr: MyAddr,
+}
+
+fn main() {
+    create("Jane", "1.2.3.4").unwrap();
+    create("Bobby", "").unwrap_err();
+}
+
+fn create(name: &str, addr: &str) -> Result<Lorem, String> {
+    // Fallible and infallible setters can be mixed freely when using
+    // the mutable builder pattern.
+    LoremBuilder::default()
+        .name(name)
+        .try_addr(addr).map_err(|e| e.to_string())?
+        .build()
+}

derive_builder/src/lib.rs

@@ -216,6 +216,31 @@
 //! }
 //! ```
 //!
+//! ## Fallible Setters
+//!
+//! Alongside the normal setter methods, you can expose fallible setters which are generic over
+//! the `TryInto` trait. TryInto is a not-yet-stable trait 
+//! (see rust-lang issue [#33417](https://github.com/rust-lang/rust/issues/33417)) similar to
+//! `Into` with the key distinction that the conversion can fail, and therefore produces a `Result`.
+//! 
+//! You can declare the `try_setter` attribute today, and your builder will work on stable Rust -
+//! the fallible setters will automatically light up in future when the `try_from` feature is
+//! stabilized.
+//!
+//!
+//! ```rust,ignore
+//! # #[macro_use]
+//! # extern crate derive_builder;
+//! #
+//! #[derive(Builder, Debug, PartialEq)]
+//! #[builder(try_setter, setter(into))]
+//! struct Lorem {
+//!     pub ipsum: u8,
+//! }
+//! ```
+//!
+//! A complete example of using fallible setters is available in `examples/try_setter.rs`.
+//!
 //! ## Default Values
 //!
 //! You can define default values for each field via annotation by `#[builder(default="...")]`,
@@ -366,6 +391,9 @@
 //! - If derive_builder depends on your crate, and vice versa, then a cyclic
 //!   dependency would occur. To break it you could try to depend on the
 //!   [`derive_builder_core`] crate instead.
+//! - The `try_setter` attribute and `owned` builder pattern are not compatible in practice;
+//!   an error during building will consume the builder, making it impossible to continue
+//!   construction.
 //!
 //! ## Debugging Info
 //!

derive_builder_core/src/setter.rs

@@ -131,9 +131,9 @@ impl<'a> ToTokens for Setter<'a> {
                     #vis fn #try_ident #try_ty_params (#self_param, value: VALUE)
                         -> #result<#return_ty, VALUE::Err>
                     {
-                        let value : #ty = value.try_into()?;
+                        let converted : #ty = value.try_into()?;
                         let mut new = #self_into_return_ty;
-                        new.#field_ident = #option::Some(value);
+                        new.#field_ident = #option::Some(converted);
                         Ok(new)
                 }));
             } else {
@@ -244,7 +244,7 @@ mod tests {
         ));
     }
 
-    // including
+    // including try_setter
     #[test]
     fn full() {
         let attrs = vec![syn::parse_outer_attr("#[some_attr]").unwrap()];
@@ -256,14 +256,36 @@ mod tests {
         setter.attrs = attrs.as_slice();
         setter.generic_into = true;
         setter.deprecation_notes = &deprecated;
+        setter.try_setter = true;
+
+        // Had to hoist these out to avoid a recursion limit in the quote!
+        // macro invocation below.
+        let action = quote!(
+            let mut new = self;
+            new.foo = ::std::option::Option::Some(value.into());
+            new
+        );
+
+        let try_action = quote!(
+            let converted : Foo = value.try_into()?;
+            let mut new = self;
+            new.foo = ::std::option::Option::Some(converted);
+            Ok(new)
+        );
+
+        println!("{}", quote!(#setter));
 
         assert_eq!(quote!(#setter), quote!(
             #[some_attr]
             pub fn foo <VALUE: ::std::convert::Into<Foo>>(&mut self, value: VALUE) -> &mut Self {
                 #deprecated
-                let mut new = self;
-                new.foo = ::std::option::Option::Some(value.into());
-                new
+                #action
+            }
+
+            #[some_attr]
+            pub fn try_foo<VALUE: ::std::convert::TryInto<Foo>>(&mut self, value: VALUE) 
+                -> ::std::result::Result<&mut Self, VALUE::Err> {
+                #try_action
             }
         ));
     }
@@ -305,4 +327,36 @@ mod tests {
 
         assert_eq!(quote!(#setter), quote!());
     }
+
+    #[test]
+    fn try_setter() {
+        let mut setter : Setter = default_setter!();
+        setter.pattern = BuilderPattern::Mutable;
+        setter.try_setter = true;
+
+        let setter_quote = quote!(
+            pub fn foo(&mut self, value: Foo) -> &mut Self {
+                let mut new = self;
+                new.foo = ::std::option::Option::Some(value);
+                new
+            }
+        );
+
+        // hoisting necessary to avoid recursion limit.
+        let try_setter_body = quote!(
+            let converted : Foo = value.try_into()?;
+            let mut new = self;
+            new.foo = ::std::option::Option::Some(converted);
+            Ok(new)
+        );
+
+        assert_eq!(quote!(#setter), quote!(
+            #setter_quote
+
+            pub fn try_foo<VALUE: ::std::convert::TryInto<Foo>>(&mut self, value: VALUE) 
+                -> ::std::result::Result<&mut Self, VALUE::Err> {
+                #try_setter_body
+            }
+        ));
+    }
 }

derive_builder_test/Cargo.toml

@@ -9,7 +9,7 @@ publish = false
 path = "src/lib.rs"
 
 [features]
-compiletests = ["compiletest_rs"]
+nightlytests = ["compiletest_rs"]
 logging = [ "derive_builder/logging" ]
 struct_default = [ "derive_builder/struct_default" ]
 

derive_builder_test/tests/compiletests.rs

@@ -1,4 +1,4 @@
-#![cfg(feature = "compiletests")]
+#![cfg(feature = "nightlytests")]
 extern crate compiletest_rs as compiletest;
 
 // note:

derive_builder/tests/try_setter.rs → derive_builder_test/tests/run-pass/try_setter.rs

@@ -1,11 +1,11 @@
-#![cfg_attr(feature = "try_setter", feature(try_from))]
+#![cfg_attr(feature = "nightlytests", feature(try_from))]
 
 #[macro_use]
 extern crate derive_builder;
 
 #[allow(unused_imports)]
 mod struct_level {
-    #[cfg(feature = "try_setter")]
+    #[cfg(feature = "try_from")]
     use std::convert::TryFrom;
 
     use std::net::{IpAddr, AddrParseError};
@@ -21,7 +21,7 @@ mod struct_level {
         }
     }
 
-    #[cfg(feature = "try_setter")]
+    #[cfg(feature = "nightlytests")]
     impl<'a> TryFrom<&'a str> for MyAddr {
         type Err = AddrParseError;
 
@@ -39,11 +39,14 @@ mod struct_level {
 
     #[test]
     fn infallible_set() {
-        let _ = LoremBuilder::default().source(IpAddr::from_str("1.2.3.4").unwrap()).build();
+        let _ = LoremBuilder::default()
+            .source(IpAddr::from_str("1.2.3.4").unwrap())
+            .dest(IpAddr::from_str("0.0.0.0").unwrap())
+            .build();
     }
 
     #[test]
-    #[cfg(feature = "try_setter")]
+    #[cfg(feature = "nightlytests")]
     fn fallible_set() {
         let mut builder = LoremBuilder::default();
         let try_result = builder.try_source("1.2.3.4");
@@ -55,15 +58,15 @@ mod struct_level {
     }
 
     // Allow dead code here since the test that uses this depends on the try_setter feature.
-    #[cfg_attr(not(feature = "try_setter"), allow(dead_code))]
+    #[cfg_attr(not(feature = "nightlytests"), allow(dead_code))]
     fn exact_helper() -> Result<Lorem, String> {
         LoremBuilder::default()
             .source(IpAddr::from_str("1.2.3.4").unwrap())
             .dest(IpAddr::from_str("0.0.0.0").unwrap())
             .build()
     }
 
-    #[cfg(feature = "try_setter")]
+    #[cfg(feature = "nightlytests")]
     fn try_helper() -> Result<Lorem, String> {
         LoremBuilder::default()
             .try_source("1.2.3.4").map_err(|e| e.to_string())?
@@ -72,7 +75,7 @@ mod struct_level {
     }
 
     #[test]
-    #[cfg(feature = "try_setter")]
+    #[cfg(feature = "nightlytests")]
     fn with_helper() {
         assert_eq!(exact_helper().unwrap(), try_helper().unwrap());
     }