feat(value): pass set errors up

Zaba505 · Zaba505 · commit cabb017f4e55 · 2020-09-10T02:08:31.000-04:00
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,12 +1,12 @@
 //! pflag is a port of spf13s' amazing Go package by the same name.
 
-#![feature(associated_type_bounds)]
 #![feature(type_name_of_val)]
 
 mod value;
 
 pub use value::Slice;
 pub use value::Value;
+pub use value::ValueError;
 
 use std::collections::BTreeMap;
 use std::fmt;
@@ -51,7 +51,7 @@ pub struct Flag {
 }
 
 impl Flag {
-    pub fn set(&mut self, val: String) -> Result<(), String> {
+    pub fn set(&mut self, val: String) -> Result<(), ValueError> {
         self.value.set(val)
     }
 
@@ -534,9 +534,9 @@ impl FlagSet {
     builtin_flag_val!(socket_addr_v6, SocketAddrV6);
 
     /// value_of retrieves the value for the given flags name.
-    pub fn value_of<T: std::str::FromStr<Err: fmt::Debug>>(&self, name: &str) -> T {
+    pub fn value_of<T: std::str::FromStr>(&self, name: &str) -> Result<T, T::Err> {
         let i = self.formal.get(name).unwrap();
-        self.flags[*i].value.value().parse().unwrap()
+        self.flags[*i].value.value().parse()
     }
 }
 
@@ -651,7 +651,10 @@ mod tests {
             panic!(err);
         }
 
-        assert_eq!(flags.value_of::<String>("hello"), "world".to_string());
+        assert_eq!(
+            flags.value_of::<String>("hello").unwrap(),
+            "world".to_string()
+        );
     }
 
     #[test]
@@ -663,7 +666,10 @@ mod tests {
             panic!(err);
         }
 
-        assert_eq!(flags.value_of::<String>("hello"), "world".to_string());
+        assert_eq!(
+            flags.value_of::<String>("hello").unwrap(),
+            "world".to_string()
+        );
     }
 
     #[test]
@@ -675,7 +681,7 @@ mod tests {
             panic!(err);
         }
 
-        assert_eq!(flags.value_of::<bool>("hello"), true);
+        assert_eq!(flags.value_of::<bool>("hello").unwrap(), true);
     }
 
     #[test]
@@ -687,7 +693,7 @@ mod tests {
             panic!(err);
         }
 
-        assert_eq!(flags.value_of::<bool>("hello"), true);
+        assert_eq!(flags.value_of::<bool>("hello").unwrap(), true);
     }
 
     #[test]
@@ -699,7 +705,7 @@ mod tests {
             panic!(err);
         }
 
-        assert_eq!(flags.value_of::<bool>("help"), true);
+        assert_eq!(flags.value_of::<bool>("help").unwrap(), true);
     }
 
     #[test]
@@ -711,7 +717,7 @@ mod tests {
             panic!(err);
         }
 
-        assert_eq!(flags.value_of::<bool>("help"), true);
+        assert_eq!(flags.value_of::<bool>("help").unwrap(), true);
     }
 
     #[test]
@@ -724,8 +730,8 @@ mod tests {
             panic!(err);
         }
 
-        assert_eq!(flags.value_of::<bool>("help"), true);
-        assert_eq!(flags.value_of::<bool>("verbose"), true);
+        assert_eq!(flags.value_of::<bool>("help").unwrap(), true);
+        assert_eq!(flags.value_of::<bool>("verbose").unwrap(), true);
     }
 
     #[test]
@@ -738,8 +744,8 @@ mod tests {
             panic!(err);
         }
 
-        assert_eq!(flags.value_of::<bool>("help"), false);
-        assert_eq!(flags.value_of::<bool>("verbose"), true);
+        assert_eq!(flags.value_of::<bool>("help").unwrap(), false);
+        assert_eq!(flags.value_of::<bool>("verbose").unwrap(), true);
     }
 
     #[test]
@@ -751,7 +757,7 @@ mod tests {
             panic!(err);
         }
 
-        assert_eq!(flags.value_of::<u32>("port"), 8080);
+        assert_eq!(flags.value_of::<u32>("port").unwrap(), 8080);
     }
 
     #[test]
@@ -791,7 +797,7 @@ mod tests {
             panic!(err);
         }
 
