Val err details

README.md

@@ -47,7 +47,7 @@ let mut u = Username::new(" valid name \n\n").unwrap();
 assert_eq!(u.get(), "valid name"); // now we're talking!
 
 // This also works for mutations:
-assert!(matches!(u.try_mutate(|u| *u = "   ".to_owned()), Err(prae::ValidationError)));
+assert!(matches!(u.try_mutate(|u| *u = "   ".to_owned()), Err(prae::ValidationError<String>)));
 ```
 
 Now our `Username` trims provided value automatically.

prae/Cargo.toml

@@ -16,5 +16,6 @@ prae_macro = { version = "0.2", path = "../prae_macro" }
 serde = { version = "1.0", optional = true }
 
 [dev-dependencies]
+assert_matches = "1.5"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

prae/src/core.rs

@@ -1,23 +1,45 @@
 use core::hash::Hash;
-use std::fmt;
+use std::{error::Error, fmt};
 use std::ops::{Deref, Index};
 
-/// Default validation error. It is used for [`define!`](prae_macro::define) macro with `ensure`
-/// keyword.
-#[derive(PartialEq)]
-pub struct ValidationError;
-
-impl std::error::Error for ValidationError {}
+/// Used for [`define!`](prae_macro::define) macro with `ensure` keyword.
+#[derive(Clone, Debug)]
+pub struct ValidationError<T> 
+where
+    T: fmt::Debug
+{
+    /// The name of the type where this ValidationError originated.
+    guarded_type_name: &'static str,
+    /// The input value that caused the error.
+    value: T
+}
 
-impl fmt::Debug for ValidationError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(f, "provided value is not valid")
+impl<T> ValidationError<T> 
+where
+    T: fmt::Debug
+{
+    /// Create a new ValidationError with the input value that failed.
+    pub fn new(guarded_type_name: &'static str, value: T) -> Self {
+        ValidationError { guarded_type_name, value }
     }
 }
 
-impl fmt::Display for ValidationError {
+impl<T> Error for ValidationError<T> 
+where
+    T: fmt::Debug
+{}
+
+impl<T> fmt::Display for ValidationError<T> 
+where
+    T: fmt::Debug
+{
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        writeln!(f, "provided value is not valid")
+        write!(
+            f,
+            "failed to create {} from {:?}: provided value is invalid", 
+            self.guarded_type_name, 
+            self.value
+        )
     }
 }
 

prae/src/lib.rs

@@ -38,11 +38,11 @@
 //! assert_eq!(u.get(), "valid name"); // now we're talking!
 //!
 //! // This also works for mutations:
-//! assert!(matches!(u.try_mutate(|u| *u = "   ".to_owned()), Err(prae::ValidationError)));
+//! assert!(matches!(u.try_mutate(|u| *u = "   ".to_owned()), Err(prae::ValidationError::<String> { .. })));
 //! ```
 //! Now our `Username` trims provided value automatically.
 //!
-//! You might noticed that `prae::ValidationError` is returned by default when our
+//! You might noticed that `prae::ValidationError::<String>` is returned by default when our
 //! construction/mutation fails. Altough it's convenient, there are situations when you might
 //! want to return a custom error. And `prae` can help with this:
 //! ```
@@ -79,6 +79,7 @@ pub use prae_macro::define;
 
 #[cfg(test)]
 mod test_deps {
+    use assert_matches as _;
     use serde as _;
     use serde_json as _;
 }

prae/tests/adjust_ensure.rs

