diff options
| -rw-r--r-- | mk/crates.mk | 12 | ||||
| -rw-r--r-- | src/compiletest/compiletest.rs | 12 | ||||
| -rw-r--r-- | src/doc/index.md | 1 | ||||
| -rw-r--r-- | src/libextra/lib.rs | 1 | ||||
| -rw-r--r-- | src/libextra/test.rs | 27 | ||||
| -rw-r--r-- | src/libgetopts/lib.rs (renamed from src/libextra/getopts.rs) | 1265 | ||||
| -rw-r--r-- | src/librustc/driver/driver.rs | 8 | ||||
| -rw-r--r-- | src/librustc/lib.rs | 7 | ||||
| -rw-r--r-- | src/librustc/middle/typeck/infer/test.rs | 7 | ||||
| -rw-r--r-- | src/librustdoc/lib.rs | 11 | ||||
| -rw-r--r-- | src/librustdoc/test.rs | 2 | ||||
| -rw-r--r-- | src/test/bench/shootout-pfib.rs | 5 | ||||
| -rw-r--r-- | src/test/run-pass/getopts_ref.rs | 6 |
13 files changed, 558 insertions, 806 deletions
diff --git a/mk/crates.mk b/mk/crates.mk index ea573b9db8d..65fb2425764 100644 --- a/mk/crates.mk +++ b/mk/crates.mk @@ -49,19 +49,20 @@ # automatically generated for all stage/host/target combinations. ################################################################################ -TARGET_CRATES := std extra green rustuv native flate arena glob term semver uuid serialize sync +TARGET_CRATES := std extra green rustuv native flate arena glob term semver \ + uuid serialize sync getopts HOST_CRATES := syntax rustc rustdoc CRATES := $(TARGET_CRATES) $(HOST_CRATES) TOOLS := compiletest rustdoc rustc DEPS_std := native:rustrt -DEPS_extra := std serialize sync term +DEPS_extra := std term sync serialize getopts DEPS_green := std DEPS_rustuv := std native:uv native:uv_support DEPS_native := std DEPS_syntax := std extra term serialize -DEPS_rustc := syntax native:rustllvm flate arena serialize sync -DEPS_rustdoc := rustc native:sundown serialize sync +DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts +DEPS_rustdoc := rustc native:sundown serialize sync getopts DEPS_flate := std native:miniz DEPS_arena := std extra DEPS_glob := std @@ -70,8 +71,9 @@ DEPS_term := std DEPS_semver := std DEPS_uuid := std serialize DEPS_sync := std +DEPS_getopts := std -TOOL_DEPS_compiletest := extra green rustuv +TOOL_DEPS_compiletest := extra green rustuv getopts TOOL_DEPS_rustdoc := rustdoc green rustuv TOOL_DEPS_rustc := rustc green rustuv TOOL_SOURCE_compiletest := $(S)src/compiletest/compiletest.rs diff --git a/src/compiletest/compiletest.rs b/src/compiletest/compiletest.rs index 8896b44f060..b3151ac99b2 100644 --- a/src/compiletest/compiletest.rs +++ b/src/compiletest/compiletest.rs @@ -14,13 +14,13 @@ #[deny(warnings)]; extern mod extra; +extern mod getopts; use std::os; use std::io; use std::io::fs; -use extra::getopts; -use extra::getopts::groups::{optopt, optflag, reqopt}; +use getopts::{optopt, optflag, reqopt}; use extra::test; use common::config; @@ -49,7 +49,7 @@ pub fn main() { pub fn parse_config(args: ~[~str]) -> config { - let groups : ~[getopts::groups::OptGroup] = + let groups : ~[getopts::OptGroup] = ~[reqopt("", "compile-lib-path", "path to host shared libraries", "PATH"), reqopt("", "run-lib-path", "path to target shared libraries", "PATH"), reqopt("", "rustc-path", "path to rustc to use for compiling", "PATH"), @@ -85,20 +85,20 @@ pub fn parse_config(args: ~[~str]) -> config { let args_ = args.tail(); if args[1] == ~"-h" || args[1] == ~"--help" { let message = format!("Usage: {} [OPTIONS] [TESTNAME...]", argv0); - println!("{}", getopts::groups::usage(message, groups)); + println!("{}", getopts::usage(message, groups)); println!(""); fail!() } let matches = - &match getopts::groups::getopts(args_, groups) { + &match getopts::getopts(args_, groups) { Ok(m) => m, Err(f) => fail!("{}", f.to_err_msg()) }; if matches.opt_present("h") || matches.opt_present("help") { let message = format!("Usage: {} [OPTIONS] [TESTNAME...]", argv0); - println!("{}", getopts::groups::usage(message, groups)); + println!("{}", getopts::usage(message, groups)); println!(""); fail!() } diff --git a/src/doc/index.md b/src/doc/index.md index 54b8b484693..39dc196b6a0 100644 --- a/src/doc/index.md +++ b/src/doc/index.md @@ -39,6 +39,7 @@ li {list-style-type: none; } * [The `arena` allocation library](arena/index.html) * [The `flate` compression library](flate/index.html) +* [The `getopts` argument parsing library](getopts/index.html) * [The `glob` file path matching library](glob/index.html) * [The `semver` version collation library](semver/index.html) * [The `serialize` value encoding/decoding library](serialize/index.html) diff --git a/src/libextra/lib.rs b/src/libextra/lib.rs index 37b4d3cc524..97c38a59af8 100644 --- a/src/libextra/lib.rs +++ b/src/libextra/lib.rs @@ -73,7 +73,6 @@ pub mod lru_cache; // And ... other stuff pub mod url; -pub mod getopts; pub mod json; pub mod tempfile; pub mod time; diff --git a/src/libextra/test.rs b/src/libextra/test.rs index c4d27b25b55..4af0fa16233 100644 --- a/src/libextra/test.rs +++ b/src/libextra/test.rs @@ -15,10 +15,9 @@ // simplest interface possible for representing and running tests // while providing a base that other test frameworks may build off of. +extern mod getopts; extern mod term; -use getopts; -use getopts::groups; use json::ToJson; use json; use serialize::Decodable; @@ -209,29 +208,29 @@ pub struct TestOpts { /// Result of parsing the options. pub type OptRes = Result<TestOpts, ~str>; -fn optgroups() -> ~[getopts::groups::OptGroup] { - ~[groups::optflag("", "ignored", "Run ignored tests"), - groups::optflag("", "test", "Run tests and not benchmarks"), - groups::optflag("", "bench", "Run benchmarks instead of tests"), - groups::optflag("h", "help", "Display this message (longer with --help)"), - groups::optopt("", "save-metrics", "Location to save bench metrics", +fn optgroups() -> ~[getopts::OptGroup] { + ~[getopts::optflag("", "ignored", "Run ignored tests"), + getopts::optflag("", "test", "Run tests and not benchmarks"), + getopts::optflag("", "bench", "Run benchmarks instead of tests"), + getopts::optflag("h", "help", "Display this message (longer with --help)"), + getopts::optopt("", "save-metrics", "Location to save bench metrics", "PATH"), - groups::optopt("", "ratchet-metrics", + getopts::optopt("", "ratchet-metrics", "Location to load and save metrics from. The metrics \ loaded are cause benchmarks to fail if they run too \ slowly", "PATH"), - groups::optopt("", "ratchet-noise-percent", + getopts::optopt("", "ratchet-noise-percent", "Tests within N% of the recorded metrics will be \ considered as passing", "PERCENTAGE"), - groups::optopt("", "logfile", "Write logs to the specified file instead \ + getopts::optopt("", "logfile", "Write logs to the specified file instead \ of stdout", "PATH"), - groups::optopt("", "test-shard", "run shard A, of B shards, worth of the testsuite", + getopts::optopt("", "test-shard", "run shard A, of B shards, worth of the testsuite", "A.B")] } fn usage(binary: &str, helpstr: &str) { let message = format!("Usage: {} [OPTIONS] [FILTER]", binary); - println!("{}", groups::usage(message, optgroups())); + println!("{}", getopts::usage(message, optgroups())); println!(""); if helpstr == "help" { println!("{}", "\ @@ -261,7 +260,7 @@ Test Attributes: pub fn parse_opts(args: &[~str]) -> Option<OptRes> { let args_ = args.tail(); let matches = - match groups::getopts(args_, optgroups()) { + match getopts::getopts(args_, optgroups()) { Ok(m) => m, Err(f) => return Some(Err(f.to_err_msg())) }; diff --git a/src/libextra/getopts.rs b/src/libgetopts/lib.rs index f29caec5d33..e5e7c50d2ce 100644 --- a/src/libextra/getopts.rs +++ b/src/libgetopts/lib.rs @@ -30,8 +30,8 @@ //! file name following `-o`, and accepts both `-h` and `--help` as optional flags. //! //! ~~~{.rust} -//! extern mod extra; -//! use extra::getopts::{optopt,optflag,getopts,Opt}; +//! extern mod getopts; +//! use getopts::{optopt,optflag,getopts,OptGroup}; //! use std::os; //! //! fn do_work(inp: &str, out: Option<~str>) { @@ -42,7 +42,7 @@ //! } //! } //! -//! fn print_usage(program: &str, _opts: &[Opt]) { +//! fn print_usage(program: &str, _opts: &[OptGroup]) { //! println!("Usage: {} [options]", program); //! println!("-o\t\tOutput"); //! println!("-h --help\tUsage"); @@ -54,15 +54,14 @@ //! let program = args[0].clone(); //! //! let opts = ~[ -//! optopt("o"), -//! optflag("h"), -//! optflag("help") +//! optopt("o", "", "set output file name", "NAME"), +//! optflag("h", "help", "print this help menu") //! ]; //! let matches = match getopts(args.tail(), opts) { //! Ok(m) => { m } //! Err(f) => { fail!(f.to_err_msg()) } //! }; -//! if matches.opt_present("h") || matches.opt_present("help") { +//! if matches.opt_present("h") { //! print_usage(program, opts); //! return; //! } @@ -77,6 +76,14 @@ //! } //! ~~~ +#[crate_id = "getopts#0.10-pre"]; +#[crate_type = "rlib"]; +#[crate_type = "dylib"]; +#[license = "MIT/ASL2"]; +#[allow(missing_doc)]; + +#[feature(globs)]; + use std::cmp::Eq; use std::result::{Err, Ok}; use std::result; @@ -122,6 +129,24 @@ pub struct Opt { priv aliases: ~[Opt], } +/// One group of options, e.g., both -h and --help, along with +/// their shared description and properties. +#[deriving(Clone, Eq)] +pub struct OptGroup { + /// Short Name of the `OptGroup` + short_name: ~str, + /// Long Name of the `OptGroup` + long_name: ~str, + /// Hint + hint: ~str, + /// Description + desc: ~str, + /// Whether it has an argument + hasarg: HasArg, + /// How often it can occur + occur: Occur +} + /// Describes wether an option is given at all or has a value. #[deriving(Clone, Eq)] enum Optval { @@ -185,6 +210,50 @@ impl Name { } } +impl OptGroup { + /// Translate OptGroup into Opt. + /// (Both short and long names correspond to different Opts). + pub fn long_to_short(&self) -> Opt { + let OptGroup { + short_name: short_name, + long_name: long_name, + hasarg: hasarg, + occur: occur, + .. + } = (*self).clone(); + + match (short_name.len(), long_name.len()) { + (0,0) => fail!("this long-format option was given no name"), + (0,_) => Opt { + name: Long((long_name)), + hasarg: hasarg, + occur: occur, + aliases: ~[] + }, + (1,0) => Opt { + name: Short(short_name.char_at(0)), + hasarg: hasarg, + occur: occur, + aliases: ~[] + }, + (1,_) => Opt { + name: Long((long_name)), + hasarg: hasarg, + occur: occur, + aliases: ~[ + Opt { + name: Short(short_name.char_at(0)), + hasarg: hasarg, + occur: occur, + aliases: ~[] + } + ] + }, + (_,_) => fail!("something is wrong with the long-form opt") + } + } +} + impl Matches { fn opt_vals(&self, nm: &str) -> ~[Optval] { match find_opt(self.opts, Name::from_str(nm)) { @@ -300,65 +369,89 @@ fn find_opt(opts: &[Opt], nm: Name) -> Option<uint> { None } -/// Create an option that is required and takes an argument. -pub fn reqopt(name: &str) -> Opt { - Opt { - name: Name::from_str(name), +/// Create a long option that is required and takes an argument. +pub fn reqopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { + let len = short_name.len(); + assert!(len == 1 || len == 0); + OptGroup { + short_name: short_name.to_owned(), + long_name: long_name.to_owned(), + hint: hint.to_owned(), + desc: desc.to_owned(), hasarg: Yes, - occur: Req, - aliases: ~[] + occur: Req } } -/// Create an option that is optional and takes an argument. -pub fn optopt(name: &str) -> Opt { - Opt { - name: Name::from_str(name), +/// Create a long option that is optional and takes an argument. +pub fn optopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { + let len = short_name.len(); + assert!(len == 1 || len == 0); + OptGroup { + short_name: short_name.to_owned(), + long_name: long_name.to_owned(), + hint: hint.to_owned(), + desc: desc.to_owned(), hasarg: Yes, - occur: Optional, - aliases: ~[] + occur: Optional } } -/// Create an option that is optional and does not take an argument. -pub fn optflag(name: &str) -> Opt { - Opt { - name: Name::from_str(name), +/// Create a long option that is optional and does not take an argument. +pub fn optflag(short_name: &str, long_name: &str, desc: &str) -> OptGroup { + let len = short_name.len(); + assert!(len == 1 || len == 0); + OptGroup { + short_name: short_name.to_owned(), + long_name: long_name.to_owned(), + hint: ~"", + desc: desc.to_owned(), hasarg: No, - occur: Optional, - aliases: ~[] + occur: Optional } } -/// Create an option that is optional, does not take an argument, -/// and may occur multiple times. -pub fn optflagmulti(name: &str) -> Opt { - Opt { - name: Name::from_str(name), +/// Create a long option that can occur more than once and does not +/// take an argument. +pub fn optflagmulti(short_name: &str, long_name: &str, desc: &str) -> OptGroup { + let len = short_name.len(); + assert!(len == 1 || len == 0); + OptGroup { + short_name: short_name.to_owned(), + long_name: long_name.to_owned(), + hint: ~"", + desc: desc.to_owned(), hasarg: No, - occur: Multi, - aliases: ~[] + occur: Multi } } -/// Create an option that is optional and takes an optional argument. -pub fn optflagopt(name: &str) -> Opt { - Opt { - name: Name::from_str(name), +/// Create a long option that is optional and takes an optional argument. +pub fn optflagopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { + let len = short_name.len(); + assert!(len == 1 || len == 0); + OptGroup { + short_name: short_name.to_owned(), + long_name: long_name.to_owned(), + hint: hint.to_owned(), + desc: desc.to_owned(), hasarg: Maybe, - occur: Optional, - aliases: ~[] + occur: Optional } } -/// Create an option that is optional, takes an argument, and may occur +/// Create a long option that is optional, takes an argument, and may occur /// multiple times. -pub fn optmulti(name: &str) -> Opt { - Opt { - name: Name::from_str(name), +pub fn optmulti(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { + let len = short_name.len(); + assert!(len == 1 || len == 0); + OptGroup { + short_name: short_name.to_owned(), + long_name: long_name.to_owned(), + hint: hint.to_owned(), + desc: desc.to_owned(), hasarg: Yes, - occur: Multi, - aliases: ~[] + occur: Multi } } @@ -390,7 +483,8 @@ impl Fail_ { /// On success returns `Ok(Opt)`. Use methods such as `opt_present` /// `opt_str`, etc. to interrogate results. Returns `Err(Fail_)` on failure. /// Use `to_err_msg` to get an error message. -pub fn getopts(args: &[~str], opts: &[Opt]) -> Result { +pub fn getopts(args: &[~str], optgrps: &[OptGroup]) -> Result { + let opts = optgrps.map(|x| x.long_to_short()); let n_opts = opts.len(); fn f(_x: uint) -> ~[Optval] { return ~[]; } @@ -516,393 +610,232 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result { }) } -/// A module which provides a way to specify descriptions and -/// groups of short and long option names, together. -pub mod groups { - use getopts::{HasArg, Long, Maybe, Multi, No, Occur, Opt, Optional, Req}; - use getopts::{Short, Yes}; - - /// One group of options, e.g., both -h and --help, along with - /// their shared description and properties. - #[deriving(Clone, Eq)] - pub struct OptGroup { - /// Short Name of the `OptGroup` - short_name: ~str, - /// Long Name of the `OptGroup` - long_name: ~str, - /// Hint - hint: ~str, - /// Description - desc: ~str, - /// Whether it has an argument - hasarg: HasArg, - /// How often it can occur - occur: Occur - } - - impl OptGroup { - /// Translate OptGroup into Opt. - /// (Both short and long names correspond to different Opts). - pub fn long_to_short(&self) -> Opt { - let OptGroup { - short_name: short_name, - long_name: long_name, - hasarg: hasarg, - occur: occur, - .. - } = (*self).clone(); - - match (short_name.len(), long_name.len()) { - (0,0) => fail!("this long-format option was given no name"), - (0,_) => Opt { - name: Long((long_name)), - hasarg: hasarg, - occur: occur, - aliases: ~[] - }, - (1,0) => Opt { - name: Short(short_name.char_at(0)), - hasarg: hasarg, - occur: occur, - aliases: ~[] - }, - (1,_) => Opt { - name: Long((long_name)), - hasarg: hasarg, - occur: occur, - aliases: ~[ - Opt { - name: Short(short_name.char_at(0)), - hasarg: hasarg, - occur: occur, - aliases: ~[] - } - ] - }, - (_,_) => fail!("something is wrong with the long-form opt") - } - } - } +/// Derive a usage message from a set of long options. +pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str { - /// Create a long option that is required and takes an argument. - pub fn reqopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { - let len = short_name.len(); - assert!(len == 1 || len == 0); - OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: hint.to_owned(), - desc: desc.to_owned(), - hasarg: Yes, - occur: Req - } - } + let desc_sep = "\n" + " ".repeat(24); - /// Create a long option that is optional and takes an argument. - pub fn optopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { - let len = short_name.len(); - assert!(len == 1 || len == 0); - OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: hint.to_owned(), - desc: desc.to_owned(), - hasarg: Yes, - occur: Optional - } - } + let mut rows = opts.iter().map(|optref| { + let OptGroup{short_name: short_name, + long_name: long_name, + hint: hint, + desc: desc, + hasarg: hasarg, + ..} = (*optref).clone(); - /// Create a long option that is optional and does not take an argument. - pub fn optflag(short_name: &str, long_name: &str, desc: &str) -> OptGroup { - let len = short_name.len(); - assert!(len == 1 || len == 0); - OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: ~"", - desc: desc.to_owned(), - hasarg: No, - occur: Optional - } - } + let mut row = " ".repeat(4); - /// Create a long option that can occur more than once and does not - /// take an argument. - pub fn optflagmulti(short_name: &str, long_name: &str, desc: &str) -> OptGroup { - let len = short_name.len(); - assert!(len == 1 || len == 0); - OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: ~"", - desc: desc.to_owned(), - hasarg: No, - occur: Multi - } - } - - /// Create a long option that is optional and takes an optional argument. - pub fn optflagopt(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { - let len = short_name.len(); - assert!(len == 1 || len == 0); - OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: hint.to_owned(), - desc: desc.to_owned(), - hasarg: Maybe, - occur: Optional - } - } - - /// Create a long option that is optional, takes an argument, and may occur - /// multiple times. - pub fn optmulti(short_name: &str, long_name: &str, desc: &str, hint: &str) -> OptGroup { - let len = short_name.len(); - assert!(len == 1 || len == 0); - OptGroup { - short_name: short_name.to_owned(), - long_name: long_name.to_owned(), - hint: hint.to_owned(), - desc: desc.to_owned(), - hasarg: Yes, - occur: Multi + // short option + match short_name.len() { + 0 => {} + 1 => { + row.push_char('-'); + row.push_str(short_name); + row.push_char(' '); + } + _ => fail!("the short name should only be 1 ascii char long"), } - } - /// Parse command line args with the provided long format options. - pub fn getopts(args: &[~str], opts: &[OptGroup]) -> ::getopts::Result { - ::getopts::getopts(args, opts.map(|x| x.long_to_short())) - } - - fn format_option(opt: &OptGroup) -> ~str { - let mut line = ~""; - - if opt.occur != Req { - line.push_char('['); + // long option + match long_name.len() { + 0 => {} + _ => { + row.push_str("--"); + row.push_str(long_name); + row.push_char(' '); + } } - // Use short_name is possible, but fallback to long_name. - if opt.short_name.len() > 0 { - line.push_char('-'); - line.push_str(opt.short_name); - } else { - line.push_str("--"); - line.push_str(opt.long_name); + // arg + match hasarg { + No => {} + Yes => row.push_str(hint), + Maybe => { + row.push_char('['); + row.push_str(hint); + row.push_char(']'); + } } - if opt.hasarg != No { - line.push_char(' '); - if opt.hasarg == Maybe { - line.push_char('['); - } - line.push_str(opt.hint); - if opt.hasarg == Maybe { - line.push_char(']'); + // FIXME: #5516 should be graphemes not codepoints + // here we just need to indent the start of the description + let rowlen = row.char_len(); + if rowlen < 24 { + for _ in range(0, 24 - rowlen) { + row.push_char(' '); } + } else { + row.push_str(desc_sep) } - if opt.occur != Req { - line.push_char(']'); - } - if opt.occur == Multi { - line.push_str(".."); + // Normalize desc to contain words separated by one space character + let mut desc_normalized_whitespace = ~""; + for word in desc.words() { + desc_normalized_whitespace.push_str(word); + desc_normalized_whitespace.push_char(' '); } - line - } - - /// Derive a short one-line usage summary from a set of long options. - pub fn short_usage(program_name: &str, opts: &[OptGroup]) -> ~str { - let mut line = ~"Usage: " + program_name + " "; - line.push_str(opts.iter().map(format_option).to_owned_vec().connect(" ")); - - line - } - - /// Derive a usage message from a set of long options. - pub fn usage(brief: &str, opts: &[OptGroup]) -> ~str { - - let desc_sep = "\n" + " ".repeat(24); - - let mut rows = opts.iter().map(|optref| { - let OptGroup{short_name: short_name, - long_name: long_name, - hint: hint, - desc: desc, - hasarg: hasarg, - ..} = (*optref).clone(); - - let mut row = " ".repeat(4); - - // short option - match short_name.len() { - 0 => {} - 1 => { - row.push_char('-'); - row.push_str(short_name); - row.push_char(' '); - } - _ => fail!("the short name should only be 1 ascii char long"), - } + // FIXME: #5516 should be graphemes not codepoints + let mut desc_rows = ~[]; + each_split_within(desc_normalized_whitespace, 54, |substr| { + desc_rows.push(substr.to_owned()); + true + }); - // long option - match long_name.len() { - 0 => {} - _ => { - row.push_str("--"); - row.push_str(long_name); - row.push_char(' '); - } - } + // FIXME: #5516 should be graphemes not codepoints + // wrapped description + row.push_str(desc_rows.connect(desc_sep)); - // arg - match hasarg { - No => {} - Yes => row.push_str(hint), - Maybe => { - row.push_char('['); - row.push_str(hint); - row.push_char(']'); - } - } + row + }); - // FIXME: #5516 should be graphemes not codepoints - // here we just need to indent the start of the description - let rowlen = row.char_len(); - if rowlen < 24 { - for _ in range(0, 24 - rowlen) { - row.push_char(' '); - } - } else { - row.push_str(desc_sep) - } - - // Normalize desc to contain words separated by one space character - let mut desc_normalized_whitespace = ~""; - for word in desc.words() { - desc_normalized_whitespace.push_str(word); - desc_normalized_whitespace.push_char(' '); - } - - // FIXME: #5516 should be graphemes not codepoints - let mut desc_rows = ~[]; - each_split_within(desc_normalized_whitespace, 54, |substr| { - desc_rows.push(substr.to_owned()); - true - }); + format!("{}\n\nOptions:\n{}\n", brief, rows.collect::<~[~str]>().connect("\n")) +} - // FIXME: #5516 should be graphemes not codepoints - // wrapped description - row.push_str(desc_rows.connect(desc_sep)); +fn format_option(opt: &OptGroup) -> ~str { + let mut line = ~""; - row - }); + if opt.occur != Req { + line.push_char('['); + } - format!("{}\n\nOptions:\n{}\n", brief, rows.collect::<~[~str]>().connect("\n")) + // Use short_name is possible, but fallback to long_name. + if opt.short_name.len() > 0 { + line.push_char('-'); + line.push_str(opt.short_name); + } else { + line.push_str("--"); + line.push_str(opt.long_name); } - /// Splits a string into substrings with possibly internal whitespace, - /// each of them at most `lim` bytes long. The substrings have leading and trailing - /// whitespace removed, and are only cut at whitespace boundaries. - /// - /// Note: Function was moved here from `std::str` because this module is the only place that - /// uses it, and because it was to specific for a general string function. - /// - /// #Failure: - /// - /// Fails during iteration if the string contains a non-whitespace - /// sequence longer than the limit. - fn each_split_within<'a>(ss: &'a str, lim: uint, it: |&'a str| -> bool) - -> bool { - // Just for fun, let's write this as a state machine: - - enum SplitWithinState { - A, // leading whitespace, initial state - B, // words - C, // internal and trailing whitespace - } - enum Whitespace { - Ws, // current char is whitespace - Cr // current char is not whitespace + if opt.hasarg != No { + line.push_char(' '); + if opt.hasarg == Maybe { + line.push_char('['); } - enum LengthLimit { - UnderLim, // current char makes current substring still fit in limit - OverLim // current char makes current substring no longer fit in limit + line.push_str(opt.hint); + if opt.hasarg == Maybe { + line.push_char(']'); } + } - let mut slice_start = 0; - let mut last_start = 0; - let mut last_end = 0; - let mut state = A; - let mut fake_i = ss.len(); - let mut lim = lim; + if opt.occur != Req { + line.push_char(']'); + } + if opt.occur == Multi { + line.push_str(".."); + } - let mut cont = true; - let slice: || = || { cont = it(ss.slice(slice_start, last_end)) }; + line +} - // if the limit is larger than the string, lower it to save cycles - if lim >= fake_i { - lim = fake_i; - } +/// Derive a short one-line usage summary from a set of long options. +pub fn short_usage(program_name: &str, opts: &[OptGroup]) -> ~str { + let mut line = ~"Usage: " + program_name + " "; + line.push_str(opts.iter().map(format_option).to_owned_vec().connect(" ")); - let machine: |(uint, char)| -> bool = |(i, c)| { - let whitespace = if ::std::char::is_whitespace(c) { 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 - => fail!("word starting with {} longer than limit!", - ss.slice(last_start, i + 1)), - (B, Cr, OverLim) => { slice(); slice_start = last_start; B } - (B, Ws, UnderLim) => { last_end = i; C } - (B, Ws, OverLim) => { last_end = i; slice(); A } - - (C, Cr, UnderLim) => { last_start = i; B } - (C, Cr, OverLim) => { slice(); slice_start = i; last_start = i; last_end = i; B } - (C, Ws, OverLim) => { slice(); A } - (C, Ws, UnderLim) => { C } - }; + line +} - cont + +/// Splits a string into substrings with possibly internal whitespace, +/// each of them at most `lim` bytes long. The substrings have leading and trailing +/// whitespace removed, and are only cut at whitespace boundaries. +/// +/// Note: Function was moved here from `std::str` because this module is the only place that +/// uses it, and because it was to specific for a general string function. +/// +/// #Failure: +/// +/// Fails during iteration if the string contains a non-whitespace +/// sequence longer than the limit. +fn each_split_within<'a>(ss: &'a str, lim: uint, it: |&'a str| -> bool) + -> bool { + // Just for fun, let's write this as a state machine: + + enum SplitWithinState { + A, // leading whitespace, initial state + B, // words + C, // internal and trailing whitespace + } + enum Whitespace { + Ws, // current char is whitespace + Cr // current char is not whitespace + } + enum LengthLimit { + UnderLim, // current char makes current substring still fit in limit + OverLim // current char makes current substring no longer fit in limit + } + + let mut slice_start = 0; + let mut last_start = 0; + let mut last_end = 0; + let mut state = A; + let mut fake_i = ss.len(); + let mut lim = lim; + + let mut cont = true; + let slice: || = || { cont = it(ss.slice(slice_start, last_end)) }; + + // if the limit is larger than the string, lower it to save cycles + if lim >= fake_i { + lim = fake_i; + } + + let machine: |(uint, char)| -> bool = |(i, c)| { + let whitespace = if ::std::char::is_whitespace(c) { 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 + => fail!("word starting with {} longer than limit!", + ss.slice(last_start, i + 1)), + (B, Cr, OverLim) => { slice(); slice_start = last_start; B } + (B, Ws, UnderLim) => { last_end = i; C } + (B, Ws, OverLim) => { last_end = i; slice(); A } + + (C, Cr, UnderLim) => { last_start = i; B } + (C, Cr, OverLim) => { slice(); slice_start = i; last_start = i; last_end = i; B } + (C, Ws, OverLim) => { slice(); A } + (C, Ws, UnderLim) => { C } }; - ss.char_indices().advance(|x| machine(x)); + cont + }; - // Let the automaton 'run out' by supplying trailing whitespace - while cont && match state { B | C => true, A => false } { - machine((fake_i, ' ')); - fake_i += 1; - } - return cont; - } + ss.char_indices().advance(|x| machine(x)); - #[test] - fn test_split_within() { - fn t(s: &str, i: uint, u: &[~str]) { - let mut v = ~[]; - each_split_within(s, i, |s| { v.push(s.to_owned()); true }); - assert!(v.iter().zip(u.iter()).all(|(a,b)| a == b)); - } - t("", 0, []); - t("", 15, []); - t("hello", 15, [~"hello"]); - t("\nMary had a little lamb\nLittle lamb\n", 15, - [~"Mary had a", ~"little lamb", ~"Little lamb"]); - t("\nMary had a little lamb\nLittle lamb\n", ::std::uint::MAX, - [~"Mary had a little lamb\nLittle lamb"]); + // Let the automaton 'run out' by supplying trailing whitespace + while cont && match state { B | C => true, A => false } { + machine((fake_i, ' ')); + fake_i += 1; } -} // end groups module + return cont; +} + +#[test] +fn test_split_within() { + fn t(s: &str, i: uint, u: &[~str]) { + let mut v = ~[]; + each_split_within(s, i, |s| { v.push(s.to_owned()); true }); + assert!(v.iter().zip(u.iter()).all(|(a,b)| a == b)); + } + t("", 0, []); + t("", 15, []); + t("hello", 15, [~"hello"]); + t("\nMary had a little lamb\nLittle lamb\n", 15, + [~"Mary had a", ~"little lamb", ~"Little lamb"]); + t("\nMary had a little lamb\nLittle lamb\n", ::std::uint::MAX, + [~"Mary had a little lamb\nLittle lamb"]); +} #[cfg(test)] mod tests { - - use getopts::groups::OptGroup; - use getopts::*; + use super::*; use std::result::{Err, Ok}; use std::result; @@ -917,73 +850,37 @@ mod tests { } } - // Tests for reqopt #[test] - fn test_reqopt_long() { - let args = ~[~"--test=20"]; - let opts = ~[reqopt("test")]; - let rs = getopts(args, opts); + fn test_reqopt() { + let long_args = ~[~"--test=20"]; + let opts = ~[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"); } - _ => { fail!("test_reqopt_long failed"); } + _ => { fail!("test_reqopt failed (long arg)"); } } - } - - #[test] - fn test_reqopt_long_missing() { - let args = ~[~"blah"]; - let opts = ~[reqopt("test")]; - let rs = getopts(args, opts); - match rs { - Err(f) => check_fail_type(f, OptionMissing_), - _ => fail!() - } - } - - #[test] - fn test_reqopt_long_no_arg() { - let args = ~[~"--test"]; - let opts = ~[reqopt("test")]; - let rs = getopts(args, opts); - match rs { - Err(f) => check_fail_type(f, ArgumentMissing_), - _ => fail!() - } - } - - #[test] - fn test_reqopt_long_multi() { - let args = ~[~"--test=20", ~"--test=30"]; - let opts = ~[reqopt("test")]; - let rs = getopts(args, opts); - match rs { - Err(f) => check_fail_type(f, OptionDuplicated_), - _ => fail!() - } - } - - #[test] - fn test_reqopt_short() { - let args = ~[~"-t", ~"20"]; - let opts = ~[reqopt("t")]; - let rs = getopts(args, opts); - match rs { + let short_args = ~[~"-t", ~"20"]; + match getopts(short_args, opts) { Ok(ref m) => { - assert!(m.opt_present("t")); + 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"); } - _ => fail!() + _ => { fail!("test_reqopt failed (short arg)"); } } } #[test] - fn test_reqopt_short_missing() { + fn test_reqopt_missing() { let args = ~[~"blah"]; - let opts = ~[reqopt("t")]; + let opts = ~[reqopt("t", "test", "testing", "TEST")]; let rs = getopts(args, opts); match rs { Err(f) => check_fail_type(f, OptionMissing_), @@ -992,20 +889,25 @@ mod tests { } #[test] - fn test_reqopt_short_no_arg() { - let args = ~[~"-t"]; - let opts = ~[reqopt("t")]; - let rs = getopts(args, opts); + fn test_reqopt_no_arg() { + let long_args = ~[~"--test"]; + let opts = ~[reqopt("t", "test", "testing", "TEST")]; + let rs = getopts(long_args, opts); match rs { Err(f) => check_fail_type(f, ArgumentMissing_), _ => fail!() } + let short_args = ~[~"-t"]; + match getopts(short_args, opts) { + Err(f) => check_fail_type(f, ArgumentMissing_), + _ => fail!() + } } #[test] - fn test_reqopt_short_multi() { - let args = ~[~"-t", ~"20", ~"-t", ~"30"]; - let opts = ~[reqopt("t")]; + fn test_reqopt_multi() { + let args = ~[~"--test=20", ~"-t", ~"30"]; + let opts = ~[reqopt("t", "test", "testing", "TEST")]; let rs = getopts(args, opts); match rs { Err(f) => check_fail_type(f, OptionDuplicated_), @@ -1013,62 +915,26 @@ mod tests { } } - // Tests for optopt #[test] - fn test_optopt_long() { - let args = ~[~"--test=20"]; - let opts = ~[optopt("test")]; - let rs = getopts(args, opts); + fn test_optopt() { + let long_args = ~[~"--test=20"]; + let opts = ~[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"); } _ => fail!() } - } - - #[test] - fn test_optopt_long_missing() { - let args = ~[~"blah"]; - let opts = ~[optopt("test")]; - let rs = getopts(args, opts); - match rs { - Ok(ref m) => assert!(!m.opt_present("test")), - _ => fail!() - } - } - - #[test] - fn test_optopt_long_no_arg() { - let args = ~[~"--test"]; - let opts = ~[optopt("test")]; - let rs = getopts(args, opts); - match rs { - Err(f) => check_fail_type(f, ArgumentMissing_), - _ => fail!() - } - } - - #[test] - fn test_optopt_long_multi() { - let args = ~[~"--test=20", ~"--test=30"]; - let opts = ~[optopt("test")]; - let rs = getopts(args, opts); - match rs { - Err(f) => check_fail_type(f, OptionDuplicated_), - _ => fail!() - } - } - - #[test] - fn test_optopt_short() { - let args = ~[~"-t", ~"20"]; - let opts = ~[optopt("t")]; - let rs = getopts(args, opts); - match rs { + let short_args = ~[~"-t", ~"20"]; + 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"); } @@ -1077,31 +943,39 @@ mod tests { } #[test] - fn test_optopt_short_missing() { + fn test_optopt_missing() { let args = ~[~"blah"]; - let opts = ~[optopt("t")]; + let opts = ~[optopt("t", "test", "testing", "TEST")]; let rs = getopts(args, opts); match rs { - Ok(ref m) => assert!(!m.opt_present("t")), + Ok(ref m) => { + assert!(!m.opt_present("test")); + assert!(!m.opt_present("t")); + } _ => fail!() } } #[test] - fn test_optopt_short_no_arg() { - let args = ~[~"-t"]; - let opts = ~[optopt("t")]; - let rs = getopts(args, opts); + fn test_optopt_no_arg() { + let long_args = ~[~"--test"]; + let opts = ~[optopt("t", "test", "testing", "TEST")]; + let rs = getopts(long_args, opts); match rs { Err(f) => check_fail_type(f, ArgumentMissing_), _ => fail!() } + let short_args = ~[~"-t"]; + match getopts(short_args, opts) { + Err(f) => check_fail_type(f, ArgumentMissing_), + _ => fail!() + } } #[test] - fn test_optopt_short_multi() { - let args = ~[~"-t", ~"20", ~"-t", ~"30"]; - let opts = ~[optopt("t")]; + fn test_optopt_multi() { + let args = ~[~"--test=20", ~"-t", ~"30"]; + let opts = ~[optopt("t", "test", "testing", "TEST")]; let rs = getopts(args, opts); match rs { Err(f) => check_fail_type(f, OptionDuplicated_), @@ -1109,26 +983,39 @@ mod tests { } } - // Tests for optflag #[test] - fn test_optflag_long() { - let args = ~[~"--test"]; - let opts = ~[optflag("test")]; - let rs = getopts(args, opts); + fn test_optflag() { + let long_args = ~[~"--test"]; + let opts = ~[optflag("t", "test", "testing")]; + let rs = getopts(long_args, opts); match rs { - Ok(ref m) => assert!(m.opt_present("test")), + Ok(ref m) => { + assert!(m.opt_present("test")); + assert!(m.opt_present("t")); + } + _ => fail!() + } + let short_args = ~[~"-t"]; + match getopts(short_args, opts) { + Ok(ref m) => { + assert!(m.opt_present("test")); + assert!(m.opt_present("t")); + } _ => fail!() } } #[test] - fn test_optflag_long_missing() { + fn test_optflag_missing() { let args = ~[~"blah"]; - let opts = ~[optflag("test")]; + let opts = ~[optflag("t", "test", "testing")]; let rs = getopts(args, opts); match rs { - Ok(ref m) => assert!(!m.opt_present("test")), + Ok(ref m) => { + assert!(!m.opt_present("test")); + assert!(!m.opt_present("t")); + } _ => fail!() } } @@ -1136,7 +1023,7 @@ mod tests { #[test] fn test_optflag_long_arg() { let args = ~[~"--test=20"]; - let opts = ~[optflag("test")]; + let opts = ~[optflag("t", "test", "testing")]; let rs = getopts(args, opts); match rs { Err(f) => { @@ -1148,9 +1035,9 @@ mod tests { } #[test] - fn test_optflag_long_multi() { - let args = ~[~"--test", ~"--test"]; - let opts = ~[optflag("test")]; + fn test_optflag_multi() { + let args = ~[~"--test", ~"-t"]; + let opts = ~[optflag("t", "test", "testing")]; let rs = getopts(args, opts); match rs { Err(f) => check_fail_type(f, OptionDuplicated_), @@ -1159,31 +1046,9 @@ mod tests { } #[test] - fn test_optflag_short() { - let args = ~[~"-t"]; - let opts = ~[optflag("t")]; - let rs = getopts(args, opts); - match rs { - Ok(ref m) => assert!(m.opt_present("t")), - _ => fail!() - } - } - - #[test] - fn test_optflag_short_missing() { - let args = ~[~"blah"]; - let opts = ~[optflag("t")]; - let rs = getopts(args, opts); - match rs { - Ok(ref m) => assert!(!m.opt_present("t")), - _ => fail!() - } - } - - #[test] fn test_optflag_short_arg() { let args = ~[~"-t", ~"20"]; - let opts = ~[optflag("t")]; + let opts = ~[optflag("t", "test", "testing")]; let rs = getopts(args, opts); match rs { Ok(ref m) => { @@ -1195,22 +1060,11 @@ mod tests { } } - #[test] - fn test_optflag_short_multi() { - let args = ~[~"-t", ~"-t"]; - let opts = ~[optflag("t")]; - let rs = getopts(args, opts); - match rs { - Err(f) => check_fail_type(f, OptionDuplicated_), - _ => fail!() - } - } - // Tests for optflagmulti #[test] fn test_optflagmulti_short1() { let args = ~[~"-v"]; - let opts = ~[optflagmulti("v")]; + let opts = ~[optflagmulti("v", "verbose", "verbosity")]; let rs = getopts(args, opts); match rs { Ok(ref m) => { @@ -1223,7 +1077,7 @@ mod tests { #[test] fn test_optflagmulti_short2a() { let args = ~[~"-v", ~"-v"]; - let opts = ~[optflagmulti("v")]; + let opts = ~[optflagmulti("v", "verbose", "verbosity")]; let rs = getopts(args, opts); match rs { Ok(ref m) => { @@ -1236,7 +1090,7 @@ mod tests { #[test] fn test_optflagmulti_short2b() { let args = ~[~"-vv"]; - let opts = ~[optflagmulti("v")]; + let opts = ~[optflagmulti("v", "verbose", "verbosity")]; let rs = getopts(args, opts); match rs { Ok(ref m) => { @@ -1249,7 +1103,7 @@ mod tests { #[test] fn test_optflagmulti_long1() { let args = ~[~"--verbose"]; - let opts = ~[optflagmulti("verbose")]; + let opts = ~[optflagmulti("v", "verbose", "verbosity")]; let rs = getopts(args, opts); match rs { Ok(ref m) => { @@ -1262,7 +1116,7 @@ mod tests { #[test] fn test_optflagmulti_long2() { let args = ~[~"--verbose", ~"--verbose"]; - let opts = ~[optflagmulti("verbose")]; + let opts = ~[optflagmulti("v", "verbose", "verbosity")]; let rs = getopts(args, opts); match rs { Ok(ref m) => { @@ -1272,67 +1126,40 @@ mod tests { } } - // Tests for optmulti #[test] - fn test_optmulti_long() { - let args = ~[~"--test=20"]; - let opts = ~[optmulti("test")]; + fn test_optflagmulti_mix() { + let args = ~[~"--verbose", ~"-v", ~"-vv", ~"verbose"]; + let opts = ~[optflagmulti("v", "verbose", "verbosity")]; let rs = getopts(args, opts); match rs { Ok(ref m) => { - assert!((m.opt_present("test"))); - assert_eq!(m.opt_str("test").unwrap(), ~"20"); + assert_eq!(m.opt_count("verbose"), 4); + assert_eq!(m.opt_count("v"), 4); } _ => fail!() } } + // Tests for optmulti #[test] - fn test_optmulti_long_missing() { - let args = ~[~"blah"]; - let opts = ~[optmulti("test")]; - let rs = getopts(args, opts); - match rs { - Ok(ref m) => assert!(!m.opt_present("test")), - _ => fail!() - } - } - - #[test] - fn test_optmulti_long_no_arg() { - let args = ~[~"--test"]; - let opts = ~[optmulti("test")]; - let rs = getopts(args, opts); - match rs { - Err(f) => check_fail_type(f, ArgumentMissing_), - _ => fail!() - } - } - - #[test] - fn test_optmulti_long_multi() { - let args = ~[~"--test=20", ~"--test=30"]; - let opts = ~[optmulti("test")]; - let rs = getopts(args, opts); + fn test_optmulti() { + let long_args = ~[~"--test=20"]; + let opts = ~[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"); - let pair = m.opt_strs("test"); - assert!(pair[0] == ~"20"); - assert!(pair[1] == ~"30"); + 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"); } _ => fail!() } - } - - #[test] - fn test_optmulti_short() { - let args = ~[~"-t", ~"20"]; - let opts = ~[optmulti("t")]; - let rs = getopts(args, opts); - match rs { + let short_args = ~[~"-t", ~"20"]; + 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"); } @@ -1341,61 +1168,65 @@ mod tests { } #[test] - fn test_optmulti_short_missing() { + fn test_optmulti_missing() { let args = ~[~"blah"]; - let opts = ~[optmulti("t")]; + let opts = ~[optmulti("t", "test", "testing", "TEST")]; let rs = getopts(args, opts); match rs { - Ok(ref m) => assert!(!m.opt_present("t")), + Ok(ref m) => { + assert!(!m.opt_present("test")); + assert!(!m.opt_present("t")); + } _ => fail!() } } #[test] - fn test_optmulti_short_no_arg() { - let args = ~[~"-t"]; - let opts = ~[optmulti("t")]; - let rs = getopts(args, opts); + fn test_optmulti_no_arg() { + let long_args = ~[~"--test"]; + let opts = ~[optmulti("t", "test", "testing", "TEST")]; + let rs = getopts(long_args, opts); match rs { Err(f) => check_fail_type(f, ArgumentMissing_), _ => fail!() } + let short_args = ~[~"-t"]; + match getopts(short_args, opts) { + Err(f) => check_fail_type(f, ArgumentMissing_), + _ => fail!() + } } #[test] - fn test_optmulti_short_multi() { - let args = ~[~"-t", ~"20", ~"-t", ~"30"]; - let opts = ~[optmulti("t")]; + fn test_optmulti_multi() { + let args = ~[~"--test=20", ~"-t", ~"30"]; + let opts = ~[optmulti("t", "test", "testing", "TEST")]; let rs = getopts(args, opts); match rs { Ok(ref m) => { - assert!((m.opt_present("t"))); - assert_eq!(m.opt_str("t").unwrap(), ~"20"); - let pair = m.opt_strs("t"); - assert!(pair[0] == ~"20"); - assert!(pair[1] == ~"30"); + 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"); } _ => fail!() } } #[test] - fn test_unrecognized_option_long() { - let args = ~[~"--untest"]; - let opts = ~[optmulti("t")]; - let rs = getopts(args, opts); + fn test_unrecognized_option() { + let long_args = ~[~"--untest"]; + let opts = ~[optmulti("t", "test", "testing", "TEST")]; + let rs = getopts(long_args, opts); match rs { Err(f) => check_fail_type(f, UnrecognizedOption_), _ => fail!() } - } - - #[test] - fn test_unrecognized_option_short() { - let args = ~[~"-t"]; - let opts = ~[optmulti("test")]; - let rs = getopts(args, opts); - match rs { + let short_args = ~[~"-u"]; + match getopts(short_args, opts) { Err(f) => check_fail_type(f, UnrecognizedOption_), _ => fail!() } @@ -1408,9 +1239,13 @@ mod tests { ~"--flag", ~"--long=30", ~"-f", ~"-m", ~"40", ~"-m", ~"50", ~"-n", ~"-A B", ~"-n", ~"-60 70"]; let opts = - ~[optopt("s"), optflag("flag"), reqopt("long"), - optflag("f"), optmulti("m"), optmulti("n"), - optopt("notpresent")]; + ~[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) => { @@ -1435,7 +1270,9 @@ mod tests { #[test] fn test_multi() { - let opts = ~[optopt("e"), optopt("encrypt"), optopt("f")]; + let opts = ~[optopt("e", "", "encrypt", "ENCRYPT"), + optopt("", "encrypt", "encrypt", "ENCRYPT"), + optopt("f", "", "flag", "FLAG")]; let args_single = ~[~"-e", ~"foo"]; let matches_single = &match getopts(args_single, opts) { @@ -1475,7 +1312,8 @@ mod tests { #[test] fn test_nospace() { let args = ~[~"-Lfoo", ~"-M."]; - let opts = ~[optmulti("L"), optmulti("M")]; + let opts = ~[optmulti("L", "", "library directory", "LIB"), + optmulti("M", "", "something", "MMMM")]; let matches = &match getopts(args, opts) { result::Ok(m) => m, result::Err(_) => fail!() @@ -1488,125 +1326,42 @@ mod tests { } #[test] - fn test_groups_reqopt() { - let opt = groups::reqopt("b", "banana", "some bananas", "VAL"); - assert!(opt == OptGroup { short_name: ~"b", - long_name: ~"banana", - hint: ~"VAL", - desc: ~"some bananas", - hasarg: Yes, - occur: Req }) - } - - #[test] - fn test_groups_optopt() { - let opt = groups::optopt("a", "apple", "some apples", "VAL"); - assert!(opt == OptGroup { short_name: ~"a", - long_name: ~"apple", - hint: ~"VAL", - desc: ~"some apples", - hasarg: Yes, - occur: Optional }) - } - - #[test] - fn test_groups_optflag() { - let opt = groups::optflag("k", "kiwi", "some kiwis"); - assert!(opt == OptGroup { short_name: ~"k", - long_name: ~"kiwi", - hint: ~"", - desc: ~"some kiwis", - hasarg: No, - occur: Optional }) - } - - #[test] - fn test_groups_optflagopt() { - let opt = groups::optflagopt("p", "pineapple", "some pineapples", "VAL"); - assert!(opt == OptGroup { short_name: ~"p", - long_name: ~"pineapple", - hint: ~"VAL", - desc: ~"some pineapples", - hasarg: Maybe, - occur: Optional }) - } - - #[test] - fn test_groups_optmulti() { - let opt = groups::optmulti("l", "lime", "some limes", "VAL"); - assert!(opt == OptGroup { short_name: ~"l", - long_name: ~"lime", - hint: ~"VAL", - desc: ~"some limes", - hasarg: Yes, - occur: Multi }) - } - - #[test] - fn test_groups_long_to_short() { - let mut short = reqopt("banana"); - short.aliases = ~[reqopt("b")]; - let verbose = groups::reqopt("b", "banana", "some bananas", "VAL"); + fn test_long_to_short() { + let mut short = Opt { name: Long(~"banana"), + hasarg: Yes, + occur: Req, + aliases: ~[] }; + short.aliases = ~[Opt { name: Short('b'), + hasarg: Yes, + occur: Req, + aliases: ~[] }]; + let verbose = reqopt("b", "banana", "some bananas", "VAL"); assert_eq!(verbose.long_to_short(), short); } #[test] - fn test_groups_getopts() { - let mut banana = reqopt("banana"); - banana.aliases = ~[reqopt("b")]; - let mut apple = optopt("apple"); - apple.aliases = ~[optopt("a")]; - let mut kiwi = optflag("kiwi"); - kiwi.aliases = ~[optflag("k")]; - let short = ~[ - banana, - apple, - kiwi, - optflagopt("p"), - optmulti("l") - ]; - - // short and verbose should always be in the same order. if they - // aren't the test will fail (and in mysterious ways) - - let verbose = ~[ - groups::reqopt("b", "banana", "Desc", "VAL"), - groups::optopt("a", "apple", "Desc", "VAL"), - groups::optflag("k", "kiwi", "Desc"), - groups::optflagopt("p", "", "Desc", "VAL"), - groups::optmulti("l", "", "Desc", "VAL"), - ]; - - let sample_args = ~[~"--kiwi", ~"15", ~"--apple", ~"1", ~"k", - ~"-p", ~"16", ~"l", ~"35"]; - - assert!(getopts(sample_args, short) - == groups::getopts(sample_args, verbose)); - } - - #[test] - fn test_groups_aliases_long_and_short() { + fn test_aliases_long_and_short() { let opts = ~[ - groups::optflagmulti("a", "apple", "Desc"), + optflagmulti("a", "apple", "Desc"), ]; let args = ~[~"-a", ~"--apple", ~"-a"]; - let matches = groups::getopts(args, opts).unwrap(); + let matches = getopts(args, opts).unwrap(); assert_eq!(3, matches.opt_count("a")); assert_eq!(3, matches.opt_count("apple")); } #[test] - fn test_groups_usage() { + fn test_usage() { let optgroups = ~[ - groups::reqopt("b", "banana", "Desc", "VAL"), - groups::optopt("a", "012345678901234567890123456789", + reqopt("b", "banana", "Desc", "VAL"), + optopt("a", "012345678901234567890123456789", "Desc", "VAL"), - groups::optflag("k", "kiwi", "Desc"), - groups::optflagopt("p", "", "Desc", "VAL"), - groups::optmulti("l", "", "Desc", "VAL"), + optflag("k", "kiwi", "Desc"), + optflagopt("p", "", "Desc", "VAL"), + optmulti("l", "", "Desc", "VAL"), ]; let expected = @@ -1621,7 +1376,7 @@ Options: -l VAL Desc "; - let generated_usage = groups::usage("Usage: fruits", optgroups); + let generated_usage = usage("Usage: fruits", optgroups); debug!("expected: <<{}>>", expected); debug!("generated: <<{}>>", generated_usage); @@ -1629,14 +1384,14 @@ Options: } #[test] - fn test_groups_usage_description_wrapping() { + fn test_usage_description_wrapping() { // indentation should be 24 spaces // lines wrap after 78: or rather descriptions wrap after 54 let optgroups = ~[ - groups::optflag("k", "kiwi", + optflag("k", "kiwi", "This is a long description which won't be wrapped..+.."), // 54 - groups::optflag("a", "apple", + optflag("a", "apple", "This is a long description which _will_ be wrapped..+.."), // 55 ]; @@ -1649,7 +1404,7 @@ Options: wrapped..+.. "; - let usage = groups::usage("Usage: fruits", optgroups); + let usage = usage("Usage: fruits", optgroups); debug!("expected: <<{}>>", expected); debug!("generated: <<{}>>", usage); @@ -1657,11 +1412,11 @@ Options: } #[test] - fn test_groups_usage_description_multibyte_handling() { + fn test_usage_description_multibyte_handling() { let optgroups = ~[ - groups::optflag("k", "k\u2013w\u2013", + optflag("k", "k\u2013w\u2013", "The word kiwi is normally spelled with two i's"), - groups::optflag("a", "apple", + optflag("a", "apple", "This \u201Cdescription\u201D has some characters that could \ confuse the line wrapping; an apple costs 0.51€ in some parts of Europe."), ]; @@ -1676,7 +1431,7 @@ Options: some parts of Europe. "; - let usage = groups::usage("Usage: fruits", optgroups); + let usage = usage("Usage: fruits", optgroups); debug!("expected: <<{}>>", expected); debug!("generated: <<{}>>", usage); @@ -1686,16 +1441,16 @@ Options: #[test] fn test_short_usage() { let optgroups = ~[ - groups::reqopt("b", "banana", "Desc", "VAL"), - groups::optopt("a", "012345678901234567890123456789", - "Desc", "VAL"), - groups::optflag("k", "kiwi", "Desc"), - groups::optflagopt("p", "", "Desc", "VAL"), - groups::optmulti("l", "", "Desc", "VAL"), + 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].."; - let generated_usage = groups::short_usage("fruits", optgroups); + let generated_usage = short_usage("fruits", optgroups); debug!("expected: <<{}>>", expected); debug!("generated: <<{}>>", generated_usage); diff --git a/src/librustc/driver/driver.rs b/src/librustc/driver/driver.rs index c3b851b76ac..70974fae5cc 100644 --- a/src/librustc/driver/driver.rs +++ b/src/librustc/driver/driver.rs @@ -34,8 +34,8 @@ use std::io::fs; use std::io::MemReader; use std::os; use std::vec; -use extra::getopts::groups::{optopt, optmulti, optflag, optflagopt}; -use extra::getopts; +use getopts::{optopt, optmulti, optflag, optflagopt}; +use getopts; use syntax::ast; use syntax::abi; use syntax::attr; @@ -992,7 +992,7 @@ pub fn parse_pretty(sess: Session, name: &str) -> PpMode { } // rustc command line options -pub fn optgroups() -> ~[getopts::groups::OptGroup] { +pub fn optgroups() -> ~[getopts::OptGroup] { ~[ optflag("c", "", "Compile and assemble, but do not link"), optmulti("", "cfg", "Configure the compilation @@ -1188,7 +1188,7 @@ mod test { use driver::driver::{build_configuration, build_session}; use driver::driver::{build_session_options, optgroups}; - use extra::getopts::groups::getopts; + use getopts::getopts; use syntax::attr; use syntax::attr::AttrMetaMethods; use syntax::diagnostic; diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 52ddc8c8108..9a6cbcc9b96 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -37,6 +37,7 @@ extern mod arena; extern mod syntax; extern mod serialize; extern mod sync; +extern mod getopts; use back::link; use driver::session; @@ -50,8 +51,6 @@ use std::os; use std::str; use std::task; use std::vec; -use extra::getopts::groups; -use extra::getopts; use syntax::ast; use syntax::attr; use syntax::diagnostic::Emitter; @@ -142,7 +141,7 @@ pub fn usage(argv0: &str) { Additional help: -W help Print 'lint' options and default settings -Z help Print internal options for debugging rustc\n", - groups::usage(message, d::optgroups())); + getopts::usage(message, d::optgroups())); } pub fn describe_warnings() { @@ -201,7 +200,7 @@ pub fn run_compiler(args: &[~str], demitter: @diagnostic::Emitter) { if args.is_empty() { usage(binary); return; } let matches = - &match getopts::groups::getopts(args, d::optgroups()) { + &match getopts::getopts(args, d::optgroups()) { Ok(m) => m, Err(f) => { d::early_error(demitter, f.to_err_msg()); diff --git a/src/librustc/middle/typeck/infer/test.rs b/src/librustc/middle/typeck/infer/test.rs index 6ac4c5ff395..dd96018d4af 100644 --- a/src/librustc/middle/typeck/infer/test.rs +++ b/src/librustc/middle/typeck/infer/test.rs @@ -23,12 +23,9 @@ use middle::lang_items::{LanguageItems, language_items}; use middle::ty::{FnTyBase, FnMeta, FnSig}; use util::ppaux::ty_to_str; -use extra::getopts::groups::{optopt, optmulti, optflag, optflagopt, getopts}; -use extra::getopts::groups; -use extra::getopts::{opt_present}; -use extra::getopts; -use extra::getopts; use extra::oldmap::HashMap; +use getopts::{optopt, optmulti, optflag, optflagopt, getopts}; +use getopts::opt_present; use syntax::codemap::DUMMY_SP; use syntax::parse::parse_crate_from_source_str; use syntax::{ast, attr, parse}; diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 7256e8923fa..f659c8646f5 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -20,13 +20,12 @@ extern mod rustc; extern mod extra; extern mod serialize; extern mod sync; +extern mod getopts; use std::local_data; use std::io; use std::io::{File, MemWriter}; use std::str; -use extra::getopts; -use extra::getopts::groups; use extra::json; use serialize::{Decodable, Encodable}; use extra::time; @@ -80,8 +79,8 @@ pub fn main() { std::os::set_exit_status(main_args(std::os::args())); } -pub fn opts() -> ~[groups::OptGroup] { - use extra::getopts::groups::*; +pub fn opts() -> ~[getopts::OptGroup] { + use getopts::*; ~[ optflag("h", "help", "show this help message"), optflag("", "version", "print rustdoc's version"), @@ -107,11 +106,11 @@ pub fn opts() -> ~[groups::OptGroup] { } pub fn usage(argv0: &str) { - println!("{}", groups::usage(format!("{} [options] <input>", argv0), opts())); + println!("{}", getopts::usage(format!("{} [options] <input>", argv0), opts())); } pub fn main_args(args: &[~str]) -> int { - let matches = match groups::getopts(args.tail(), opts()) { + let matches = match getopts::getopts(args.tail(), opts()) { Ok(m) => m, Err(err) => { println!("{}", err.to_err_msg()); diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 28e62f8fb29..12f2f2ca936 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -16,11 +16,11 @@ use std::run; use std::str; use extra::tempfile::TempDir; -use extra::getopts; use extra::test; use rustc::driver::driver; use rustc::driver::session; use rustc::metadata::creader::Loader; +use getopts; use syntax::diagnostic; use syntax::parse; diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index 040c8526ee0..86a2043527e 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -19,8 +19,9 @@ */ extern mod extra; +extern mod getopts; -use extra::{time, getopts}; +use extra::time; use std::os; use std::result::{Ok, Err}; use std::task; @@ -52,7 +53,7 @@ struct Config { } fn parse_opts(argv: ~[~str]) -> Config { - let opts = ~[getopts::optflag("stress")]; + let opts = ~[getopts::optflag("", "stress", "")]; let opt_args = argv.slice(1, argv.len()); diff --git a/src/test/run-pass/getopts_ref.rs b/src/test/run-pass/getopts_ref.rs index bfc14006565..db8098a79ac 100644 --- a/src/test/run-pass/getopts_ref.rs +++ b/src/test/run-pass/getopts_ref.rs @@ -10,13 +10,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod extra; +extern mod getopts; -use extra::getopts::{optopt, getopts}; +use getopts::{optopt, getopts}; pub fn main() { let args = ~[]; - let opts = ~[optopt("b")]; + let opts = ~[optopt("b", "", "something", "SMTHNG")]; match getopts(args, opts) { Ok(ref m) => |