-        let bools = flags.value_of::<Slice<bool>>("bools");
+        let bools = flags.value_of::<Slice<bool>>("bools").unwrap();
         assert_eq!(bools.len(), 3);
     }
 
@@ -804,7 +810,7 @@ mod tests {
             panic!(err);
         }
 
-        let bools = flags.value_of::<Slice<bool>>("bools");
+        let bools = flags.value_of::<Slice<bool>>("bools").unwrap();
         assert_eq!(bools.len(), 3);
     }
 
@@ -817,7 +823,7 @@ mod tests {
             panic!(err);
         }
 
-        let bools = flags.value_of::<value::Slice<bool>>("bools");
+        let bools = flags.value_of::<value::Slice<bool>>("bools").unwrap();
         assert_eq!(bools.len(), 3);
     }
 
@@ -830,7 +836,7 @@ mod tests {
             panic!(err);
         }
 
-        let bools = flags.value_of::<Slice<bool>>("bools");
+        let bools = flags.value_of::<Slice<bool>>("bools").unwrap();
         assert_eq!(bools.len(), 1);
     }
 }
diff --git a/src/value.rs b/src/value.rs
@@ -1,11 +1,23 @@
+use std::error::Error;
 use std::fmt;
 use std::str;
 use std::string;
 
+#[derive(Debug)]
+pub struct ValueError(Box<dyn Error>);
+
+impl fmt::Display for ValueError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "unexpected error while setting value: {}", &self.0)
+    }
+}
+
+impl Error for ValueError {}
+
 /// Value is a trait representing the value stored in a flag.
 pub trait Value {
     /// set sets the underlying value.
-    fn set(&mut self, val: string::String) -> Result<(), string::String>;
+    fn set(&mut self, val: string::String) -> Result<(), ValueError>;
 
     /// value retrieves the current value as a String.
     fn value(&self) -> string::String;
@@ -21,7 +33,11 @@ pub trait Value {
     }
 }
 
