//! file name following `-o`, and accepts both `-h` and `--help` as optional flags.
//!
//! ```{.rust}
+//! #![feature(rustc_private)]
+//!
//! extern crate getopts;
//! use getopts::{optopt,optflag,getopts,OptGroup,usage};
-//! use std::os;
+//! use std::env;
//!
//! fn do_work(inp: &str, out: Option<String>) {
//! println!("{}", inp);
//!
//! fn print_usage(program: &str, opts: &[OptGroup]) {
//! let brief = format!("Usage: {} [options]", program);
-//! print!("{}", usage(brief, opts));
+//! print!("{}", usage(&brief, opts));
//! }
//!
//! fn main() {
-//! let args: Vec<String> = os::args();
+//! let args: Vec<String> = env::args().collect();
//!
//! let program = args[0].clone();
//!
//! optopt("o", "", "set output file name", "NAME"),
//! optflag("h", "help", "print this help menu")
//! ];
-//! let matches = match getopts(args[1..], opts) {
+//! let matches = match getopts(&args[1..], opts) {
//! Ok(m) => { m }
//! Err(f) => { panic!(f.to_string()) }
//! };
//! if matches.opt_present("h") {
-//! print_usage(program, opts);
+//! print_usage(&program, opts);
//! return;
//! }
//! let output = matches.opt_str("o");
//! let input = if !matches.free.is_empty() {
//! matches.free[0].clone()
//! } else {
-//! print_usage(program, opts);
+//! print_usage(&program, opts);
//! return;
//! };
-//! do_work(input, output);
+//! do_work(&input, output);
//! }
//! ```
#![unstable(feature = "rustc_private",
reason = "use the crates.io `getopts` library instead",
issue = "27812")]
-#![staged_api]
+#![cfg_attr(stage0, staged_api)]
#![crate_type = "rlib"]
#![crate_type = "dylib"]
#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
html_root_url = "https://doc.rust-lang.org/nightly/",
- html_playground_url = "https://play.rust-lang.org/")]
+ html_playground_url = "https://play.rust-lang.org/",
+ test(attr(deny(warnings))))]
#![deny(missing_docs)]
#![feature(staged_api)]
#![feature(str_char)]
#![cfg_attr(test, feature(rustc_private))]
-#[cfg(test)] #[macro_use] extern crate log;
+#[cfg(test)]
+#[macro_use]
+extern crate log;
use self::Name::*;
use self::HasArg::*;
/// Whether option has an argument
pub hasarg: HasArg,
/// How often it can occur
- pub occur: Occur
+ pub occur: Occur,
}
/// Describes whether an option is given at all or has a value.
fn to_string(&self) -> String {
match *self {
Short(ch) => ch.to_string(),
- Long(ref s) => s.to_owned()
+ Long(ref s) => s.to_owned(),
}
}
}
} = (*self).clone();
match (short_name.len(), long_name.len()) {
- (0,0) => panic!("this long-format option was given no name"),
- (0,_) => Opt {
- name: Long((long_name)),
- hasarg: hasarg,
- occur: occur,
- aliases: Vec::new()
- },
- (1,0) => Opt {
- name: Short(short_name.char_at(0)),
- hasarg: hasarg,
- occur: occur,
- aliases: Vec::new()
- },
- (1,_) => Opt {
- name: Long((long_name)),
- hasarg: hasarg,
- occur: occur,
- aliases: vec!(
- Opt {
- name: Short(short_name.char_at(0)),
- hasarg: hasarg,
- occur: occur,
- aliases: Vec::new()
- }
- )
- },
- (_,_) => panic!("something is wrong with the long-form opt")
+ (0, 0) => panic!("this long-format option was given no name"),
+ (0, _) => {
+ Opt {
+ name: Long((long_name)),
+ hasarg: hasarg,
+ occur: occur,
+ aliases: Vec::new(),
+ }
+ }
+ (1, 0) => {
+ Opt {
+ name: Short(short_name.char_at(0)),
+ hasarg: hasarg,
+ occur: occur,
+ aliases: Vec::new(),
+ }
+ }
+ (1, _) => {
+ Opt {
+ name: Long((long_name)),
+ hasarg: hasarg,
+ occur: occur,
+ aliases: vec![Opt {
+ name: Short(short_name.char_at(0)),
+ hasarg: hasarg,
+ occur: occur,
+ aliases: Vec::new(),
+ }],
+ }
+ }
+ (_, _) => panic!("something is wrong with the long-form opt"),
}
}
}
fn opt_vals(&self, nm: &str) -> Vec<Optval> {
match find_opt(&self.opts[..], Name::from_str(nm)) {
Some(id) => self.vals[id].clone(),
- None => panic!("No option '{}' defined", nm)
+ None => panic!("No option '{}' defined", nm),
}
}
for nm in names {
match self.opt_val(&nm[..]) {
Some(Val(ref s)) => return Some(s.clone()),
- _ => ()
+ _ => (),
}
}
None
for v in &r {
match *v {
Val(ref s) => acc.push((*s).clone()),
- _ => ()
+ _ => (),
}
}
acc
}
match vals[0] {
Val(ref s) => Some((*s).clone()),
- _ => None
+ _ => None,
}
}
} else {
match vals[0] {
Val(ref s) => Some((*s).clone()),
- _ => Some(def.to_owned())
+ _ => Some(def.to_owned()),
}
}
}
-
}
fn is_arg(arg: &str) -> bool {
// Search main options.
let pos = opts.iter().position(|opt| opt.name == nm);
if pos.is_some() {
- return pos
+ return pos;
}
// Search in aliases.
hint: hint.to_owned(),
desc: desc.to_owned(),
hasarg: Yes,
- occur: Req
+ occur: Req,
}
}
hint: hint.to_owned(),
desc: desc.to_owned(),
hasarg: Yes,
- occur: Optional
+ occur: Optional,
}
}
hint: "".to_owned(),
desc: desc.to_owned(),
hasarg: No,
- occur: Optional
+ occur: Optional,
}
}
hint: "".to_owned(),
desc: desc.to_owned(),
hasarg: No,
- occur: Multi
+ occur: Multi,
}
}
hint: hint.to_owned(),
desc: desc.to_owned(),
hasarg: Maybe,
- occur: Optional
+ occur: Optional,
}
}
hint: hint.to_owned(),
desc: desc.to_owned(),
hasarg: Yes,
- occur: Multi
+ occur: Multi,
}
}
desc: &str,
hint: &str,
hasarg: HasArg,
- occur: Occur) -> OptGroup {
+ occur: Occur)
+ -> OptGroup {
let len = short_name.len();
assert!(len == 1 || len == 0);
OptGroup {
hint: hint.to_owned(),
desc: desc.to_owned(),
hasarg: hasarg,
- occur: occur
+ occur: occur,
}
}
impl fmt::Display for Fail {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
- ArgumentMissing(ref nm) => {
- write!(f, "Argument to option '{}' missing.", *nm)
- }
- UnrecognizedOption(ref nm) => {
- write!(f, "Unrecognized option: '{}'.", *nm)
- }
- OptionMissing(ref nm) => {
- write!(f, "Required option '{}' missing.", *nm)
- }
- OptionDuplicated(ref nm) => {
- write!(f, "Option '{}' given more than once.", *nm)
- }
- UnexpectedArgument(ref nm) => {
- write!(f, "Option '{}' does not take an argument.", *nm)
- }
+ ArgumentMissing(ref nm) => write!(f, "Argument to option '{}' missing.", *nm),
+ UnrecognizedOption(ref nm) => write!(f, "Unrecognized option: '{}'.", *nm),
+ OptionMissing(ref nm) => write!(f, "Required option '{}' missing.", *nm),
+ OptionDuplicated(ref nm) => write!(f, "Option '{}' given more than once.", *nm),
+ UnexpectedArgument(ref nm) => write!(f, "Option '{}' does not take an argument.", *nm),
}
}
}
let opts: Vec<Opt> = optgrps.iter().map(|x| x.long_to_short()).collect();
let n_opts = opts.len();
- fn f(_x: usize) -> Vec<Optval> { Vec::new() }
+ fn f(_x: usize) -> Vec<Optval> {
+ Vec::new()
+ }
let mut vals: Vec<_> = (0..n_opts).map(f).collect();
let mut free: Vec<String> = Vec::new();
free.push(cur);
} else if cur == "--" {
let mut j = i + 1;
- while j < l { free.push(args[j].clone()); j += 1; }
+ while j < l {
+ free.push(args[j].clone());
+ j += 1;
+ }
break;
} else {
let mut names;
let mut i_arg = None;
if cur.as_bytes()[1] == b'-' {
let tail = &cur[2..curlen];
- let tail_eq: Vec<&str> = tail.split('=').collect();
+ let tail_eq: Vec<&str> = tail.splitn(2, '=').collect();
if tail_eq.len() <= 1 {
- names = vec!(Long(tail.to_owned()));
+ names = vec![Long(tail.to_owned())];
} else {
- names =
- vec!(Long(tail_eq[0].to_owned()));
+ names = vec![Long(tail_eq[0].to_owned())];
i_arg = Some(tail_eq[1].to_owned());
}
} else {
let ch = cur.char_at(j);
let opt = Short(ch);
- /* In a series of potential options (eg. -aheJ), if we
- see one which takes an argument, we assume all
- subsequent characters make up the argument. This
- allows options such as -L/usr/local/lib/foo to be
- interpreted correctly
- */
+ // In a series of potential options (eg. -aheJ), if we
+ // see one which takes an argument, we assume all
+ // subsequent characters make up the argument. This
+ // allows options such as -L/usr/local/lib/foo to be
+ // interpreted correctly
let opt_id = match find_opt(&opts, opt.clone()) {
- Some(id) => id,
- None => return Err(UnrecognizedOption(opt.to_string()))
+ Some(id) => id,
+ None => return Err(UnrecognizedOption(opt.to_string())),
};
names.push(opt);
let arg_follows = match opts[opt_id].hasarg {
Yes | Maybe => true,
- No => false
+ No => false,
};
let next = j + ch.len_utf8();
for nm in &names {
name_pos += 1;
let optid = match find_opt(&opts, (*nm).clone()) {
- Some(id) => id,
- None => return Err(UnrecognizedOption(nm.to_string()))
+ Some(id) => id,
+ None => return Err(UnrecognizedOption(nm.to_string())),
};
match opts[optid].hasarg {
- No => {
- if name_pos == names.len() && !i_arg.is_none() {
- return Err(UnexpectedArgument(nm.to_string()));
- }
- let v = &mut vals[optid];
- v.push(Given);
- }
- Maybe => {
- if !i_arg.is_none() {
- let v = &mut vals[optid];
- v.push(Val((i_arg.clone())
- .unwrap()));
- } else if name_pos < names.len() || i + 1 == l ||
- is_arg(&args[i + 1][..]) {
+ No => {
+ if name_pos == names.len() && !i_arg.is_none() {
+ return Err(UnexpectedArgument(nm.to_string()));
+ }
let v = &mut vals[optid];
v.push(Given);
- } else {
- i += 1;
- let v = &mut vals[optid];
- v.push(Val(args[i].clone()));
}
- }
- Yes => {
- if !i_arg.is_none() {
- let v = &mut vals[optid];
- v.push(Val(i_arg.clone().unwrap()));
- } else if i + 1 == l {
- return Err(ArgumentMissing(nm.to_string()));
- } else {
- i += 1;
- let v = &mut vals[optid];
- v.push(Val(args[i].clone()));
+ Maybe => {
+ if !i_arg.is_none() {
+ let v = &mut vals[optid];
+ v.push(Val((i_arg.clone()).unwrap()));
+ } else if name_pos < names.len() || i + 1 == l || is_arg(&args[i + 1][..]) {
+ let v = &mut vals[optid];
+ v.push(Given);
+ } else {
+ i += 1;
+ let v = &mut vals[optid];
+ v.push(Val(args[i].clone()));
+ }
+ }
+ Yes => {
+ if !i_arg.is_none() {
+ let v = &mut vals[optid];
+ v.push(Val(i_arg.clone().unwrap()));
+ } else if i + 1 == l {
+ return Err(ArgumentMissing(nm.to_string()));
+ } else {
+ i += 1;
+ let v = &mut vals[optid];
+ v.push(Val(args[i].clone()));
+ }
}
- }
}
}
}
Ok(Matches {
opts: opts,
vals: vals,
- free: free
+ free: free,
})
}
row
});
- format!("{}\n\nOptions:\n{}\n", brief,
+ format!("{}\n\nOptions:\n{}\n",
+ brief,
rows.collect::<Vec<String>>().join("\n"))
}
#[derive(Copy, Clone)]
enum SplitWithinState {
- A, // leading whitespace, initial state
- B, // words
- C, // internal and trailing whitespace
+ A, // leading whitespace, initial state
+ B, // words
+ C, // internal and trailing whitespace
}
#[derive(Copy, Clone)]
enum Whitespace {
Ws, // current char is whitespace
- Cr // current char is not whitespace
+ Cr, // current char is not whitespace
}
#[derive(Copy, Clone)]
enum LengthLimit {
UnderLim, // current char makes current substring still fit in limit
- OverLim // current char makes current substring no longer fit in limit
+ OverLim, // current char makes current substring no longer fit in limit
}
///
/// Panics during iteration if the string contains a non-whitespace
/// sequence longer than the limit.
-fn each_split_within<F>(ss: &str, lim: usize, mut it: F) -> bool where
- F: FnMut(&str) -> bool
+fn each_split_within<F>(ss: &str, lim: usize, mut it: F) -> bool
+ where F: FnMut(&str) -> bool
{
// Just for fun, let's write this as a state machine:
}
let mut machine = |cont: &mut bool, (i, c): (usize, char)| -> bool {
- let whitespace = if c.is_whitespace() { Ws } else { Cr };
- let limit = if (i - slice_start + 1) <= lim { UnderLim } else { OverLim };
+ let whitespace = if c.is_whitespace() {
+ Ws
+ } else {
+ Cr
+ };
+ let limit = if (i - slice_start + 1) <= lim {
+ UnderLim
+ } else {
+ OverLim
+ };
state = match (state, whitespace, limit) {
- (A, Ws, _) => { A }
- (A, Cr, _) => { slice_start = i; last_start = i; B }
-
- (B, Cr, UnderLim) => { B }
- (B, Cr, OverLim) if (i - last_start + 1) > lim
- => panic!("word starting with {} longer than limit!",
- &ss[last_start..i + 1]),
- (B, Cr, OverLim) => {
+ (A, Ws, _) => A,
+ (A, Cr, _) => {
+ slice_start = i;
+ last_start = i;
+ B
+ }
+
+ (B, Cr, UnderLim) => B,
+ (B, Cr, OverLim) if (i - last_start + 1) > lim => {
+ panic!("word starting with {} longer than limit!",
+ &ss[last_start..i + 1])
+ }
+ (B, Cr, OverLim) => {
*cont = it(&ss[slice_start..last_end]);
slice_start = last_start;
B
last_end = i;
C
}
- (B, Ws, OverLim) => {
+ (B, Ws, OverLim) => {
last_end = i;
*cont = it(&ss[slice_start..last_end]);
A
last_start = i;
B
}
- (C, Cr, OverLim) => {
+ (C, Cr, OverLim) => {
*cont = it(&ss[slice_start..last_end]);
slice_start = i;
last_start = i;
last_end = i;
B
}
- (C, Ws, OverLim) => {
+ (C, Ws, OverLim) => {
*cont = it(&ss[slice_start..last_end]);
A
}
- (C, Ws, UnderLim) => {
- C
- }
+ (C, Ws, UnderLim) => C,
};
*cont
ss.char_indices().all(|x| machine(&mut cont, x));
// Let the automaton 'run out' by supplying trailing whitespace
- while cont && match state { B | C => true, A => false } {
+ while cont &&
+ match state {
+ B | C => true,
+ A => false,
+ } {
machine(&mut cont, (fake_i, ' '));
fake_i += 1;
}
fn test_split_within() {
fn t(s: &str, i: usize, u: &[String]) {
let mut v = Vec::new();
- each_split_within(s, i, |s| { v.push(s.to_string()); true });
- assert!(v.iter().zip(u).all(|(a,b)| a == b));
+ each_split_within(s, i, |s| {
+ v.push(s.to_string());
+ true
+ });
+ assert!(v.iter().zip(u).all(|(a, b)| a == b));
}
t("", 0, &[]);
t("", 15, &[]);
t("hello", 15, &["hello".to_string()]);
- t("\nMary had a little lamb\nLittle lamb\n", 15, &[
- "Mary had a".to_string(),
- "little lamb".to_string(),
- "Little lamb".to_string()
- ]);
- t("\nMary had a little lamb\nLittle lamb\n", ::std::usize::MAX,
- &["Mary had a little lamb\nLittle lamb".to_string()]);
+ t("\nMary had a little lamb\nLittle lamb\n",
+ 15,
+ &["Mary had a".to_string(), "little lamb".to_string(), "Little lamb".to_string()]);
+ t("\nMary had a little lamb\nLittle lamb\n",
+ ::std::usize::MAX,
+ &["Mary had a little lamb\nLittle lamb".to_string()]);
}
#[cfg(test)]
// Tests for reqopt
#[test]
fn test_reqopt() {
- let long_args = vec!("--test=20".to_string());
- let opts = vec!(reqopt("t", "test", "testing", "TEST"));
+ let long_args = vec!["--test=20".to_string()];
+ let opts = vec![reqopt("t", "test", "testing", "TEST")];
let rs = getopts(&long_args, &opts);
match rs {
- Ok(ref m) => {
- assert!(m.opt_present("test"));
- assert_eq!(m.opt_str("test").unwrap(), "20");
- assert!(m.opt_present("t"));
- assert_eq!(m.opt_str("t").unwrap(), "20");
- }
- _ => { panic!("test_reqopt failed (long arg)"); }
+ Ok(ref m) => {
+ assert!(m.opt_present("test"));
+ assert_eq!(m.opt_str("test").unwrap(), "20");
+ assert!(m.opt_present("t"));
+ assert_eq!(m.opt_str("t").unwrap(), "20");
+ }
+ _ => {
+ panic!("test_reqopt failed (long arg)");
+ }
}
- let short_args = vec!("-t".to_string(), "20".to_string());
+ let short_args = vec!["-t".to_string(), "20".to_string()];
match getopts(&short_args, &opts) {
- Ok(ref m) => {
- assert!((m.opt_present("test")));
- assert_eq!(m.opt_str("test").unwrap(), "20");
- assert!((m.opt_present("t")));
- assert_eq!(m.opt_str("t").unwrap(), "20");
- }
- _ => { panic!("test_reqopt failed (short arg)"); }
+ Ok(ref m) => {
+ assert!((m.opt_present("test")));
+ assert_eq!(m.opt_str("test").unwrap(), "20");
+ assert!((m.opt_present("t")));
+ assert_eq!(m.opt_str("t").unwrap(), "20");
+ }
+ _ => {
+ panic!("test_reqopt failed (short arg)");
+ }
}
}
#[test]
fn test_reqopt_missing() {
- let args = vec!("blah".to_string());
- let opts = vec!(reqopt("t", "test", "testing", "TEST"));
+ let args = vec!["blah".to_string()];
+ let opts = vec![reqopt("t", "test", "testing", "TEST")];
let rs = getopts(&args, &opts);
match rs {
- Err(OptionMissing(_)) => {},
- _ => panic!()
+ Err(OptionMissing(_)) => {}
+ _ => panic!(),
}
}
#[test]
fn test_reqopt_no_arg() {
- let long_args = vec!("--test".to_string());
- let opts = vec!(reqopt("t", "test", "testing", "TEST"));
+ let long_args = vec!["--test".to_string()];
+ let opts = vec![reqopt("t", "test", "testing", "TEST")];
let rs = getopts(&long_args, &opts);
match rs {
- Err(ArgumentMissing(_)) => {},
- _ => panic!()
+ Err(ArgumentMissing(_)) => {}
+ _ => panic!(),
}
- let short_args = vec!("-t".to_string());
+ let short_args = vec!["-t".to_string()];
match getopts(&short_args, &opts) {
- Err(ArgumentMissing(_)) => {},
- _ => panic!()
+ Err(ArgumentMissing(_)) => {}
+ _ => panic!(),
}
}
#[test]
fn test_reqopt_multi() {
- let args = vec!("--test=20".to_string(), "-t".to_string(), "30".to_string());
- let opts = vec!(reqopt("t", "test", "testing", "TEST"));
+ let args = vec!["--test=20".to_string(), "-t".to_string(), "30".to_string()];
+ let opts = vec![reqopt("t", "test", "testing", "TEST")];
let rs = getopts(&args, &opts);
match rs {
- Err(OptionDuplicated(_)) => {},
- _ => panic!()
+ Err(OptionDuplicated(_)) => {}
+ _ => panic!(),
}
}
// Tests for optopt
#[test]
fn test_optopt() {
- let long_args = vec!("--test=20".to_string());
- let opts = vec!(optopt("t", "test", "testing", "TEST"));
+ let long_args = vec!["--test=20".to_string()];
+ let opts = vec![optopt("t", "test", "testing", "TEST")];
let rs = getopts(&long_args, &opts);
match rs {
- Ok(ref m) => {
- assert!(m.opt_present("test"));
- assert_eq!(m.opt_str("test").unwrap(), "20");
- assert!((m.opt_present("t")));
- assert_eq!(m.opt_str("t").unwrap(), "20");
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert!(m.opt_present("test"));
+ assert_eq!(m.opt_str("test").unwrap(), "20");
+ assert!((m.opt_present("t")));
+ assert_eq!(m.opt_str("t").unwrap(), "20");
+ }
+ _ => panic!(),
}
- let short_args = vec!("-t".to_string(), "20".to_string());
+ let short_args = vec!["-t".to_string(), "20".to_string()];
match getopts(&short_args, &opts) {
- Ok(ref m) => {
- assert!((m.opt_present("test")));
- assert_eq!(m.opt_str("test").unwrap(), "20");
- assert!((m.opt_present("t")));
- assert_eq!(m.opt_str("t").unwrap(), "20");
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert!((m.opt_present("test")));
+ assert_eq!(m.opt_str("test").unwrap(), "20");
+ assert!((m.opt_present("t")));
+ assert_eq!(m.opt_str("t").unwrap(), "20");
+ }
+ _ => panic!(),
}
}
#[test]
fn test_optopt_missing() {
- let args = vec!("blah".to_string());
- let opts = vec!(optopt("t", "test", "testing", "TEST"));
+ let args = vec!["blah".to_string()];
+ let opts = vec![optopt("t", "test", "testing", "TEST")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- assert!(!m.opt_present("test"));
- assert!(!m.opt_present("t"));
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert!(!m.opt_present("test"));
+ assert!(!m.opt_present("t"));
+ }
+ _ => panic!(),
}
}
#[test]
fn test_optopt_no_arg() {
- let long_args = vec!("--test".to_string());
- let opts = vec!(optopt("t", "test", "testing", "TEST"));
+ let long_args = vec!["--test".to_string()];
+ let opts = vec![optopt("t", "test", "testing", "TEST")];
let rs = getopts(&long_args, &opts);
match rs {
- Err(ArgumentMissing(_)) => {},
- _ => panic!()
+ Err(ArgumentMissing(_)) => {}
+ _ => panic!(),
}
- let short_args = vec!("-t".to_string());
+ let short_args = vec!["-t".to_string()];
match getopts(&short_args, &opts) {
- Err(ArgumentMissing(_)) => {},
- _ => panic!()
+ Err(ArgumentMissing(_)) => {}
+ _ => panic!(),
}
}
#[test]
fn test_optopt_multi() {
- let args = vec!("--test=20".to_string(), "-t".to_string(), "30".to_string());
- let opts = vec!(optopt("t", "test", "testing", "TEST"));
+ let args = vec!["--test=20".to_string(), "-t".to_string(), "30".to_string()];
+ let opts = vec![optopt("t", "test", "testing", "TEST")];
let rs = getopts(&args, &opts);
match rs {
- Err(OptionDuplicated(_)) => {},
- _ => panic!()
+ Err(OptionDuplicated(_)) => {}
+ _ => panic!(),
}
}
// Tests for optflag
#[test]
fn test_optflag() {
- let long_args = vec!("--test".to_string());
- let opts = vec!(optflag("t", "test", "testing"));
+ let long_args = vec!["--test".to_string()];
+ let opts = vec![optflag("t", "test", "testing")];
let rs = getopts(&long_args, &opts);
match rs {
- Ok(ref m) => {
- assert!(m.opt_present("test"));
- assert!(m.opt_present("t"));
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert!(m.opt_present("test"));
+ assert!(m.opt_present("t"));
+ }
+ _ => panic!(),
}
- let short_args = vec!("-t".to_string());
+ let short_args = vec!["-t".to_string()];
match getopts(&short_args, &opts) {
- Ok(ref m) => {
- assert!(m.opt_present("test"));
- assert!(m.opt_present("t"));
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert!(m.opt_present("test"));
+ assert!(m.opt_present("t"));
+ }
+ _ => panic!(),
}
}
#[test]
fn test_optflag_missing() {
- let args = vec!("blah".to_string());
- let opts = vec!(optflag("t", "test", "testing"));
+ let args = vec!["blah".to_string()];
+ let opts = vec![optflag("t", "test", "testing")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- assert!(!m.opt_present("test"));
- assert!(!m.opt_present("t"));
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert!(!m.opt_present("test"));
+ assert!(!m.opt_present("t"));
+ }
+ _ => panic!(),
}
}
#[test]
fn test_optflag_long_arg() {
- let args = vec!("--test=20".to_string());
- let opts = vec!(optflag("t", "test", "testing"));
+ let args = vec!["--test=20".to_string()];
+ let opts = vec![optflag("t", "test", "testing")];
let rs = getopts(&args, &opts);
match rs {
- Err(UnexpectedArgument(_)) => {},
- _ => panic!()
+ Err(UnexpectedArgument(_)) => {}
+ _ => panic!(),
}
}
#[test]
fn test_optflag_multi() {
- let args = vec!("--test".to_string(), "-t".to_string());
- let opts = vec!(optflag("t", "test", "testing"));
+ let args = vec!["--test".to_string(), "-t".to_string()];
+ let opts = vec![optflag("t", "test", "testing")];
let rs = getopts(&args, &opts);
match rs {
- Err(OptionDuplicated(_)) => {},
- _ => panic!()
+ Err(OptionDuplicated(_)) => {}
+ _ => panic!(),
}
}
#[test]
fn test_optflag_short_arg() {
- let args = vec!("-t".to_string(), "20".to_string());
- let opts = vec!(optflag("t", "test", "testing"));
+ let args = vec!["-t".to_string(), "20".to_string()];
+ let opts = vec![optflag("t", "test", "testing")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- // The next variable after the flag is just a free argument
+ Ok(ref m) => {
+ // The next variable after the flag is just a free argument
- assert!(m.free[0] == "20");
- }
- _ => panic!()
+ assert!(m.free[0] == "20");
+ }
+ _ => panic!(),
}
}
// Tests for optflagmulti
#[test]
fn test_optflagmulti_short1() {
- let args = vec!("-v".to_string());
- let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+ let args = vec!["-v".to_string()];
+ let opts = vec![optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- assert_eq!(m.opt_count("v"), 1);
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert_eq!(m.opt_count("v"), 1);
+ }
+ _ => panic!(),
}
}
#[test]
fn test_optflagmulti_short2a() {
- let args = vec!("-v".to_string(), "-v".to_string());
- let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+ let args = vec!["-v".to_string(), "-v".to_string()];
+ let opts = vec![optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- assert_eq!(m.opt_count("v"), 2);
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert_eq!(m.opt_count("v"), 2);
+ }
+ _ => panic!(),
}
}
#[test]
fn test_optflagmulti_short2b() {
- let args = vec!("-vv".to_string());
- let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+ let args = vec!["-vv".to_string()];
+ let opts = vec![optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- assert_eq!(m.opt_count("v"), 2);
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert_eq!(m.opt_count("v"), 2);
+ }
+ _ => panic!(),
}
}
#[test]
fn test_optflagmulti_long1() {
- let args = vec!("--verbose".to_string());
- let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+ let args = vec!["--verbose".to_string()];
+ let opts = vec![optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- assert_eq!(m.opt_count("verbose"), 1);
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert_eq!(m.opt_count("verbose"), 1);
+ }
+ _ => panic!(),
}
}
#[test]
fn test_optflagmulti_long2() {
- let args = vec!("--verbose".to_string(), "--verbose".to_string());
- let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+ let args = vec!["--verbose".to_string(), "--verbose".to_string()];
+ let opts = vec![optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- assert_eq!(m.opt_count("verbose"), 2);
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert_eq!(m.opt_count("verbose"), 2);
+ }
+ _ => panic!(),
}
}
#[test]
fn test_optflagmulti_mix() {
- let args = vec!("--verbose".to_string(), "-v".to_string(),
- "-vv".to_string(), "verbose".to_string());
- let opts = vec!(optflagmulti("v", "verbose", "verbosity"));
+ let args = vec!["--verbose".to_string(),
+ "-v".to_string(),
+ "-vv".to_string(),
+ "verbose".to_string()];
+ let opts = vec![optflagmulti("v", "verbose", "verbosity")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- assert_eq!(m.opt_count("verbose"), 4);
- assert_eq!(m.opt_count("v"), 4);
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert_eq!(m.opt_count("verbose"), 4);
+ assert_eq!(m.opt_count("v"), 4);
+ }
+ _ => panic!(),
}
}
// Tests for optmulti
#[test]
fn test_optmulti() {
- let long_args = vec!("--test=20".to_string());
- let opts = vec!(optmulti("t", "test", "testing", "TEST"));
+ let long_args = vec!["--test=20".to_string()];
+ let opts = vec![optmulti("t", "test", "testing", "TEST")];
let rs = getopts(&long_args, &opts);
match rs {
- Ok(ref m) => {
- assert!((m.opt_present("test")));
- assert_eq!(m.opt_str("test").unwrap(), "20");
- assert!((m.opt_present("t")));
- assert_eq!(m.opt_str("t").unwrap(), "20");
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert!((m.opt_present("test")));
+ assert_eq!(m.opt_str("test").unwrap(), "20");
+ assert!((m.opt_present("t")));
+ assert_eq!(m.opt_str("t").unwrap(), "20");
+ }
+ _ => panic!(),
}
- let short_args = vec!("-t".to_string(), "20".to_string());
+ let short_args = vec!["-t".to_string(), "20".to_string()];
match getopts(&short_args, &opts) {
- Ok(ref m) => {
- assert!((m.opt_present("test")));
- assert_eq!(m.opt_str("test").unwrap(), "20");
- assert!((m.opt_present("t")));
- assert_eq!(m.opt_str("t").unwrap(), "20");
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert!((m.opt_present("test")));
+ assert_eq!(m.opt_str("test").unwrap(), "20");
+ assert!((m.opt_present("t")));
+ assert_eq!(m.opt_str("t").unwrap(), "20");
+ }
+ _ => panic!(),
}
}
#[test]
fn test_optmulti_missing() {
- let args = vec!("blah".to_string());
- let opts = vec!(optmulti("t", "test", "testing", "TEST"));
+ let args = vec!["blah".to_string()];
+ let opts = vec![optmulti("t", "test", "testing", "TEST")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- assert!(!m.opt_present("test"));
- assert!(!m.opt_present("t"));
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert!(!m.opt_present("test"));
+ assert!(!m.opt_present("t"));
+ }
+ _ => panic!(),
}
}
#[test]
fn test_optmulti_no_arg() {
- let long_args = vec!("--test".to_string());
- let opts = vec!(optmulti("t", "test", "testing", "TEST"));
+ let long_args = vec!["--test".to_string()];
+ let opts = vec![optmulti("t", "test", "testing", "TEST")];
let rs = getopts(&long_args, &opts);
match rs {
- Err(ArgumentMissing(_)) => {},
- _ => panic!()
+ Err(ArgumentMissing(_)) => {}
+ _ => panic!(),
}
- let short_args = vec!("-t".to_string());
+ let short_args = vec!["-t".to_string()];
match getopts(&short_args, &opts) {
- Err(ArgumentMissing(_)) => {},
- _ => panic!()
+ Err(ArgumentMissing(_)) => {}
+ _ => panic!(),
}
}
#[test]
fn test_optmulti_multi() {
- let args = vec!("--test=20".to_string(), "-t".to_string(), "30".to_string());
- let opts = vec!(optmulti("t", "test", "testing", "TEST"));
+ let args = vec!["--test=20".to_string(), "-t".to_string(), "30".to_string()];
+ let opts = vec![optmulti("t", "test", "testing", "TEST")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- assert!(m.opt_present("test"));
- assert_eq!(m.opt_str("test").unwrap(), "20");
- assert!(m.opt_present("t"));
- assert_eq!(m.opt_str("t").unwrap(), "20");
- let pair = m.opt_strs("test");
- assert!(pair[0] == "20");
- assert!(pair[1] == "30");
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert!(m.opt_present("test"));
+ assert_eq!(m.opt_str("test").unwrap(), "20");
+ assert!(m.opt_present("t"));
+ assert_eq!(m.opt_str("t").unwrap(), "20");
+ let pair = m.opt_strs("test");
+ assert!(pair[0] == "20");
+ assert!(pair[1] == "30");
+ }
+ _ => panic!(),
}
}
#[test]
fn test_unrecognized_option() {
- let long_args = vec!("--untest".to_string());
- let opts = vec!(optmulti("t", "test", "testing", "TEST"));
+ let long_args = vec!["--untest".to_string()];
+ let opts = vec![optmulti("t", "test", "testing", "TEST")];
let rs = getopts(&long_args, &opts);
match rs {
- Err(UnrecognizedOption(_)) => {},
- _ => panic!()
+ Err(UnrecognizedOption(_)) => {}
+ _ => panic!(),
}
- let short_args = vec!("-u".to_string());
+ let short_args = vec!["-u".to_string()];
match getopts(&short_args, &opts) {
- Err(UnrecognizedOption(_)) => {},
- _ => panic!()
+ Err(UnrecognizedOption(_)) => {}
+ _ => panic!(),
}
}
#[test]
fn test_combined() {
- let args =
- vec!("prog".to_string(),
- "free1".to_string(),
- "-s".to_string(),
- "20".to_string(),
- "free2".to_string(),
- "--flag".to_string(),
- "--long=30".to_string(),
- "-f".to_string(),
- "-m".to_string(),
- "40".to_string(),
- "-m".to_string(),
- "50".to_string(),
- "-n".to_string(),
- "-A B".to_string(),
- "-n".to_string(),
- "-60 70".to_string());
- let opts =
- vec!(optopt("s", "something", "something", "SOMETHING"),
- optflag("", "flag", "a flag"),
- reqopt("", "long", "hi", "LONG"),
- optflag("f", "", "another flag"),
- optmulti("m", "", "mmmmmm", "YUM"),
- optmulti("n", "", "nothing", "NOTHING"),
- optopt("", "notpresent", "nothing to see here", "NOPE"));
+ let args = vec!["prog".to_string(),
+ "free1".to_string(),
+ "-s".to_string(),
+ "20".to_string(),
+ "free2".to_string(),
+ "--flag".to_string(),
+ "--long=30".to_string(),
+ "-f".to_string(),
+ "-m".to_string(),
+ "40".to_string(),
+ "-m".to_string(),
+ "50".to_string(),
+ "-n".to_string(),
+ "-A B".to_string(),
+ "-n".to_string(),
+ "-60 70".to_string()];
+ let opts = vec![optopt("s", "something", "something", "SOMETHING"),
+ optflag("", "flag", "a flag"),
+ reqopt("", "long", "hi", "LONG"),
+ optflag("f", "", "another flag"),
+ optmulti("m", "", "mmmmmm", "YUM"),
+ optmulti("n", "", "nothing", "NOTHING"),
+ optopt("", "notpresent", "nothing to see here", "NOPE")];
let rs = getopts(&args, &opts);
match rs {
- Ok(ref m) => {
- assert!(m.free[0] == "prog");
- assert!(m.free[1] == "free1");
- assert_eq!(m.opt_str("s").unwrap(), "20");
- assert!(m.free[2] == "free2");
- assert!((m.opt_present("flag")));
- assert_eq!(m.opt_str("long").unwrap(), "30");
- assert!((m.opt_present("f")));
- let pair = m.opt_strs("m");
- assert!(pair[0] == "40");
- assert!(pair[1] == "50");
- let pair = m.opt_strs("n");
- assert!(pair[0] == "-A B");
- assert!(pair[1] == "-60 70");
- assert!((!m.opt_present("notpresent")));
- }
- _ => panic!()
+ Ok(ref m) => {
+ assert!(m.free[0] == "prog");
+ assert!(m.free[1] == "free1");
+ assert_eq!(m.opt_str("s").unwrap(), "20");
+ assert!(m.free[2] == "free2");
+ assert!((m.opt_present("flag")));
+ assert_eq!(m.opt_str("long").unwrap(), "30");
+ assert!((m.opt_present("f")));
+ let pair = m.opt_strs("m");
+ assert!(pair[0] == "40");
+ assert!(pair[1] == "50");
+ let pair = m.opt_strs("n");
+ assert!(pair[0] == "-A B");
+ assert!(pair[1] == "-60 70");
+ assert!((!m.opt_present("notpresent")));
+ }
+ _ => panic!(),
}
}
#[test]
fn test_multi() {
- let opts = vec!(optopt("e", "", "encrypt", "ENCRYPT"),
- optopt("", "encrypt", "encrypt", "ENCRYPT"),
- optopt("f", "", "flag", "FLAG"));
+ let opts = vec![optopt("e", "", "encrypt", "ENCRYPT"),
+ optopt("", "encrypt", "encrypt", "ENCRYPT"),
+ optopt("f", "", "flag", "FLAG")];
- let args_single = vec!("-e".to_string(), "foo".to_string());
+ let args_single = vec!["-e".to_string(), "foo".to_string()];
let matches_single = &match getopts(&args_single, &opts) {
- result::Result::Ok(m) => m,
- result::Result::Err(_) => panic!()
+ result::Result::Ok(m) => m,
+ result::Result::Err(_) => panic!(),
};
assert!(matches_single.opts_present(&["e".to_string()]));
assert!(matches_single.opts_present(&["encrypt".to_string(), "e".to_string()]));
assert_eq!(matches_single.opts_str(&["encrypt".to_string(), "e".to_string()]).unwrap(),
"foo");
- let args_both = vec!("-e".to_string(), "foo".to_string(), "--encrypt".to_string(),
- "foo".to_string());
+ let args_both = vec!["-e".to_string(),
+ "foo".to_string(),
+ "--encrypt".to_string(),
+ "foo".to_string()];
let matches_both = &match getopts(&args_both, &opts) {
- result::Result::Ok(m) => m,
- result::Result::Err(_) => panic!()
+ result::Result::Ok(m) => m,
+ result::Result::Err(_) => panic!(),
};
assert!(matches_both.opts_present(&["e".to_string()]));
assert!(matches_both.opts_present(&["encrypt".to_string()]));
assert!(!matches_both.opts_present(&[]));
assert_eq!(matches_both.opts_str(&["e".to_string()]).unwrap(), "foo");
- assert_eq!(matches_both.opts_str(&["encrypt".to_string()]).unwrap(), "foo");
+ assert_eq!(matches_both.opts_str(&["encrypt".to_string()]).unwrap(),
+ "foo");
assert_eq!(matches_both.opts_str(&["e".to_string(), "encrypt".to_string()]).unwrap(),
"foo");
assert_eq!(matches_both.opts_str(&["encrypt".to_string(), "e".to_string()]).unwrap(),
#[test]
fn test_nospace() {
- let args = vec!("-Lfoo".to_string(), "-M.".to_string());
- let opts = vec!(optmulti("L", "", "library directory", "LIB"),
- optmulti("M", "", "something", "MMMM"));
+ let args = vec!["-Lfoo".to_string(), "-M.".to_string()];
+ let opts = vec![optmulti("L", "", "library directory", "LIB"),
+ optmulti("M", "", "something", "MMMM")];
let matches = &match getopts(&args, &opts) {
- result::Result::Ok(m) => m,
- result::Result::Err(_) => panic!()
+ result::Result::Ok(m) => m,
+ result::Result::Err(_) => panic!(),
};
assert!(matches.opts_present(&["L".to_string()]));
assert_eq!(matches.opts_str(&["L".to_string()]).unwrap(), "foo");
#[test]
fn test_nospace_conflict() {
- let args = vec!("-vvLverbose".to_string(), "-v".to_string() );
- let opts = vec!(optmulti("L", "", "library directory", "LIB"),
- optflagmulti("v", "verbose", "Verbose"));
+ let args = vec!["-vvLverbose".to_string(), "-v".to_string()];
+ let opts = vec![optmulti("L", "", "library directory", "LIB"),
+ optflagmulti("v", "verbose", "Verbose")];
let matches = &match getopts(&args, &opts) {
- result::Result::Ok(m) => m,
- result::Result::Err(e) => panic!( "{}", e )
+ result::Result::Ok(m) => m,
+ result::Result::Err(e) => panic!("{}", e),
};
assert!(matches.opts_present(&["L".to_string()]));
assert_eq!(matches.opts_str(&["L".to_string()]).unwrap(), "verbose");
occur: Occur::Req,
aliases: Vec::new(),
};
- short.aliases = vec!(Opt { name: Name::Short('b'),
- hasarg: HasArg::Yes,
- occur: Occur::Req,
- aliases: Vec::new() });
+ short.aliases = vec![Opt {
+ name: Name::Short('b'),
+ hasarg: HasArg::Yes,
+ occur: Occur::Req,
+ aliases: Vec::new(),
+ }];
let verbose = reqopt("b", "banana", "some bananas", "VAL");
assert!(verbose.long_to_short() == short);
#[test]
fn test_aliases_long_and_short() {
- let opts = vec!(
- optflagmulti("a", "apple", "Desc"));
+ let opts = vec![optflagmulti("a", "apple", "Desc")];
- let args = vec!("-a".to_string(), "--apple".to_string(), "-a".to_string());
+ let args = vec!["-a".to_string(), "--apple".to_string(), "-a".to_string()];
let matches = getopts(&args, &opts).unwrap();
assert_eq!(3, matches.opt_count("a"));
#[test]
fn test_usage() {
- let optgroups = vec!(
- reqopt("b", "banana", "Desc", "VAL"),
- optopt("a", "012345678901234567890123456789",
- "Desc", "VAL"),
- optflag("k", "kiwi", "Desc"),
- optflagopt("p", "", "Desc", "VAL"),
- optmulti("l", "", "Desc", "VAL"));
+ let optgroups = vec![reqopt("b", "banana", "Desc", "VAL"),
+ optopt("a", "012345678901234567890123456789", "Desc", "VAL"),
+ optflag("k", "kiwi", "Desc"),
+ optflagopt("p", "", "Desc", "VAL"),
+ optmulti("l", "", "Desc", "VAL")];
let expected =
"Usage: fruits
// indentation should be 24 spaces
// lines wrap after 78: or rather descriptions wrap after 54
- let optgroups = vec!(
- optflag("k", "kiwi",
- "This is a long description which won't be wrapped..+.."), // 54
- optflag("a", "apple",
- "This is a long description which _will_ be wrapped..+.."));
+ let optgroups = vec![optflag("k",
+ "kiwi",
+ // 54
+ "This is a long description which won't be wrapped..+.."),
+ optflag("a",
+ "apple",
+ "This is a long description which _will_ be wrapped..+..")];
let expected =
"Usage: fruits
#[test]
fn test_usage_description_multibyte_handling() {
- let optgroups = vec!(
- optflag("k", "k\u{2013}w\u{2013}",
- "The word kiwi is normally spelled with two i's"),
- optflag("a", "apple",
- "This \u{201C}description\u{201D} has some characters that could \
-confuse the line wrapping; an apple costs 0.51€ in some parts of Europe."));
+ let optgroups = vec![optflag("k",
+ "k\u{2013}w\u{2013}",
+ "The word kiwi is normally spelled with two i's"),
+ optflag("a",
+ "apple",
+ "This \u{201C}description\u{201D} has some characters that \
+ could confuse the line wrapping; an apple costs 0.51€ in \
+ some parts of Europe.")];
let expected =
"Usage: fruits
#[test]
fn test_short_usage() {
- let optgroups = vec!(
- reqopt("b", "banana", "Desc", "VAL"),
- optopt("a", "012345678901234567890123456789",
- "Desc", "VAL"),
- optflag("k", "kiwi", "Desc"),
- optflagopt("p", "", "Desc", "VAL"),
- optmulti("l", "", "Desc", "VAL"));
+ let optgroups = vec![reqopt("b", "banana", "Desc", "VAL"),
+ optopt("a", "012345678901234567890123456789", "Desc", "VAL"),
+ optflag("k", "kiwi", "Desc"),
+ optflagopt("p", "", "Desc", "VAL"),
+ optmulti("l", "", "Desc", "VAL")];
let expected = "Usage: fruits -b VAL [-a VAL] [-k] [-p [VAL]] [-l VAL]..".to_string();
let generated_usage = short_usage("fruits", &optgroups);
debug!("generated: <<{}>>", generated_usage);
assert_eq!(generated_usage, expected);
}
+
+ #[test]
+ fn test_args_with_equals() {
+ let args = vec!("--one".to_string(), "A=B".to_string(),
+ "--two=C=D".to_string());
+ let opts = vec![optopt("o", "one", "One", "INFO"),
+ optopt("t", "two", "Two", "INFO")];
+ let matches = &match getopts(&args, &opts) {
+ result::Result::Ok(m) => m,
+ result::Result::Err(e) => panic!("{}", e)
+ };
+ assert_eq!(matches.opts_str(&["o".to_string()]).unwrap(), "A=B");
+ assert_eq!(matches.opts_str(&["t".to_string()]).unwrap(), "C=D");
+ }
}
projects / rustc.git / blobdiff