@@ -1,3 +1,5 @@
+use assert_matches::assert_matches;
+
 use prae;
 
 prae::define! {
@@ -8,7 +10,10 @@ prae::define! {
 
 #[test]
 fn construction_fails_for_invalid_data() {
-    assert_eq!(Username::new("  ").unwrap_err(), prae::ValidationError);
+    assert_matches!(
+        Username::new("  ").unwrap_err(),
+        prae::ValidationError::<String> { .. }
+    )
 }
 
 #[test]
@@ -20,10 +25,10 @@ fn construction_succeeds_for_valid_data() {
 #[test]
 fn mutation_fails_for_invalid_data() {
     let mut un = Username::new("user").unwrap();
-    assert_eq!(
+    assert_matches!(
         un.try_mutate(|u| *u = "  ".to_owned()).unwrap_err(),
-        prae::ValidationError
-    );
+        prae::ValidationError::<String> { .. }
+    )
 }
 
 #[test]
@@ -38,4 +43,4 @@ fn mutation_succeeds_for_valid_data() {
     let mut un = Username::new("user").unwrap();
     assert!(un.try_mutate(|u| *u = "  new user  ".to_owned()).is_ok());
     assert_eq!(un.get(), "new user");
-}
+}

prae/tests/adjust_validate.rs

@@ -1,6 +1,8 @@
+use assert_matches::assert_matches;
+
 use prae;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct UsernameError;
 
 prae::define! {
@@ -17,7 +19,7 @@ prae::define! {
 
 #[test]
 fn construction_fails_for_invalid_data() {
-    assert_eq!(Username::new("  ").unwrap_err(), UsernameError {});
+    assert_matches!(Username::new("  ").unwrap_err(), UsernameError {});
 }
 
 #[test]
@@ -29,7 +31,7 @@ fn construction_succeeds_for_valid_data() {
 #[test]
 fn mutation_fails_for_invalid_data() {
     let mut un = Username::new("user").unwrap();
-    assert_eq!(
+    assert_matches!(
         un.try_mutate(|u| *u = "  ".to_owned()).unwrap_err(),
         UsernameError {}
     );
@@ -47,4 +49,4 @@ fn mutation_succeeds_for_valid_data() {
     let mut un = Username::new("user").unwrap();
     assert!(un.try_mutate(|u| *u = "  new user  ".to_owned()).is_ok());
     assert_eq!(un.get(), "new user");
-}
+}

prae/tests/ensure.rs

@@ -1,3 +1,5 @@
+use assert_matches::assert_matches;
+
 use prae;
 
 prae::define! {
@@ -7,7 +9,17 @@ prae::define! {
 
 #[test]
 fn construction_fails_for_invalid_data() {
-    assert_eq!(Username::new("").unwrap_err(), prae::ValidationError);
+    assert_matches!(
+        Username::new("").unwrap_err(),
+        prae::ValidationError::<String> { .. }
+    )
+}
+
+#[test]
+fn error_formats_correctly() {
+    let error = Username::new("").unwrap_err();
+    let message = format!("{}", error);
+    assert_eq!(message, "failed to create Username from \"\": provided value is invalid");
 }
 
 #[test]
@@ -19,10 +31,10 @@ fn construction_succeeds_for_valid_data() {
 #[test]
 fn mutation_fails_for_invalid_data() {
     let mut un = Username::new("user").unwrap();
-    assert_eq!(
+    assert_matches!(
         un.try_mutate(|u| *u = "".to_owned()).unwrap_err(),
-        prae::ValidationError
-    );
+        prae::ValidationError::<String> { .. }
+    )
 }
 
 #[test]
@@ -37,4 +49,4 @@ fn mutation_succeeds_for_valid_data() {
     let mut un = Username::new("user").unwrap();
     assert!(un.try_mutate(|u| *u = " new user ".to_owned()).is_ok());
     assert_eq!(un.get(), " new user ");
-}
+}

prae/tests/validate.rs

@@ -1,6 +1,8 @@
+use assert_matches::assert_matches;
+
 use prae;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug)]
 pub struct UsernameError;
 
 prae::define! {
@@ -16,7 +18,7 @@ prae::define! {
 
 #[test]
 fn construction_fails_for_invalid_data() {
-    assert_eq!(Username::new("").unwrap_err(), UsernameError {});
+    assert_matches!(Username::new("").unwrap_err(), UsernameError {});
 }
 
 #[test]
@@ -28,7 +30,7 @@ fn construction_succeeds_for_valid_data() {
 #[test]
 fn mutation_fails_for_invalid_data() {
     let mut un = Username::new("user").unwrap();
-    assert_eq!(
+    assert_matches!(
         un.try_mutate(|u| *u = "".to_owned()).unwrap_err(),
         UsernameError {}
     );
@@ -46,4 +48,4 @@ fn mutation_succeeds_for_valid_data() {
     let mut un = Username::new("user").unwrap();
     assert!(un.try_mutate(|u| *u = " new user ".to_owned()).is_ok());
     assert_eq!(un.get(), " new user ");
-}
+}

prae_macro/src/lib.rs

@@ -34,9 +34,9 @@ pub fn define(input: TokenStream) -> TokenStream {
 
     let validate_fn = match &guard {
         GuardClosure::Ensure(EnsureClosure(closure)) => quote! {
-            fn validate(v: &Self::Target) -> Option<prae::ValidationError> {
+            fn validate(v: &Self::Target) -> Option<prae::ValidationError::<#ty>> {
                 let f: fn(&Self::Target) -> bool = #closure;
-                if f(v) { None } else { Some(prae::ValidationError) }
+                if f(v) { None } else { Some(prae::ValidationError::<#ty>::new(stringify!(#ident), v.clone()) ) }
             }
         },
         GuardClosure::Validate(ValidateClosure(closure, err_ty)) => quote! {
@@ -48,7 +48,7 @@ pub fn define(input: TokenStream) -> TokenStream {
     };
 
     let err_ty = match &guard {
-        GuardClosure::Ensure(_) => quote!(prae::ValidationError),
+        GuardClosure::Ensure(_) => quote!(prae::ValidationError::<#ty>),
         GuardClosure::Validate(ValidateClosure(_, err_ty)) => quote!(#err_ty),
     };