shelly 0.1.0

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

extern crate clap;
extern crate os_pipe;

use std::env;
use std::fs;
use std::path;
use std::process::Command;

use clap::Clap;

/// 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 {
    #[clap(default_value = ".")]
    /// Path to create project
    path: String,
    #[clap(short)]
    /// Drop into REPL after building
    shell: bool,
}

const MIX_EXS: &str = r#"
defmodule Script.Mixfile do
  use Mix.Project

	def application do
		[applications: [:httpoison], extra_applications: [:nimble_csv, :jason]]
	end

	def project do
		[app: :script, version: "1.0.0", deps: deps()]
	end

	defp deps do
		[{:httpoison, "~> 1.7"}, {:jason, "~> 1.2"}, {:nimble_csv, "~> 1.1"}, {:floki, "~> 0.29"}]
	end
end
"#;

const PARSER: &str = r#"
NimbleCSV.define(CSVParser, separator: ",", escape: "\"")
NimbleCSV.define(TSVParser, separator: "\t", escape: "\"")

defmodule Parser do
  def parse_csv(file) do
		[ headers | data ] =
		file
		|> File.read!()
		|> CSVParser.parse_string(skip_headers: false)

		data
		|> Enum.map(&Enum.zip(headers, &1))
		|> Enum.map(&Map.new/1)
	end

	def to_csv(rows) when is_list(rows) do
		header =
		rows
		|> Enum.at(0)
		|> Map.keys()

		[header | Enum.map(rows, &Map.values/1)]
	end

	def write_csv(rows, file) when is_list(rows) do
		File.write!(file, CSVParser.dump_to_iodata(rows))
	end
end
"#;

fn main() {
    let opts = Opts::parse();

    println!("Generating mix project...");

    let folder_path = path::PathBuf::from(opts.path);

    let result: Result<(), String> = fs::create_dir_all(folder_path.clone())
        .map_err(|err| format!("Failed to create dir: {}", err))
        .and_then(|()| {
            env::set_current_dir(folder_path.clone())
                .map_err(|err| format!("Failed to set cwd: {}", err))
        })
        .and_then(|()| {
            fs::write("mix.exs", MIX_EXS)
                .map_err(|err| format!("Failed to write `mix.exs`: {}", err))
        })
        .and_then(|()| {
            fs::create_dir(path::PathBuf::from("lib"))
                .map_err(|err| format!("Failed to create `lib` dir: {}", err))
        })
        .and_then(|()| {
            fs::write(path::PathBuf::from("lib").join("parser.ex"), PARSER)
                .map_err(|err| format!("Failed to write `lib/parser.ex`: {}", err))
        });

    if let Err(error) = result {
        panic!("ahhhhhh: {}", error);
    }

    let stdout = os_pipe::dup_stdout().unwrap();
    let mut mix = match Command::new("mix")
        .args(&["do", "deps.get,", "deps.compile"])
        .stdout(stdout)
        .spawn()
    {
        Err(error) => panic!("Failed to spawn `mix` process: {}", error),
        Ok(process) => process,
    };

    let _ = mix.wait();

    if opts.shell {
        let stdout = os_pipe::dup_stdout().unwrap();
        let mut iex_command = match Command::new("iex")
            .args(&["-S", "mix"])
            .stdout(stdout)
            .stdin(os_pipe::dup_stdin().unwrap())
            .spawn()
        {
            Err(error) => panic!("Failed to run `iex` shell: {}", error),
            Ok(process) => process,
        };

        let _ = iex_command.wait();
    }
}