From 14648ff357970ef1779fd7cb546cfe46c4a955ca Mon Sep 17 00:00:00 2001 From: prataprc Date: Tue, 22 May 2018 12:59:20 +0530 Subject: [PATCH 1/2] implement opt_get() method call on Matches. * more tolerant than opt_default. * folds str::parse() on the argument and returns Result. --- src/lib.rs | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) diff --git a/src/lib.rs b/src/lib.rs index 0a81c40e..ea1b4821 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -119,6 +119,7 @@ use std::ffi::OsStr; use std::fmt; use std::iter::{repeat, IntoIterator}; use std::result; +use std::str::FromStr; /// A description of the options that a program can handle. pub struct Options { @@ -841,6 +842,20 @@ impl Matches { } } + /// Returns the matching value or `None`. + /// + /// Similar to opt_default, except the two differences. Instead of + /// returning None when option was not present, return `def`. Instead of + /// returning &str slice return valued of type T parsed using str::parse(). + pub fn opt_get(&self, nm: &str, def: T) + -> result::Result::Err> where T: FromStr + { + match self.opt_val(nm) { + Some(Val(s)) => s.parse(), + Some(Given) => Ok(def), + None => Ok(def), + } + } } fn is_arg(arg: &str) -> bool { @@ -2018,4 +2033,46 @@ Options: Err(e) => panic!("{}", e) } } + + #[test] + fn test_opt_default() { + let mut opts = Options::new(); + opts.optflag("h", "help", "Description"); + opts.optflag("i", "ignore", "Description"); + opts.optflag("r", "run", "Description"); + opts.long_only(false); + + let args: Vec = ["-i", "-r", "10"] + .iter().map(|x| x.to_string()).collect(); + let matches = &match opts.parse(&args) { + Ok(m) => m, + Err(e) => panic!("{}", e) + }; + assert_eq!(matches.opt_default("help", ""), None); + assert_eq!(matches.opt_default("i", "def"), Some("def".to_string())); + } + + #[test] + fn test_opt_get() { + let mut opts = Options::new(); + opts.optflag("h", "help", "Description"); + opts.optflagopt("i", "ignore", "Description", "true | false"); + opts.optflagopt("r", "run", "Description", "0 .. 10"); + opts.optflagopt("p", "percent", "Description", "0.0 .. 10.0"); + opts.long_only(false); + + let args: Vec = [ + "-i", "true", "-p", "1.1" + ].iter().map(|x| x.to_string()).collect(); + let matches = &match opts.parse(&args) { + Ok(m) => m, + Err(e) => panic!("{}", e) + }; + let h_arg =matches.opt_get("help", 10); + assert_eq!(h_arg, Ok(10)); + let i_arg = matches.opt_get("i", false); + assert_eq!(i_arg, Ok(true)); + let p_arg = matches.opt_get("p", 10.2); + assert_eq!(p_arg, Ok(1.1)); + } } From 26ddb4c04d48ca205f5f4c069872cd4b43da354e Mon Sep 17 00:00:00 2001 From: prataprc Date: Sun, 3 Jun 2018 14:08:51 +0530 Subject: [PATCH 2/2] Include opt_get_default variant. --- src/lib.rs | 55 +++++++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 46 insertions(+), 9 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index ea1b4821..b9bfe3c8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -842,13 +842,26 @@ impl Matches { } } - /// Returns the matching value or `None`. + /// Returns some matching value or `None`. /// - /// Similar to opt_default, except the two differences. Instead of - /// returning None when option was not present, return `def`. Instead of - /// returning &str slice return valued of type T parsed using str::parse(). - pub fn opt_get(&self, nm: &str, def: T) - -> result::Result::Err> where T: FromStr + /// Similar to opt_str, also converts matching argument using FromStr. + pub fn opt_get(&self, nm: &str) -> result::Result, T::Err> + where T: FromStr + { + match self.opt_val(nm) { + Some(Val(s)) => Ok(Some(s.parse()?)), + Some(Given) => Ok(None), + None => Ok(None), + } + } + + /// Returns a matching value or default. + /// + /// Similar to opt_default, except the two differences. + /// Instead of returning None when argument was not present, return `def`. + /// Instead of returning &str return type T, parsed using str::parse(). + pub fn opt_get_default(&self, nm: &str, def: T) + -> result::Result where T: FromStr { match self.opt_val(nm) { Some(Val(s)) => s.parse(), @@ -2068,11 +2081,35 @@ Options: Ok(m) => m, Err(e) => panic!("{}", e) }; - let h_arg =matches.opt_get("help", 10); + let h_arg = matches.opt_get::("help"); + assert_eq!(h_arg, Ok(None)); + let i_arg = matches.opt_get("i"); + assert_eq!(i_arg, Ok(Some(true))); + let p_arg = matches.opt_get("p"); + assert_eq!(p_arg, Ok(Some(1.1))); + } + + #[test] + fn test_opt_get_default() { + let mut opts = Options::new(); + opts.optflag("h", "help", "Description"); + opts.optflagopt("i", "ignore", "Description", "true | false"); + opts.optflagopt("r", "run", "Description", "0 .. 10"); + opts.optflagopt("p", "percent", "Description", "0.0 .. 10.0"); + opts.long_only(false); + + let args: Vec = [ + "-i", "true", "-p", "1.1" + ].iter().map(|x| x.to_string()).collect(); + let matches = &match opts.parse(&args) { + Ok(m) => m, + Err(e) => panic!("{}", e) + }; + let h_arg =matches.opt_get_default("help", 10); assert_eq!(h_arg, Ok(10)); - let i_arg = matches.opt_get("i", false); + let i_arg = matches.opt_get_default("i", false); assert_eq!(i_arg, Ok(true)); - let p_arg = matches.opt_get("p", 10.2); + let p_arg = matches.opt_get_default("p", 10.2); assert_eq!(p_arg, Ok(1.1)); } }