-impl<T: string::ToString + str::FromStr<Err: fmt::Debug>> Value for T {
+impl<E, T> Value for T
+where
+    E: Error + 'static,
+    T: string::ToString + str::FromStr<Err = E>,
+{
     // typ is reimplemeted in order to leverage any::type_name, which
     // is currently whereas any::type_name_of_val is not.
     fn typ(&self) -> &str {
@@ -33,14 +49,14 @@ impl<T: string::ToString + str::FromStr<Err: fmt::Debug>> Value for T {
             + 1) as usize..]
     }
 
-    fn set(&mut self, val: string::String) -> Result<(), string::String> {
+    fn set(&mut self, val: string::String) -> Result<(), ValueError> {
         let res = val.as_str().parse::<T>();
         match res {
             Ok(v) => {
                 *self = v;
                 Ok(())
             }
-            Err(err) => Err(format!("unexpected error while parsing: {:?}", err)),
+            Err(err) => Err(ValueError(Box::new(err))),
         }
     }
 
@@ -94,7 +110,11 @@ impl<T, V: Into<Vec<T>>> From<V> for Slice<T> {
     }
 }
 
-impl<T: string::ToString + str::FromStr<Err: fmt::Debug>> Value for Slice<T> {
+impl<E, T> Value for Slice<T>
+where
+    E: Error + 'static,
+    T: string::ToString + str::FromStr<Err = E>,
+{
     fn typ(&self) -> &str {
         let type_name = std::any::type_name::<T>();
         &type_name[(type_name
@@ -104,7 +124,7 @@ impl<T: string::ToString + str::FromStr<Err: fmt::Debug>> Value for Slice<T> {
             + 1) as usize..]
     }
 
-    fn set(&mut self, val: string::String) -> Result<(), string::String> {
+    fn set(&mut self, val: string::String) -> Result<(), ValueError> {
         if !self.changed {
             self.vals = Vec::with_capacity(self.vals.capacity());
         }
@@ -115,7 +135,7 @@ impl<T: string::ToString + str::FromStr<Err: fmt::Debug>> Value for Slice<T> {
                     self.vals.push(v);
                     Ok(())
                 }
-                Err(err) => Err(format!("unexpected error while parsing: {:?}", err)),
+                Err(err) => Err(ValueError(Box::new(err))),
             }
         })
     }
@@ -135,7 +155,11 @@ impl<T: string::ToString + str::FromStr<Err: fmt::Debug>> Value for Slice<T> {
     }
 }
 
-impl<T: str::FromStr<Err: fmt::Debug>> str::FromStr for Slice<T> {
+impl<E, T> str::FromStr for Slice<T>
+where
+    E: Error + 'static,
+    T: str::FromStr<Err = E>,
+{
     type Err = T::Err;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {

Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,12 @@`
`1`	`1`	`//! pflag is a port of spf13s' amazing Go package by the same name.`
`2`	`2`
`3`		`-#![feature(associated_type_bounds)]`
`4`	`3`	`#![feature(type_name_of_val)]`
`5`	`4`
`6`	`5`	`mod value;`
`7`	`6`
`8`	`7`	`pub use value::Slice;`
`9`	`8`	`pub use value::Value;`
	`9`	`+pub use value::ValueError;`
`10`	`10`
`11`	`11`	`use std::collections::BTreeMap;`
`12`	`12`	`use std::fmt;`
`@@ -51,7 +51,7 @@ pub struct Flag {`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`impl Flag {`
`54`		`- pub fn set(&mut self, val: String) -> Result<(), String> {`
	`54`	`+ pub fn set(&mut self, val: String) -> Result<(), ValueError> {`
`55`	`55`	`self.value.set(val)`
`56`	`56`	`}`
`57`	`57`
`@@ -534,9 +534,9 @@ impl FlagSet {`
`534`	`534`	`builtin_flag_val!(socket_addr_v6, SocketAddrV6);`
`535`	`535`
`536`	`536`	`/// value_of retrieves the value for the given flags name.`
`537`		`- pub fn value_of<T: std::str::FromStr<Err: fmt::Debug>>(&self, name: &str) -> T {`
	`537`	`+ pub fn value_of<T: std::str::FromStr>(&self, name: &str) -> Result<T, T::Err> {`
`538`	`538`	`let i = self.formal.get(name).unwrap();`
`539`		`- self.flags[*i].value.value().parse().unwrap()`
	`539`	`+ self.flags[*i].value.value().parse()`
`540`	`540`	`}`
`541`	`541`	`}`
`542`	`542`
`@@ -651,7 +651,10 @@ mod tests {`
`651`	`651`	`panic!(err);`
`652`	`652`	`}`
`653`	`653`
`654`		`- assert_eq!(flags.value_of::<String>("hello"), "world".to_string());`
	`654`	`+ assert_eq!(`
	`655`	`+ flags.value_of::<String>("hello").unwrap(),`
	`656`	`+ "world".to_string()`
	`657`	`+ );`
`655`	`658`	`}`
`656`	`659`
`657`	`660`	`#[test]`
`@@ -663,7 +666,10 @@ mod tests {`
`663`	`666`	`panic!(err);`
`664`	`667`	`}`
`665`	`668`
`666`		`- assert_eq!(flags.value_of::<String>("hello"), "world".to_string());`
	`669`	`+ assert_eq!(`
	`670`	`+ flags.value_of::<String>("hello").unwrap(),`
	`671`	`+ "world".to_string()`
	`672`	`+ );`
`667`	`673`	`}`
`668`	`674`
`669`	`675`	`#[test]`
`@@ -675,7 +681,7 @@ mod tests {`
`675`	`681`	`panic!(err);`
`676`	`682`	`}`
`677`	`683`
`678`		`- assert_eq!(flags.value_of::<bool>("hello"), true);`
	`684`	`+ assert_eq!(flags.value_of::<bool>("hello").unwrap(), true);`
`679`	`685`	`}`
`680`	`686`
`681`	`687`	`#[test]`
`@@ -687,7 +693,7 @@ mod tests {`
`687`	`693`	`panic!(err);`
`688`	`694`	`}`
`689`	`695`
`690`		`- assert_eq!(flags.value_of::<bool>("hello"), true);`
	`696`	`+ assert_eq!(flags.value_of::<bool>("hello").unwrap(), true);`
`691`	`697`	`}`
`692`	`698`
`693`	`699`	`#[test]`
`@@ -699,7 +705,7 @@ mod tests {`
`699`	`705`	`panic!(err);`
`700`	`706`	`}`
`701`	`707`
`702`		`- assert_eq!(flags.value_of::<bool>("help"), true);`
	`708`	`+ assert_eq!(flags.value_of::<bool>("help").unwrap(), true);`
`703`	`709`	`}`
`704`	`710`
`705`	`711`	`#[test]`
`@@ -711,7 +717,7 @@ mod tests {`
`711`	`717`	`panic!(err);`
`712`	`718`	`}`
`713`	`719`
`714`		`- assert_eq!(flags.value_of::<bool>("help"), true);`
	`720`	`+ assert_eq!(flags.value_of::<bool>("help").unwrap(), true);`
`715`	`721`	`}`
`716`	`722`
`717`	`723`	`#[test]`
`@@ -724,8 +730,8 @@ mod tests {`
`724`	`730`	`panic!(err);`
`725`	`731`	`}`
`726`	`732`
`727`		`- assert_eq!(flags.value_of::<bool>("help"), true);`
`728`		`- assert_eq!(flags.value_of::<bool>("verbose"), true);`
	`733`	`+ assert_eq!(flags.value_of::<bool>("help").unwrap(), true);`
	`734`	`+ assert_eq!(flags.value_of::<bool>("verbose").unwrap(), true);`
`729`	`735`	`}`
`730`	`736`
`731`	`737`	`#[test]`
`@@ -738,8 +744,8 @@ mod tests {`
`738`	`744`	`panic!(err);`
`739`	`745`	`}`
`740`	`746`
`741`		`- assert_eq!(flags.value_of::<bool>("help"), false);`
`742`		`- assert_eq!(flags.value_of::<bool>("verbose"), true);`
	`747`	`+ assert_eq!(flags.value_of::<bool>("help").unwrap(), false);`
	`748`	`+ assert_eq!(flags.value_of::<bool>("verbose").unwrap(), true);`
`743`	`749`	`}`
`744`	`750`
`745`	`751`	`#[test]`
`@@ -751,7 +757,7 @@ mod tests {`
`751`	`757`	`panic!(err);`
`752`	`758`	`}`
`753`	`759`
`754`		`- assert_eq!(flags.value_of::<u32>("port"), 8080);`
	`760`	`+ assert_eq!(flags.value_of::<u32>("port").unwrap(), 8080);`
`755`	`761`	`}`
`756`	`762`
`757`	`763`	`#[test]`
`@@ -791,7 +797,7 @@ mod tests {`
`791`	`797`	`panic!(err);`
`792`	`798`	`}`
`793`	`799`
`794`		`- let bools = flags.value_of::<Slice<bool>>("bools");`
	`800`	`+ let bools = flags.value_of::<Slice<bool>>("bools").unwrap();`
`795`	`801`	`assert_eq!(bools.len(), 3);`
`796`	`802`	`}`
`797`	`803`
`@@ -804,7 +810,7 @@ mod tests {`
`804`	`810`	`panic!(err);`
`805`	`811`	`}`
`806`	`812`
`807`		`- let bools = flags.value_of::<Slice<bool>>("bools");`
	`813`	`+ let bools = flags.value_of::<Slice<bool>>("bools").unwrap();`
`808`	`814`	`assert_eq!(bools.len(), 3);`
`809`	`815`	`}`
`810`	`816`
`@@ -817,7 +823,7 @@ mod tests {`
`817`	`823`	`panic!(err);`
`818`	`824`	`}`
`819`	`825`
`820`		`- let bools = flags.value_of::<value::Slice<bool>>("bools");`
	`826`	`+ let bools = flags.value_of::<value::Slice<bool>>("bools").unwrap();`
`821`	`827`	`assert_eq!(bools.len(), 3);`
`822`	`828`	`}`
`823`	`829`
`@@ -830,7 +836,7 @@ mod tests {`
`830`	`836`	`panic!(err);`
`831`	`837`	`}`
`832`	`838`
`833`		`- let bools = flags.value_of::<Slice<bool>>("bools");`
	`839`	`+ let bools = flags.value_of::<Slice<bool>>("bools").unwrap();`
`834`	`840`	`assert_eq!(bools.len(), 1);`
`835`	`841`	`}`
`836`	`842`	`}`