nodes 0.1.0

Library and cli of a simple node/though keeping system
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

#[macro_use] extern crate clap;
#[macro_use] extern crate lazy_static;
extern crate nodes;
extern crate regex;

mod commands;

fn ret_main() -> i32 {
    fn is_uint(v: String) -> Result<(), String> {
        if let Err(_) = v.parse::<u64>() {
            Err(format!("Could not parse '{}' as unsigned number", v))
        } else {
            Ok(())
        }
    }

    let matches = clap_app!(nodes =>
        (version: "0.1")
        (setting: clap::AppSettings::VersionlessSubcommands)
        (author: "nyorain [at gmail dot com]")
        (about: "Manages your node system from the command line")
        (@arg storage: -s --storage +takes_value "The storage to use")
        (@arg local: -l --local 
            conflicts_with("storage")
            "Search for a local node storage in current directory")
        (@subcommand create =>
            (about: "Creates a new node")
            (alias: "c")
            (@arg meta: !required index(1) "Associate metadata with this node")
            (@arg tags: -t --tag +takes_value !required ... +use_delimiter
                "Tag the node")
            (@arg type: --type +takes_value !required 
                "Type of node to create, will open matching editor")
            (@arg content: -c --content +takes_value !required
                "Write this content into the node instead of open an editor")
        ) (@subcommand rm =>
            (about: "Removes a node (by id)")
            (@arg id: +required +multiple index(1)
                {is_uint}
                "The nodes id. Can also specify multiple nodes")
        ) (@subcommand add =>
            (about: "Creates a new node from an existing file")
            (alias: "a")
            (@arg file: +required index(1) "The file to add")
            (@arg name: !required index(2) "Name of new node, id by default")
        ) (@subcommand ls =>
            (about: "Lists existing notes")
            (@arg pattern: index(1) 
                "Only list nodes matching this pattern")
            (@arg num: -n --num +takes_value
                default_value("10")
                {is_uint}
                "Maximum number of nodes to show")
            (@arg lines: -l --lines +takes_value
                {is_uint}
                "How many lines to show at maximum from a node")
            (@arg full: -f --full conflicts_with("lines") "Print full nodes")
            (@arg sort: -s --sort
                +case_insensitive
                default_value("id")
                +takes_value "Order of displayed nodes")
            (@arg reverse: -R --rev !takes_value !required
                "Reverses the order")
            (@arg reverse_list: -r --revlist !takes_value !required
                "Reverses the display order")
        // ) (@subcommand show =>
        //     (about: "Shows a node")
        //     (alias: "s")
        //     (@arg id: +required index(1) {is_uint} "Id of node to show")
        //     (@arg meta: -m --meta "Shows the meta file instead")
        ) (@subcommand edit =>
            (about: "Edits a node")
            (alias: "e")
            (@arg id: +required index(1) {is_uint} "Id of node to edit")
            (@arg meta: -m --meta "Edit the meta file instead")
        ) (@subcommand ref =>
           (@arg ref: +required index(1) "The node reference")
           (@arg from: index(2) 
                "Origin node path. Needed for 'this' storage")
           (about: "Resolves a node reference to a path")
        ) (@subcommand config =>
            (about: "Edit config file")
        )
    ).get_matches();

    // load config & match storage-independent commands
    let config = nodes::Config::load_default().expect("Error loading config");
    match matches.subcommand() {
        ("config", Some(s)) => return commands::config(&config, s),
        ("ref", Some(s)) => return commands::ref_path(&config, s),
        _ => {},
    }

    // storage-dependent commands, load a storage
    let mut storage = match if matches.is_present("local") {
        config.load_local_storage()
    } else {
        match matches.value_of("storage") {
            Some(name) => config.load_storage(name),
            None => config.load_default_storage(),
        }
    } {
        Ok(a) => a,
        Err(e) => {
            println!("Error fetching storage: {:?}", e);
            return 1;
        },
    };

    match matches.subcommand() {
        ("rm", Some(s)) => commands::rm(&mut storage, s),
        ("edit", Some(s)) => commands::edit(&mut storage, s),
        ("create", Some(s)) => commands::create(&mut storage, s),
        ("add", Some(s)) => commands::add(&mut storage, s),
        ("ls", Some(s)) => commands::ls(&mut storage, s),
        (_, Some(_)) => {
            println!("Currently not supported");
            return 2;
        } _ => commands::ls(&mut storage, 
                          &clap::ArgMatches::default())
    }
}

fn main() {
    std::process::exit(ret_main());
}