shelly 0.2.0

Generate dynamic-, scripting-language projects with dependencies for quick CLI feedback loops
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

use std::fs;
use std::path;

use clap::Clap;

use shelly::config::{Config, SupportedLanguage, Target};
use shelly::elixir;

/// Generate dynamic, scripting language projects with dependencies for
/// quick CLI feedback loops.
#[derive(Clap)]
#[clap(version = "1.0", author = "Alex M. <alex41290@gmail.com>")]
struct Opts {
    /// Path to create project
    #[clap(default_value = ".")]
    path: String,

    /// Drop into REPL after building
    #[clap(short, long)]
    shell: bool,

    /// A target is a language and dependencies pairing
    #[clap(short, long)]
    target: Option<String>,

    #[clap(short, long)]
    config: Option<String>,
}

fn main() {
    let default_config = fs::read_to_string("./src/templates/shelly.yml").unwrap();

    let opts: Opts = Opts::parse();

    let config_file = if let Some(cfg) = opts.config {
        fs::read_to_string(cfg)
    } else {
        let home_path = path::PathBuf::from(std::env::var("HOME").unwrap());
        let path = home_path.join(".config").join("shelly");

        if path.clone().join("shelly.yml").as_path().exists() {
            fs::read_to_string(path.clone().join("shelly.yml"))
        } else {
            let _ = fs::create_dir_all(path.clone());
            let _ = fs::write(path.join("shelly.yml"), default_config.clone());
            Ok(default_config)
        }
    }
    .unwrap();

    let config: Config = serde_yaml::from_str(config_file.as_str()).unwrap();
    println!("{:#?}", config);

    let target_name = if let Some(t) = opts.target {
        t
    } else {
        config.default_target
    };
    let target = config.targets.get(&target_name).unwrap();
    let Target { language, deps } = target;

    match language {
        SupportedLanguage::elixir => {
            elixir::write_project(opts.path, deps.clone()).unwrap();
            elixir::run(opts.shell).unwrap();
        }
        SupportedLanguage::node => {
            panic!("Language not supported yet");
        }
        SupportedLanguage::rust => {
            panic!("Language not supported yet");
        }
    }
}