kickstart 0.3.0

A simple way to get started with a project by scaffolding from a template powered by the Tera engine
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

use std::env;
use std::error::Error;
use std::path::Path;

use clap::{crate_authors, crate_description, crate_version, App, AppSettings, Arg, SubCommand};

use kickstart::generation::Template;
use kickstart::terminal;
use kickstart::validate::validate_file;

pub fn build_cli() -> App<'static, 'static> {
    App::new("kickstart")
        .version(crate_version!())
        .author(crate_authors!())
        .about(crate_description!())
        .setting(AppSettings::SubcommandsNegateReqs)
        .arg(
            Arg::with_name("template")
                .required(true)
                .help("Template to use: a local path or a HTTP url pointing to a Git repository"),
        )
        .arg(
            Arg::with_name("output-dir")
                .short("o")
                .long("output-dir")
                .takes_value(true)
                .help("Where to output the project: defaults to the current directory"),
        )
        .arg(
            Arg::with_name("sub-dir")
                .short("s")
                .long("sub-dir")
                .takes_value(true)
                .help("A subdirectory of the chosen template to use, to allow nested templates."),
        )
        .arg(
            Arg::with_name("no-input")
                .long("no-input")
                .help("Do not prompt for parameters and only use the defaults from template.toml"),
        )
        .subcommands(vec![SubCommand::with_name("validate")
            .about("Validates that a template.toml is valid")
            .arg(Arg::with_name("path").required(true).help("The path to the template.toml"))])
}

fn bail(e: &dyn Error) -> ! {
    terminal::error(&format!("Error: {}", e));
    let mut cause = e.source();
    while let Some(e) = cause {
        terminal::error(&format!("Reason: {}", e));
        cause = e.source();
    }
    ::std::process::exit(1)
}

fn main() {
    let matches = build_cli().get_matches();

    match matches.subcommand() {
        ("validate", Some(matches)) => {
            let errs = match validate_file(matches.value_of("path").unwrap()) {
                Ok(e) => e,
                Err(e) => bail(&e),
            };

            if !errs.is_empty() {
                terminal::error("The template.toml is invalid:\n");
                for err in errs {
                    terminal::error(&format!("- {}\n", err));
                }
                ::std::process::exit(1);
            } else {
                terminal::success("The template.toml file is valid!\n");
            }
        }
        _ => {
            // The actual generation call
            let template_path = matches.value_of("template").unwrap();
            let output_dir = matches
                .value_of("output-dir")
                .map(|p| Path::new(p).to_path_buf())
                .unwrap_or_else(|| env::current_dir().unwrap());
            let no_input = matches.is_present("no-input");
            let sub_dir = matches.value_of("sub-dir");

            let template = match Template::from_input(template_path, sub_dir) {
                Ok(t) => t,
                Err(e) => bail(&e),
            };

            match template.generate(&output_dir, no_input) {
                Ok(_) => terminal::success("\nEverything done, ready to go!\n"),
                Err(e) => bail(&e),
            };
        }
    }
}