bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

std: Convert records to structs in getopts

Browse source
This commit is contained in:
Brian Anderson 2012-12-11 17:03:22 -08:00
parent fa4fbd51f6
commit 742f354ffb
1 changed files with 42 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

75
src/libstd/getopts.rs
View file

@ -89,7 +89,11 @@ enum HasArg { Yes, No, Maybe, }
enum Occur { Req, Optional, Multi, } enum Occur { Req, Optional, Multi, }
/// A description of a possible option /// A description of a possible option
pub type Opt = {name: Name, hasarg: HasArg, occur: Occur}; pub struct Opt {
name: Name,
hasarg: HasArg,
occur: Occur
}
fn mkname(nm: &str) -> Name { fn mkname(nm: &str) -> Name {
let unm = str::from_slice(nm); let unm = str::from_slice(nm);
@ -143,27 +147,27 @@ impl Opt : Eq {
/// Create an option that is required and takes an argument /// Create an option that is required and takes an argument
pub fn reqopt(name: &str) -> Opt { pub fn reqopt(name: &str) -> Opt {
return {name: mkname(name), hasarg: Yes, occur: Req}; return Opt {name: mkname(name), hasarg: Yes, occur: Req};
} }
/// Create an option that is optional and takes an argument /// Create an option that is optional and takes an argument
pub fn optopt(name: &str) -> Opt { pub fn optopt(name: &str) -> Opt {
return {name: mkname(name), hasarg: Yes, occur: Optional}; return Opt {name: mkname(name), hasarg: Yes, occur: Optional};
} }
/// Create an option that is optional and does not take an argument /// Create an option that is optional and does not take an argument
pub fn optflag(name: &str) -> Opt { pub fn optflag(name: &str) -> Opt {
return {name: mkname(name), hasarg: No, occur: Optional}; return Opt {name: mkname(name), hasarg: No, occur: Optional};
} }
/// Create an option that is optional and does not take an argument /// Create an option that is optional and does not take an argument
pub fn optflagmulti(name: &str) -> Opt { pub fn optflagmulti(name: &str) -> Opt {
return {name: mkname(name), hasarg: No, occur: Multi}; return Opt {name: mkname(name), hasarg: No, occur: Multi};
} }
/// Create an option that is optional and takes an optional argument /// Create an option that is optional and takes an optional argument
pub fn optflagopt(name: &str) -> Opt { pub fn optflagopt(name: &str) -> Opt {
return {name: mkname(name), hasarg: Maybe, occur: Optional}; return Opt {name: mkname(name), hasarg: Maybe, occur: Optional};
} }
/** /**
@ -171,7 +175,7 @@ pub fn optflagopt(name: &str) -> Opt {
* multiple times * multiple times
*/ */
pub fn optmulti(name: &str) -> Opt { pub fn optmulti(name: &str) -> Opt {
return {name: mkname(name), hasarg: Yes, occur: Multi}; return Opt {name: mkname(name), hasarg: Yes, occur: Multi};
} }
enum Optval { Val(~str), Given, } enum Optval { Val(~str), Given, }
@ -180,7 +184,11 @@ enum Optval { Val(~str), Given, }
* The result of checking command line arguments. Contains a vector * The result of checking command line arguments. Contains a vector
* of matches and a vector of free strings. * of matches and a vector of free strings.
*/ */
pub type Matches = {opts: ~[Opt], vals: ~[~[Optval]], free: ~[~str]}; pub struct Matches {
opts: ~[Opt],
vals: ~[~[Optval]],
free: ~[~str]
}
impl Optval : Eq { impl Optval : Eq {
pure fn eq(&self, other: &Optval) -> bool { pure fn eq(&self, other: &Optval) -> bool {
@ -410,7 +418,7 @@ pub fn getopts(args: &[~str], opts: &[Opt]) -> Result unsafe {
} }
i += 1; i += 1;
} }
return Ok({opts: vec::from_slice(opts), return Ok(Matches {opts: vec::from_slice(opts),
vals: vec::from_mut(move vals), vals: vec::from_mut(move vals),
free: free}); free: free});
} }
@ -538,14 +546,14 @@ pub mod groups {
/** one group of options, e.g., both -h and --help, along with /** one group of options, e.g., both -h and --help, along with
* their shared description and properties * their shared description and properties
*/ */
pub type OptGroup = { pub struct OptGroup {
short_name: ~str, short_name: ~str,
long_name: ~str, long_name: ~str,
hint: ~str, hint: ~str,
desc: ~str, desc: ~str,
hasarg: HasArg, hasarg: HasArg,
occur: Occur occur: Occur
}; }
impl OptGroup : Eq { impl OptGroup : Eq {
pure fn eq(&self, other: &OptGroup) -> bool { pure fn eq(&self, other: &OptGroup) -> bool {
@ -566,7 +574,7 @@ pub mod groups {
desc: &str, hint: &str) -> OptGroup { desc: &str, hint: &str) -> OptGroup {
let len = short_name.len(); let len = short_name.len();
assert len == 1 || len == 0; assert len == 1 || len == 0;
return {short_name: str::from_slice(short_name), return OptGroup { short_name: str::from_slice(short_name),
long_name: str::from_slice(long_name), long_name: str::from_slice(long_name),
hint: str::from_slice(hint), hint: str::from_slice(hint),
desc: str::from_slice(desc), desc: str::from_slice(desc),
@ -579,7 +587,7 @@ pub mod groups {
desc: &str, hint: &str) -> OptGroup { desc: &str, hint: &str) -> OptGroup {
let len = short_name.len(); let len = short_name.len();
assert len == 1 || len == 0; assert len == 1 || len == 0;
return {short_name: str::from_slice(short_name), return OptGroup {short_name: str::from_slice(short_name),
long_name: str::from_slice(long_name), long_name: str::from_slice(long_name),
hint: str::from_slice(hint), hint: str::from_slice(hint),
desc: str::from_slice(desc), desc: str::from_slice(desc),
@ -592,7 +600,7 @@ pub mod groups {
desc: &str) -> OptGroup { desc: &str) -> OptGroup {
let len = short_name.len(); let len = short_name.len();
assert len == 1 || len == 0; assert len == 1 || len == 0;
return {short_name: str::from_slice(short_name), return OptGroup {short_name: str::from_slice(short_name),
long_name: str::from_slice(long_name), long_name: str::from_slice(long_name),
hint: ~"", hint: ~"",
desc: str::from_slice(desc), desc: str::from_slice(desc),
@ -605,7 +613,7 @@ pub mod groups {
desc: &str, hint: &str) -> OptGroup { desc: &str, hint: &str) -> OptGroup {
let len = short_name.len(); let len = short_name.len();
assert len == 1 || len == 0; assert len == 1 || len == 0;
return {short_name: str::from_slice(short_name), return OptGroup {short_name: str::from_slice(short_name),
long_name: str::from_slice(long_name), long_name: str::from_slice(long_name),
hint: str::from_slice(hint), hint: str::from_slice(hint),
desc: str::from_slice(desc), desc: str::from_slice(desc),
@ -621,7 +629,7 @@ pub mod groups {
desc: &str, hint: &str) -> OptGroup { desc: &str, hint: &str) -> OptGroup {
let len = short_name.len(); let len = short_name.len();
assert len == 1 || len == 0; assert len == 1 || len == 0;
return {short_name: str::from_slice(short_name), return OptGroup {short_name: str::from_slice(short_name),
long_name: str::from_slice(long_name), long_name: str::from_slice(long_name),
hint: str::from_slice(hint), hint: str::from_slice(hint),
desc: str::from_slice(desc), desc: str::from_slice(desc),
@ -637,20 +645,20 @@ pub mod groups {
(0,0) => fail ~"this long-format option was given no name", (0,0) => fail ~"this long-format option was given no name",
(0,_) => ~[{name: Long(((*lopt).long_name)), (0,_) => ~[Opt {name: Long(((*lopt).long_name)),
hasarg: (*lopt).hasarg, hasarg: (*lopt).hasarg,
occur: (*lopt).occur}], occur: (*lopt).occur}],
(1,0) => ~[{name: Short(str::char_at((*lopt).short_name, 0)), (1,0) => ~[Opt {name: Short(str::char_at((*lopt).short_name, 0)),
hasarg: (*lopt).hasarg, hasarg: (*lopt).hasarg,
occur: (*lopt).occur}], occur: (*lopt).occur}],
(1,_) => ~[{name: Short(str::char_at((*lopt).short_name, 0)), (1,_) => ~[Opt {name: Short(str::char_at((*lopt).short_name, 0)),
hasarg: (*lopt).hasarg, hasarg: (*lopt).hasarg,
occur: (*lopt).occur}, occur: (*lopt).occur},
{name: Long(((*lopt).long_name)), Opt {name: Long(((*lopt).long_name)),
hasarg: (*lopt).hasarg, hasarg: (*lopt).hasarg,
occur: (*lopt).occur}], occur: (*lopt).occur}],
(_,_) => fail ~"something is wrong with the long-form opt" (_,_) => fail ~"something is wrong with the long-form opt"
} }
@ -725,6 +733,7 @@ mod tests {
#[legacy_exports]; #[legacy_exports];
use opt = getopts; use opt = getopts;
use result::{Err, Ok}; use result::{Err, Ok};
use opt::groups::OptGroup;
fn check_fail_type(f: Fail_, ft: FailType) { fn check_fail_type(f: Fail_, ft: FailType) {
match f { match f {
@ -1291,7 +1300,7 @@ mod tests {
#[test] #[test]
fn test_groups_reqopt() { fn test_groups_reqopt() {
let opt = groups::reqopt(~"b", ~"banana", ~"some bananas", ~"VAL"); let opt = groups::reqopt(~"b", ~"banana", ~"some bananas", ~"VAL");
assert opt == { short_name: ~"b", assert opt == OptGroup { short_name: ~"b",
long_name: ~"banana", long_name: ~"banana",
hint: ~"VAL", hint: ~"VAL",
desc: ~"some bananas", desc: ~"some bananas",
@ -1302,7 +1311,7 @@ mod tests {
#[test] #[test]
fn test_groups_optopt() { fn test_groups_optopt() {
let opt = groups::optopt(~"a", ~"apple", ~"some apples", ~"VAL"); let opt = groups::optopt(~"a", ~"apple", ~"some apples", ~"VAL");
assert opt == { short_name: ~"a", assert opt == OptGroup { short_name: ~"a",
long_name: ~"apple", long_name: ~"apple",
hint: ~"VAL", hint: ~"VAL",
desc: ~"some apples", desc: ~"some apples",
@ -1313,7 +1322,7 @@ mod tests {
#[test] #[test]
fn test_groups_optflag() { fn test_groups_optflag() {
let opt = groups::optflag(~"k", ~"kiwi", ~"some kiwis"); let opt = groups::optflag(~"k", ~"kiwi", ~"some kiwis");
assert opt == { short_name: ~"k", assert opt == OptGroup { short_name: ~"k",
long_name: ~"kiwi", long_name: ~"kiwi",
hint: ~"", hint: ~"",
desc: ~"some kiwis", desc: ~"some kiwis",
@ -1325,7 +1334,7 @@ mod tests {
fn test_groups_optflagopt() { fn test_groups_optflagopt() {
let opt = groups::optflagopt(~"p", ~"pineapple", let opt = groups::optflagopt(~"p", ~"pineapple",
~"some pineapples", ~"VAL"); ~"some pineapples", ~"VAL");
assert opt == { short_name: ~"p", assert opt == OptGroup { short_name: ~"p",
long_name: ~"pineapple", long_name: ~"pineapple",
hint: ~"VAL", hint: ~"VAL",
desc: ~"some pineapples", desc: ~"some pineapples",
@ -1337,7 +1346,7 @@ mod tests {
fn test_groups_optmulti() { fn test_groups_optmulti() {
let opt = groups::optmulti(~"l", ~"lime", let opt = groups::optmulti(~"l", ~"lime",
~"some limes", ~"VAL"); ~"some limes", ~"VAL");
assert opt == { short_name: ~"l", assert opt == OptGroup { short_name: ~"l",
long_name: ~"lime", long_name: ~"lime",
hint: ~"VAL", hint: ~"VAL",
desc: ~"some limes", desc: ~"some limes",