Initial commit

Author: Vincent Prouillet

.editorconfig

@@ -0,0 +1,5 @@
+[*.rs]
+end_of_line = lf
+charset = utf-8
+indent_style = space
+indent_size = 4

.gitignore

@@ -0,0 +1,13 @@
+/*.iml
+/.idea
+target/
+Cargo.lock
+notes
+out.html
+*.bench
+node_modules
+yarn.lock
+public/
+*.css
+Hello/
+clicli/

Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "kickstart"
+version = "0.0.1"
+description = "A simple way to get started with a project"
+authors = ["Vincent Prouillet <prouillet.vincent@gmail.com>"]
+license = "MIT"
+
+[[bin]]
+name = "kickstart"
+
+[dependencies]
+clap = "2"
+tera = "0.11"
+toml = "0.4"
+walkdir = "2"

LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Vincent Prouillet
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

README.md

@@ -0,0 +1,13 @@
+# kickstart
+
+A very WIP equivalent of [cookiecutter](https://github.com/audreyr/cookiecutter)
+in Rust.
+
+## Run on examples
+
+- cargo run -- examples/super-basic
+- cargo run -- examples/rust-cli -o clicli
+
+## TODO
+
+- Use template from git urls

examples/rust-cli/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "{{bin_name}}"
+version = "0.1.0"
+authors = ["{{author_name}} <{{author_mail}}>"]
+description = "{{description}}"
+
+[dependencies]
+{%- if use_clap %}
+clap = "2"
+{% endif -%}

examples/rust-cli/README.md

@@ -0,0 +1 @@
+# {{ bin_name | capitalize }}

examples/rust-cli/src/main.rs

@@ -0,0 +1,17 @@
+{% if use_clap %}
+#[macro_use]
+extern crate clap;
+{% endif %}
+
+fn main() {
+    {% if use_clap -%}
+    let app = App::new("{{bin_name}}")
+        .version(crate_version!())
+        .author(crate_authors!())
+        .about(crate_description!());
+
+    let matches = app.get_matches();
+    {%- else -%}
+    println!("Hello, world!");
+    {%- endif %}
+}

examples/rust-cli/template.toml

@@ -0,0 +1,19 @@
+[bin_name]
+default = "Bin"
+question = "Binary name?"
+
+[description]
+default = "Some CLI app"
+question = "A description for that binary?"
+
+[author_name]
+default = "Vincent"
+question = "Your name?"
+
+[author_mail]
+default = "spam@spam.com"
+question = "Your email?"
+
+[use_clap]
+default = true
+question = "Do you want clap set-up?"

examples/super-basic/template.toml

@@ -0,0 +1,11 @@
+[directory_name]
+default = "Hello"
+question = "Directory name?"
+
+[file_name]
+default = "Howdy"
+question = "File name?"
+
+[greeting_recipient]
+default = "Vincent"
+question = "Who am I greeting?"

examples/super-basic/{{directory_name}}/{{file_name}}.py

@@ -0,0 +1 @@
+print("Hello, {{greeting_recipient}}!")

src/cli.rs

@@ -0,0 +1,21 @@
+use clap::{App, Arg};
+
+pub fn build_cli() -> App<'static, 'static> {
+    App::new("kickstart")
+        .version(crate_version!())
+        .author(crate_authors!())
+        .about(crate_description!())
+        .arg(
+            Arg::with_name("template")
+                .required(true)
+                .help("Template to use: a local path or a url")
+        )
+        .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")
+        )
+        .subcommands(vec![])
+}

src/main.rs

@@ -0,0 +1,25 @@
+#[macro_use]
+extern crate clap;
+extern crate tera;
+extern crate toml;
+extern crate walkdir;
+
+use std::env;
+use std::path::Path;
+
+mod cli;
+mod template;
+mod prompt;
+
+use template::Template;
+
+
+fn main() {
+    let matches = cli::build_cli().get_matches();
+    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 template = Template::from_cli(template_path);
+    template.generate(output_dir);
+}

src/prompt.rs

@@ -0,0 +1,42 @@
+use std::io::{self, Write, BufRead};
+
+
+/// Wait for user input and return what they typed
+fn read_line() -> String {
+    let stdin = io::stdin();
+    let stdin = stdin.lock();
+    let mut lines = stdin.lines();
+    lines
+        .next()
+        .and_then(|l| l.ok())
+        .unwrap()
+}
+
+/// Ask a yes/no question to the user
+pub fn ask_bool(question: &str, default: bool) -> bool {
+    print!("{} {}: ", question, if default { "[Y/n]" } else { "[y/N]" });
+    let _ = io::stdout().flush();
+    let input = read_line();
+
+    match &*input {
+        "y" | "Y" | "yes" | "YES" | "true" => true,
+        "n" | "N" | "no" | "NO" | "false" => false,
+        "" => default,
+        _ => {
+            println!("Invalid choice: '{}'", input);
+            ask_bool(question, default)
+        },
+    }
+}
+
+/// Ask a question to the user where they can write any string
+pub fn ask_string(question: &str, default: &str) -> String {
+    print!("{} ({}): ", question, default);
+    let _ = io::stdout().flush();
+    let input = read_line();
+
+    match &*input {
+        "" => default.to_string(),
+        _ => input,
+    }
+}

src/template.rs

@@ -0,0 +1,108 @@
+use std::fs::{File, create_dir_all};
+use std::io::prelude::*;
+use std::path::{Path, PathBuf};
+
+use toml::{self, Value as TomlValue};
+use tera::{Tera, Context};
+use walkdir::WalkDir;
+
+use prompt::{ask_string, ask_bool};
+
+
+// TODO: error handling
+pub fn read_file(p: &Path) -> String {
+    let mut f = File::open(p).expect("file not found");
+
+    let mut contents = String::new();
+    f.read_to_string(&mut contents)
+        .expect("something went wrong reading the file");
+
+    contents
+}
+
+pub fn write_file(p: &Path, contents: &str) {
+    let mut f = File::create(p).expect("Unable to create file");
+    f.write_all(contents.as_bytes()).expect("Unable to write data");
+}
+
+pub fn create_directory(path: &Path) {
+    if !path.exists() {
+        create_dir_all(path).unwrap();
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Template {
+    path: PathBuf,
+    name: String,
+}
+
+impl Template {
+    pub fn from_cli(path: &str) -> Template {
+        // TODO: templates can be from git as well, not only local
+        let path = Path::new(path);
+        let name = path.file_name().unwrap().to_string_lossy();
+
+        Template {
+            path: path.to_path_buf(),
+            name: name.to_string(),
+        }
+    }
+
+    pub fn download_from_vcs(&self) {
+        // TODO
+    }
+
+    fn ask_questions(&self, conf: TomlValue) -> Context {
+        let table = conf.as_table().unwrap();
+        let mut context = Context::new();
+
+        for (key, data) in table {
+            let question = data["question"].as_str().unwrap();
+            if let Some(b) = data["default"].as_bool() {
+                let res = ask_bool(question, b);
+                context.add(key, &res);
+
+            } else {
+                let res = ask_string(question, data["default"].as_str().unwrap());
+                context.add(key, &res);
+            };
+        }
+
+        context
+    }
+
+    // TODO: error handling
+    pub fn generate(&self, output_dir: PathBuf) {
+        // Get the variables from the user first
+        let conf_path = self.path.join("template.toml");
+        if !conf_path.exists() {
+            panic!("template.toml missing")
+        }
+        let conf: TomlValue = toml::from_str(&read_file(&conf_path)).unwrap();
+        let context = self.ask_questions(conf);
+
+        if !output_dir.exists() {
+            create_directory(&output_dir);
+        }
+
+        // And now generate the files (in current directory for now)
+        for entry in WalkDir::new(&self.path).into_iter().filter_map(|e| e.ok()) {
+            // Skip root folder and the template.toml
+            if entry.path() == self.path || entry.path() == conf_path {
+                continue;
+            }
+            let path = entry.path().strip_prefix(&self.path).unwrap();
+            // TODO: only render tpl if {{..}}
+            let tpl = Tera::one_off(&format!("{}", path.display()), &context, false).unwrap();
+            let real_path = Path::new(&tpl);
+
+            if entry.path().is_dir() {
+                create_directory(&output_dir.join(real_path));
+            } else {
+                let contents = Tera::one_off(&read_file(&entry.path()), &context, false).unwrap();
+                write_file(&output_dir.join(real_path), &contents);
+            }
+        }
+    }
+}