Mirrors/clap
2
0
Fork 0
mirror of https://github.com/clap-rs/clap synced 2024-12-12 22:02:35 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #16 from untitaker/make

Browse source 
Add makefile magic
This commit is contained in:
Kevin K. 2015-03-18 21:20:10 -04:00
commit dde61de645
3 changed files with 41 additions and 95 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
Makefile Normal file
View file

@ -0,0 +1,20 @@
THIS_MAKEFILE_PATH:=$(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST))
THIS_DIR:=$(shell cd $(dir $(THIS_MAKEFILE_PATH));pwd)
test:
cargo test
build:
cargo build
doc:
cd "$(THIS_DIR)"
cp src/lib.rs code.bak
cat README.md | sed -e 's/^/\/\/! /g' > readme.bak
sed -i '/\/\/ DOCS/r readme.bak' src/lib.rs
(cargo doc --no-deps && make clean) || (make clean && false)
clean:
cd "$(THIS_DIR)"
mv code.bak src/lib.rs || true
rm *.bak || true

21
README.md
View file

@ -1,4 +1,7 @@
# clap ![Travis-CI](https://travis-ci.org/kbknapp/clap-rs.svg?branch=master)
# clap
![Travis-CI](https://travis-ci.org/kbknapp/clap-rs.svg?branch=master)
Command Line Argument Parser written in Rust
A simply library for parsing command line arguments and subcommands when writing command line and console applications.
@ -119,3 +122,19 @@ Add `extern crate clap;` to your crate root.
## More Information
You can find complete documentation on the [github-pages site](http://kbknapp.github.io/clap-rs/docs/clap/index.html) for this project.
## How to build
### Running the tests
```
cargo test
```
### Building the documentation
Run this instead of `cargo doc` to generate the proper module docstring:
```
make doc
```

95
src/lib.rs
View file

@ -2,100 +2,7 @@
#![feature(libc, exit_status)]
//! A simply library for parsing command line arguments when writing
//! command line and console applications.
//!
//!
//! You can use `clap` to lay out a list of possible valid command line arguments and let `clap` parse the string given by the user at runtime.
//! When using `clap` you define a set of parameters and rules for your arguments and at runtime `clap` will determine their validity.
//! Also, `clap` provides the traditional version and help switches 'for free' by parsing the list of possible valid arguments lazily at runtime.
//! i.e. only when it's been determined that the user wants or needs to see the help and version information.
//!
//! After defining a list of possible valid arguments you get a list of matches that the user supplied at runtime. You can then use this list to
//! determine the functioning of your program.
//!
//! Example:
//!
//! ```no_run
//! use clap::{Arg, App, SubCommand};
//!
//! // ...
//!
//! let matches = App::new("MyApp")
//! .version("1.0")
//! .author("Kevin K. <kbknapp@gmail.com>")
//! .about("Does awesome things")
//! .arg(Arg::new("config")
//! .short("c")
//! .long("config")
//! .help("Sets a custom config file")
//! .takes_value(true))
//! .arg(Arg::new("output")
//! .help("Sets an optional output file")
//! .index(1))
//! .arg(Arg::new("debug")
//! .short("d")
//! .multiple(true)
//! .help("Turn debugging information on"))
//! .subcommand(SubCommand::new("test")
//! .about("Has test sub functionality")
//! .arg(Arg::new("verbose")
//! .short("v")
//! .help("Display verbose information")))
//! .get_matches();
//!
//! if let Some(o) = matches.value_of("output") {
//! println!("Value for output: {}", o);
//! }
//!
//! if let Some(c) = matches.value_of("config") {
//! println!("Value for config: {}", c);
//! }
//!
//! match matches.occurrences_of("debug") {
//! 0 => println!("Debug mode is off"),
//! 1 => println!("Debug mode is kind of on"),
//! 2 => println!("Debug mode is on"),
//! 3 | _ => println!("Don't be crazy"),
//! }
//!
//! if let Some(ref matches) = matches.subcommand_matches("test") {
//! if matches.is_present("verbose") {
//! println!("Printing verbose test info...");
//! } else {
//! println!("Not printing regular test info...");
//! }
//! }
//!
//! // more porgram logic goes here...
//! ```
//!
//! If you were to compile the above program and run it with the flag `--help` or `-h` the following output woud be presented
//!
//! ```sh
//! $ myprog --help
//! MyApp 1.0
//! Kevin K. <kbknapp@gmail.com>
//! Does awesome things
//!
//! USAGE:
//! MyApp [FLAGS] [OPTIONS] [POSITIONAL] [SUBCOMMANDS]
//!
//! FLAGS:
//! -d Turn debugging information on
//! -h,--help Prints this message
//! -v,--version Prints version information
//!
//! OPTIONS:
//! -c,--config <config> Sets a custom config file
//!
//! POSITIONAL ARGUMENTS:
//! output Sets an optional output file
//!
//! SUBCOMMANDS:
//! help Prints this message
//! test Has test sub-functionality
//! ```
// DOCS
pub use args::{Arg, SubCommand, ArgMatches};
pub use app::App;