Implemented a new constructor for Error: from_err() (#126)

* Implemented a new constructor for Error: from_err(). from_err() chains another error as the cause of Error

* Added a test.

* Renamed Error::from_err to Error::with_chain, with_chain now takes Into<ErrorKind> instead of ErrorKind.

* Updated changelog.

* Moved the bounds to where clauses.

Author: golddranks

CHANGELOG.md

@@ -1,5 +1,7 @@
 # Unreleased
 
+- [Add a new constructor for `Error`: `with_chain`.](https://github.com/brson/error-chain/pull/126)
+
 # 0.9.0
 
 - Revert [Add a `Sync` bound to errors](https://github.com/brson/error-chain/pull/110)

src/error_chain.rs

@@ -84,6 +84,14 @@ macro_rules! error_chain_processed {
                 Self::from_kind(kind)
             }
 
+            fn with_chain<E, K>(error: E, kind: K)
+                -> Self
+                where E: ::std::error::Error + Send + 'static,
+                      K: Into<Self::ErrorKind>
+            {
+                Self::with_chain(error, kind)
+            }
+
             fn kind(&self) -> &Self::ErrorKind {
                 self.kind()
             }
@@ -111,6 +119,18 @@ macro_rules! error_chain_processed {
                 )
             }
 
+            /// Constructs a chained error from another error and a kind, and generates a backtrace.
+            pub fn with_chain<E, K>(error: E, kind: K)
+                -> $error_name
+                where E: ::std::error::Error + Send + 'static,
+                      K: Into<$error_kind_name>
+            {
+                $error_name(
+                    kind.into(),
+                    $crate::State::new::<$error_name>(Box::new(error), ),
+                )
+            }
+
             /// Returns the kind of the error.
             pub fn kind(&self) -> &$error_kind_name {
                 &self.0

src/lib.rs

@@ -424,6 +424,12 @@ pub trait ChainedError: error::Error + Send + 'static {
     /// Constructs an error from a kind, and generates a backtrace.
     fn from_kind(kind: Self::ErrorKind) -> Self where Self: Sized;
 
+    /// Constructs a chained error from another error and a kind, and generates a backtrace.
+    fn with_chain<E, K>(error: E, kind: K) -> Self
+        where Self: Sized,
+              E: ::std::error::Error + Send + 'static,
+              K: Into<Self::ErrorKind>;
+
     /// Returns the kind of the error.
     fn kind(&self) -> &Self::ErrorKind;
 

tests/tests.rs

@@ -541,3 +541,40 @@ fn types_declarations() {
 
     let _: MyResult<()> = Ok(());
 }
+
+#[test]
+/// Calling chain_err over a `Result` containing an error to get a chained error
+//// and constructing a MyError directly, passing it an error should be equivalent.
+fn rewrapping() {
+
+    use std::env::VarError::{self, NotPresent, NotUnicode};
+
+    error_chain! {
+        foreign_links {
+            VarErr(VarError);
+        }
+
+        types {
+            MyError, MyErrorKind, MyResultExt, MyResult;
+        }
+    }
+
+    let result_a_from_func: Result<String, _> = Err(VarError::NotPresent);
+    let result_b_from_func: Result<String, _> = Err(VarError::NotPresent);
+
+    let our_error_a = result_a_from_func.map_err(|e| match e {
+        NotPresent => MyError::with_chain(e, "env var wasn't provided"),
+        NotUnicode(_) => MyError::with_chain(e, "env var was bork文字化ã"),
+    });
+
+    let our_error_b = result_b_from_func.or_else(|e| match e {
+        NotPresent => Err(e).chain_err(|| "env var wasn't provided"),
+        NotUnicode(_) => Err(e).chain_err(|| "env var was bork文字化ã"),
+    });
+
+    assert_eq!(
+        format!("{}", our_error_a.unwrap_err()),
+        format!("{}", our_error_b.unwrap_err())
+    );
+
+}