cmdparsing 2.1.0

adds a macro to parse arguments
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

# CMDPARSING
a macro to do command line argument parsing  
```rust
use std::env::args;
use cmdparsing::define; 


define! {
    Data; //name of the struct
help: "usage: cmd [file(2)] [other]"; //the usage of the command(shows when using -help, or --help(reserved flag))
      flags {
t: bool = "w"|"h",  // a flag that uses a boolean
       f: String = "f", // a flag of type string
       o: String = "l" => [2], //a flag of type string with 2 entries
      };
      args {
file: String => [2], //a positional argument with 2 entries(String)
          other: String, //a positional argument with one entry(String)
      };
      rest => more: String; //a rest argument that takes strings(takes the last arguments unless its broken by a flag)
}

fn main() {
    let d = Data::from(args().skip(1).collect());
    println!("{:?}", d);
}

```

That example would generate this struct 

```rust
struct Data {
t: bool,
       f: Option<String>,
       o: Vec<String>,
       file: Vec<String>,
       other: String,
       more: Vec<String>,
}
```
## there's also command pattern
```rust
cmd! { // this generates a main function and runs it for you
help: "usage: cmd [run|test]";
      run => "run", //the ident is the function name and the string is the key for the command
          test => "test"|"alias", //there are also aliases
}

fn test(_: Vec<String>) {
    println!("this is a test");
}
fn run(args: Vec<String>) {
    let d = Data::from(args.into_iter().skip(1).collect());
    println!("{:?}", d);
}
```
but if you want more control
```rust
cmd! { //this generates the struct Main, which has a method named run to run the command
    Main;
    help: "usage: cmd [run|test]";
    run => "run", //the ident is the function name and the string is the key for the command
    test => "test"|"alias", //there are also aliases
}

fn main() {
    Main::run(std::env::args().skip(1).collect());
}

fn test(_: Vec<String>) {
    println!("this is a test");
}
fn run(args: Vec<String>) {
    let d = Data::from(args.into_iter().skip(1).collect());
    println!("{:?}", d);
}
```