kanorg 0.5.0

Simple Kanban management in Rust
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Main CLI of KanOrg.
extern crate clap;

use clap::{App, Arg, SubCommand};
use std::{env, process};

use kanorg::board::{KanOrgBoard, KanOrgBoardResult};

/// Returns the argument matches from the command line
pub fn get_matches<'a>() -> clap::ArgMatches<'a> {
    let create_args = &[Arg::with_name("target_dir")
        .index(1)
        .help("Target directory to create the new config")];
    let show_args = &[Arg::with_name("task | workflow")
        .index(1)
        .help("Specific task or workflow to display")];
    let add_args = &[
        Arg::with_name("title")
            .index(1)
            .required(true)
            .help("Define the new task title"),
        Arg::with_name("workflow")
            .index(2)
            .help("Specify the initial task workflow"),
        Arg::with_name("edit")
            .short("e")
            .help("Edit the task once created"),
    ];
    let move_args = &[
        Arg::with_name("task")
            .index(1)
            .required(true)
            .help("Task identifier"),
        Arg::with_name("workflow")
            .index(2)
            .help("New workflow to which move the task to"),
    ];
    let edit_args = &[Arg::with_name("task")
        .index(1)
        .required(true)
        .help("Task identifier")];
    let delete_args = &[Arg::with_name("task")
        .index(1)
        .required(true)
        .help("Task identifier")];

    App::new(env!("CARGO_PKG_NAME"))
        .version(env!("CARGO_PKG_VERSION"))
        .author(env!("CARGO_PKG_AUTHORS"))
        .about(env!("CARGO_PKG_DESCRIPTION"))
        .subcommands(vec![
            SubCommand::with_name("create")
                .about("Create a default config in the current directory")
                .args(create_args),
            SubCommand::with_name("c")
                .about("Alias for `create` subcommand")
                .args(create_args),
            SubCommand::with_name("show")
                .about("Show the KanOrg display")
                .args(show_args),
            SubCommand::with_name("s")
                .about("Alias for `show` subcommand")
                .args(show_args),
            SubCommand::with_name("add")
                .about("Add a new task to the workflow")
                .args(add_args),
            SubCommand::with_name("a")
                .about("Alias for `add` subcommand")
                .args(add_args),
            SubCommand::with_name("move")
                .about("Move a task to another workflow")
                .args(move_args),
            SubCommand::with_name("m")
                .about("Alias for `move` subcommand")
                .args(move_args),
            SubCommand::with_name("edit")
                .about("Edit the title or description from a task")
                .args(edit_args),
            SubCommand::with_name("e")
                .about("Alias for `edit` subcommand")
                .args(edit_args),
            SubCommand::with_name("delete")
                .about("Delete a task from any workflow")
                .args(delete_args),
            SubCommand::with_name("d")
                .about("Alias for `delete` subcommand")
                .args(delete_args),
        ])
        .get_matches()
}

/// Collect errors form the subcommands and print them. Then exit the program.
fn print_error_and_exit(result: KanOrgBoardResult<()>) {
    if let Err(err) = result {
        println!("{}", err);
        process::exit(1);
    };
}

/// Main function.
fn main() -> KanOrgBoardResult<()> {
    let matches = get_matches();

    match matches.subcommand() {
        ("create", Some(subcommand)) | ("c", Some(subcommand)) => {
            print_error_and_exit(KanOrgBoard::create(
                subcommand.value_of("target_dir").unwrap_or("."),
            ));
        }
        _ => {
            let mut board = KanOrgBoard::new(&env::current_dir()?)?;

            match matches.subcommand() {
                ("show", Some(subcommand)) | ("s", Some(subcommand)) => {
                    print_error_and_exit(board.show(
                        subcommand.value_of("task | workflow"),
                        &mut std::io::stdout(),
                    ));
                }
                ("add", Some(subcommand)) | ("a", Some(subcommand)) => {
                    print_error_and_exit(board.add(
                        subcommand.value_of("title").unwrap(),
                        subcommand.value_of("workflow"),
                        subcommand.is_present("edit"),
                    ));
                }
                ("move", Some(subcommand)) | ("m", Some(subcommand)) => {
                    print_error_and_exit(board.relocate(
                        subcommand.value_of("task").unwrap(),
                        subcommand.value_of("workflow"),
                    ));
                }
                ("edit", Some(subcommand)) | ("e", Some(subcommand)) => {
                    print_error_and_exit(board.edit(subcommand.value_of("task").unwrap()));
                }
                ("delete", Some(subcommand)) | ("d", Some(subcommand)) => {
                    print_error_and_exit(board.delete(subcommand.value_of("task").unwrap()));
                }
                _ => println!("{}", matches.usage()),
            }
        }
    }

    Ok(())
}