update: changed source field of Err to use Option (#9)

Author: sttk

src/errs.rs

@@ -14,7 +14,7 @@ use std::ptr;
 /// the error.
 pub struct Err {
     reason_container: ptr::NonNull<ReasonContainer>,
-    source: Box<dyn error::Error>,
+    source: Option<Box<dyn error::Error>>,
 }
 
 impl Err {
@@ -38,7 +38,7 @@ impl Err {
         let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<ReasonContainer>();
         Self {
             reason_container: ptr,
-            source: Box::new(NoSource {}),
+            source: None,
         }
     }
 
@@ -67,7 +67,7 @@ impl Err {
         let ptr = ptr::NonNull::from(Box::leak(boxed)).cast::<ReasonContainer>();
         Self {
             reason_container: ptr,
-            source: Box::new(source),
+            source: Some(Box::new(source)),
         }
     }
 
@@ -194,10 +194,7 @@ impl fmt::Display for Err {
 
 impl error::Error for Err {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
-        match self.source.downcast_ref::<NoSource>() {
-            Some(_) => None,
-            None => Some(&(*self.source)),
-        }
+        self.source.as_deref()
     }
 }
 
@@ -267,17 +264,6 @@ where
     any::TypeId::of::<R>() == type_id
 }
 
-#[derive(Debug)]
-struct NoSource {}
-
-impl error::Error for NoSource {}
-
-impl fmt::Display for NoSource {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        Ok(())
-    }
-}
-
 #[cfg(test)]
 mod tests_of_err_without_source {
     use super::*;

tests/errs_test.rs

@@ -1,11 +1,13 @@
 #[cfg(test)]
 mod integration_tests_of_err {
     use sabi;
+    use std::error::Error;
 
     #[derive(Debug)]
     enum IoErrs {
         FileNotFound { path: String },
         NoPermission { path: String, r#mod: (u8, u8, u8) },
+        DueToSomeError { path: String },
     }
 
     fn find_file() -> Result<(), sabi::Err> {
@@ -15,14 +17,21 @@ mod integration_tests_of_err {
         Err(err)
     }
 
-    fn write_file() -> Result<(), sabi::Err> {
+    fn read_file() -> Result<(), sabi::Err> {
         let err = sabi::Err::new(IoErrs::NoPermission {
             path: "/aaa/bbb/ccc".to_string(),
-            r#mod: (6, 6, 6),
+            r#mod: (4, 4, 4),
         });
         Err(err)
     }
 
+    fn write_file() -> Result<(), sabi::Err> {
+        let path = "/aaa/bbb/ccc".to_string();
+        let source = std::io::Error::new(std::io::ErrorKind::AlreadyExists, path.clone());
+        let err = sabi::Err::with_source(IoErrs::DueToSomeError { path }, source);
+        Err(err)
+    }
+
     #[test]
     fn should_create_err_and_identify_reason() {
         match find_file() {
@@ -31,21 +40,43 @@ mod integration_tests_of_err {
                 Ok(r) => match r {
                     IoErrs::FileNotFound { path } => {
                         assert_eq!(path, "/aaa/bbb/ccc");
+                        assert!(err.source().is_none());
                     }
                     IoErrs::NoPermission { path: _, r#mod: _ } => panic!(),
+                    IoErrs::DueToSomeError { path: _ } => panic!(),
                 },
                 _ => panic!(),
             },
         }
 
-        match write_file() {
+        match read_file() {
             Ok(_) => panic!(),
             Err(err) => match err.reason::<IoErrs>() {
                 Ok(r) => match r {
                     IoErrs::FileNotFound { path: _ } => panic!(),
                     IoErrs::NoPermission { path, r#mod } => {
                         assert_eq!(path, "/aaa/bbb/ccc");
-                        assert_eq!(*r#mod, (6, 6, 6));
+                        assert_eq!(*r#mod, (4, 4, 4));
+                        assert!(err.source().is_none());
+                    }
+                    IoErrs::DueToSomeError { path: _ } => panic!(),
+                },
+                _ => panic!(),
+            },
+        }
+
+        match write_file() {
+            Ok(_) => panic!(),
+            Err(err) => match err.reason::<IoErrs>() {
+                Ok(r) => match r {
+                    IoErrs::FileNotFound { path: _ } => panic!(),
+                    IoErrs::NoPermission { path: _, r#mod: _ } => panic!(),
+                    IoErrs::DueToSomeError { path } => {
+                        assert_eq!(path, "/aaa/bbb/ccc");
+                        let source = err.source().unwrap();
+                        let io_err = source.downcast_ref::<std::io::Error>().unwrap();
+                        assert_eq!(io_err.kind(), std::io::ErrorKind::AlreadyExists);
+                        assert_eq!(io_err.to_string(), "/aaa/bbb/ccc");
                     }
                 },
                 _ => panic!(),
@@ -62,16 +93,29 @@ mod integration_tests_of_err {
                     assert_eq!(path, "/aaa/bbb/ccc");
                 }
                 IoErrs::NoPermission { path: _, r#mod: _ } => panic!(),
+                IoErrs::DueToSomeError { path: _ } => panic!(),
             }),
         };
 
-        match write_file() {
+        match read_file() {
             Ok(_) => panic!(),
             Err(err) => err.match_reason::<IoErrs>(|r| match r {
                 IoErrs::FileNotFound { path: _ } => panic!(),
                 IoErrs::NoPermission { path, r#mod } => {
                     assert_eq!(path, "/aaa/bbb/ccc");
-                    assert_eq!(*r#mod, (6, 6, 6));
+                    assert_eq!(*r#mod, (4, 4, 4));
+                }
+                IoErrs::DueToSomeError { path: _ } => panic!(),
+            }),
+        };
+
+        match write_file() {
+            Ok(_) => panic!(),
+            Err(err) => err.match_reason::<IoErrs>(|r| match r {
+                IoErrs::FileNotFound { path: _ } => panic!(),
+                IoErrs::NoPermission { path: _, r#mod: _ } => panic!(),
+                IoErrs::DueToSomeError { path } => {
+                    assert_eq!(path, "/aaa/bbb/ccc");
                 }
             }),
         };
@@ -83,6 +127,10 @@ mod integration_tests_of_err {
         assert!(err.is_reason::<IoErrs>());
         assert!(!err.is_reason::<String>());
 
+        let err = read_file().unwrap_err();
+        assert!(err.is_reason::<IoErrs>());
+        assert!(!err.is_reason::<String>());
+
         let err = write_file().unwrap_err();
         assert!(err.is_reason::<IoErrs>());
         assert!(!err.is_reason::<String>());
@@ -94,9 +142,13 @@ mod integration_tests_of_err {
         //println!("{err:?}");
         assert_eq!(format!("{err:?}"), "sabi::errs::Err { reason: errs_test::integration_tests_of_err::IoErrs FileNotFound { path: \"/aaa/bbb/ccc\" } }");
 
+        let err = read_file().unwrap_err();
+        //println!("{err:?}");
+        assert_eq!(format!("{err:?}"), "sabi::errs::Err { reason: errs_test::integration_tests_of_err::IoErrs NoPermission { path: \"/aaa/bbb/ccc\", mod: (4, 4, 4) } }");
+
         let err = write_file().unwrap_err();
         //println!("{err:?}");
-        assert_eq!(format!("{err:?}"), "sabi::errs::Err { reason: errs_test::integration_tests_of_err::IoErrs NoPermission { path: \"/aaa/bbb/ccc\", mod: (6, 6, 6) } }");
+        assert_eq!(format!("{err:?}"), "sabi::errs::Err { reason: errs_test::integration_tests_of_err::IoErrs DueToSomeError { path: \"/aaa/bbb/ccc\" } }");
     }
 
     #[test]
@@ -105,13 +157,38 @@ mod integration_tests_of_err {
         //println!("{err}");
         assert_eq!(format!("{err}"), "FileNotFound { path: \"/aaa/bbb/ccc\" }");
 
+        let err = read_file().unwrap_err();
+        //println!("{err}");
+        assert_eq!(
+            format!("{err}"),
+            "NoPermission { path: \"/aaa/bbb/ccc\", mod: (4, 4, 4) }"
+        );
+
         let err = write_file().unwrap_err();
         //println!("{err}");
         assert_eq!(
             format!("{err}"),
-            "NoPermission { path: \"/aaa/bbb/ccc\", mod: (6, 6, 6) }"
+            "DueToSomeError { path: \"/aaa/bbb/ccc\" }"
         );
     }
+
+    #[test]
+    fn should_get_source_of_err() {
+        let err = find_file().unwrap_err();
+        assert!(err.source().is_none());
+
+        let err = read_file().unwrap_err();
+        assert!(err.source().is_none());
+
+        let err = write_file().unwrap_err();
+        if let Some(source) = err.source() {
+            let io_err = source.downcast_ref::<std::io::Error>().unwrap();
+            assert_eq!(io_err.kind(), std::io::ErrorKind::AlreadyExists);
+            assert_eq!(io_err.to_string(), "/aaa/bbb/ccc");
+        } else {
+            panic!();
+        }
+    }
 }
 
 #[test]