devrc 0.6.0

devrc is an easy to use task runner tool on steroids for developers
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

use std::{io::Cursor, path::PathBuf};
use structopt::{
    clap::{AppSettings, Shell},
    StructOpt,
};

use std::error::Error;

use crate::errors::{DevrcError, DevrcResult};

pub fn get_crate_version() -> &'static str {
    env!("CARGO_PKG_VERSION")
}

/// Parse a single key-value pair
fn parse_key_val<T>(s: &str) -> DevrcResult<(T, T)>
where
    T: std::str::FromStr,
    T::Err: Error + 'static,
{
    let pos = s.find('=').ok_or({
        //format!("invalid KEY=value: no `=` found in `{}`", s)}
        DevrcError::InvalidArgument
    })?;
    Ok((
        s[..pos].parse().map_err(|_| DevrcError::InvalidArgument)?,
        s[pos + 1..]
            .parse()
            .map_err(|_| DevrcError::InvalidArgument)?,
    ))
}

#[derive(StructOpt, Debug)]
#[structopt(version = get_crate_version())]
#[structopt(name = "devrc")]
#[structopt(about = "⚡ task automation tool on steroids ⚡")]
#[structopt(after_help = "Wish you productive coding!
Visit https://github.com/devrc-hub/devrc to get more info about devrc.")]
#[structopt(setting = AppSettings::ColoredHelp)]
pub struct CommandLine {
    /// Specify an alternate Devrcfile files
    /// (default: Devrcfile)
    #[structopt(
        parse(from_os_str),
        name = "CONFIG",
        short = "f",
        long = "f",
        verbatim_doc_comment
    )]
    pub configs: Vec<PathBuf>,

    /// List available tasks and their arguments
    #[structopt(short = "l", long = "list")]
    pub list: bool,

    /// Show detailed tasks list
    #[structopt(short = "d", long = "detailed")]
    pub detailed: bool,

    /// Read stdin instead of reading default devrcfile
    #[structopt(long = "stdin")]
    pub read_stdin: bool,

    /// Show global variables
    #[structopt(long = "variables")]
    pub list_vars: bool,

    /// Show global environment variables
    #[structopt(long = "evariables")]
    pub list_env_vars: bool,

    /// Print shell completion script for <SHELL>
    #[structopt(long, name="SHELL", possible_values = &Shell::variants(), case_insensitive = true)]
    pub completions: Option<Shell>,

    #[structopt(name = "TASKS OR ARGS")]
    // //#[structopt(name = "TASKS", raw(setting = "AppSettings::AllowLeadingHyphen"))]
    pub rest: Vec<String>,

    /// Force to use global .devrc file
    #[structopt(short = "g")]
    pub global: bool,

    /// Print commands and skip execution
    #[structopt(long = "--dry-run")]
    pub dry_run: bool,

    /// Describe task
    #[structopt(long = "--describe")]
    pub describe: bool,

    /// Show debug info
    #[structopt(long = "--dbg-runner", hidden = true)]
    pub dbg: bool,

    // The number of occurrences of the `v/verbose` flag
    /// Enable verbose mode (-v, -vv, -vvv, etc.)
    #[structopt(short, long, parse(from_occurrences))]
    pub verbose: u8,

    /// Suppress all output
    #[structopt(short, long)]
    pub quiet: bool,

    /// Override <VARIABLE> with <VALUE>
    #[structopt(long = "--set", parse(try_from_str = parse_key_val), name="VAR=VALUE")]
    pub set: Vec<(String, String)>,
}

impl CommandLine {
    pub fn generate_completions(shell: Shell) {
        let mut cursor = Cursor::new(Vec::new());
        Self::clap().gen_completions_to(env!("CARGO_PKG_NAME"), shell, &mut cursor);
        println!(
            "{}",
            String::from_utf8(cursor.into_inner())
                .expect("Clap completion not UTF-8")
                .trim()
        );
    }
}

#[derive(Debug, Eq, PartialEq, StructOpt)]
pub enum Subcommands {
    // `external_subcommand` tells structopt to put
    // all the extra arguments into this Vec
    #[structopt(external_subcommand)]
    Other(Vec<String>),
}

pub fn parse_args() -> CommandLine {
    CommandLine::from_args()
}