From c2dfd0eb03fd2aac388f8cdbdaf127dda3eba6df Mon Sep 17 00:00:00 2001
From: Greg Chapple <gregchapple1@gmail.com>
Date: Wed, 24 Jun 2015 16:42:00 +0100
Subject: [PATCH 1/3] Implement cargo project templates

Project templates allow users to define custom templates which can be
used to scaffold projects. These templates consists of a directory of
files, each of which will be treated as a mustache template.

Example:

    cargo new myproject --template=http://github.com/someone/nickel-template

This would download the template called 'nickel-template' to
~/.cargo/templates/nickel-template. Each file in that directory would
then be compiled and rendered to the new project directory created by
cargo. Once the template is downloaded, future uses can just reference
it by name:

    cargo new webapp --template nickel-template

Certain files will be ignored in template directories. These are namely
files which mustache will not be able to compile. Image files, for
example are all ignored.

Closes issue #396
---
 Cargo.lock                     |  10 ++
 Cargo.toml                     |   1 +
 src/bin/new.rs                 |  21 +--
 src/cargo/lib.rs               |   1 +
 src/cargo/ops/cargo_new.rs     | 227 ++++++++++++++++++++++++++++++---
 src/cargo/sources/git/utils.rs |   4 +-
 src/cargo/util/config.rs       |   4 +
 src/doc/guide.md               |  62 +++++++++
 src/etc/_cargo                 |   7 +-
 src/etc/cargo.bashcomp.sh      |   2 +-
 10 files changed, 302 insertions(+), 37 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2a0a9a44a9d..2aa2cbe390a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -17,6 +17,7 @@ dependencies = [
  "libc 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "libgit2-sys 0.2.17 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mustache 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "num_cpus 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex 0.1.30 (registry+https://github.com/rust-lang/crates.io-index)",
  "registry 0.1.0",
@@ -218,6 +219,15 @@ dependencies = [
  "libc 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "mustache"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "log 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rustc-serialize 0.3.14 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
 [[package]]
 name = "num_cpus"
 version = "0.2.6"
diff --git a/Cargo.toml b/Cargo.toml
index 65da37271b4..787ccdfe69b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,6 +35,7 @@ time = "0.1"
 toml = "0.1"
 url = "0.2"
 winapi = "0.1"
+mustache = "0.6.1"
 
 [dev-dependencies]
 tempdir = "0.3"
diff --git a/src/bin/new.rs b/src/bin/new.rs
index fdfb0283e0c..552763eaebd 100644
--- a/src/bin/new.rs
+++ b/src/bin/new.rs
@@ -9,6 +9,7 @@ struct Options {
     flag_bin: bool,
     arg_path: String,
     flag_name: Option<String>,
+    flag_template: Option<String>,
     flag_vcs: Option<ops::VersionControl>,
 }
 
@@ -20,31 +21,31 @@ Usage:
     cargo new -h | --help
 
 Options:
-    -h, --help          Print this message
-    --vcs <vcs>         Initialize a new repository for the given version
-                        control system (git or hg) or do not initialize any version
-                        control at all (none) overriding a global configuration.
-    --bin               Use a binary instead of a library template
-    --name <name>       Set the resulting package name
-    -v, --verbose       Use verbose output
+    -h, --help             Print this message
+    --vcs <vcs>            Initialize a new repository for the given version
+                           control system (git or hg) or do not initialize any version
+                           control at all (none) overriding a global configuration.
+    --bin                  Use a binary instead of a library template
+    --name <name>          Set the resulting package name
+    --template <template>  Use a specified template
+    -v, --verbose          Use verbose output
 ";
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     debug!("executing; cmd=cargo-new; args={:?}", env::args().collect::<Vec<_>>());
     config.shell().set_verbose(options.flag_verbose);
 
-    let Options { flag_bin, arg_path, flag_name, flag_vcs, .. } = options;
+    let Options { flag_bin, arg_path, flag_name, flag_vcs, flag_template, .. } = options;
 
     let opts = ops::NewOptions {
         version_control: flag_vcs,
         bin: flag_bin,
         path: &arg_path,
         name: flag_name.as_ref().map(|s| s.as_ref()),
+        template: flag_template.as_ref().map(|s| s.as_ref()),
     };
 
     ops::new(opts, config).map(|_| None).map_err(|err| {
         CliError::from_boxed(err, 101)
     })
 }
-
-
diff --git a/src/cargo/lib.rs b/src/cargo/lib.rs
index fde0b9bc287..3cd7c920477 100644
--- a/src/cargo/lib.rs
+++ b/src/cargo/lib.rs
@@ -22,6 +22,7 @@ extern crate threadpool;
 extern crate time;
 extern crate toml;
 extern crate url;
+extern crate mustache;
 
 use std::env;
 use std::error::Error;
diff --git a/src/cargo/ops/cargo_new.rs b/src/cargo/ops/cargo_new.rs
index 3f032b4fad9..68aa6321ff3 100644
--- a/src/cargo/ops/cargo_new.rs
+++ b/src/cargo/ops/cargo_new.rs
@@ -1,12 +1,13 @@
 use std::env;
-use std::fs::{self, File};
+use std::fs::{self, File, DirEntry, OpenOptions};
 use std::io::prelude::*;
 use std::io;
-use std::path::Path;
+use std::path::{Path, PathBuf, Component};
 
 use rustc_serialize::{Decodable, Decoder};
 
 use git2::Config as GitConfig;
+use git2::Repository;
 
 use term::color::BLACK;
 
@@ -14,6 +15,7 @@ use util::{GitRepo, HgRepo, CargoResult, human, ChainError, internal};
 use util::Config;
 
 use toml;
+use mustache;
 
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum VersionControl { Git, Hg, NoVcs }
@@ -23,6 +25,7 @@ pub struct NewOptions<'a> {
     pub bin: bool,
     pub path: &'a str,
     pub name: Option<&'a str>,
+    pub template: Option<&'a str>,
 }
 
 impl Decodable for VersionControl {
@@ -147,29 +150,123 @@ fn mk(config: &Config, path: &Path, name: &str,
         (None, None, name, None) => name,
     };
 
-    try!(file(&path.join("Cargo.toml"), format!(
-r#"[package]
-name = "{}"
-version = "0.1.0"
-authors = [{}]
-"#, name, toml::Value::String(author)).as_bytes()));
+    // find template base dir
+    let template_dir = config.template_path();
+    if fs::metadata(&template_dir).is_err() {
+        try!(fs::create_dir(&template_dir));
+    }
 
-    try!(fs::create_dir(&path.join("src")));
+    // create lib & bin templates if not already present.
+    let lib_template = template_dir.join("lib");
+    let bin_template = template_dir.join("bin");
 
-    if opts.bin {
-        try!(file(&path.join("src/main.rs"), b"\
-fn main() {
-    println!(\"Hello, world!\");
-}
-"));
-    } else {
-        try!(file(&path.join("src/lib.rs"), b"\
-#[test]
-fn it_works() {
-}
-"));
+    try!(create_bin_template(&bin_template));
+    try!(create_lib_template(&lib_template));
+
+    let template = match opts.template {
+        // given template is a remote git repository & needs to be cloned
+        // This will be cloned to .cargo/templates/<repo_name> where <repo_name>
+        // is the last component of the given URL. For example:
+        //
+        //      http://github.com/rust-lang/some-template
+        //      <repo_name> = some-template
+        Some(template) if template.starts_with("http") ||
+                          template.starts_with("git@") => {
+            let path = PathBuf::from(template);
+
+            let repo_name = match path.components().last().unwrap() {
+                Component::Normal(p) => p,
+                _ => {
+                    return Err(human(format!("Could not determine repository name from: {}", path.display())))
+                }
+            };
+            let template_path = template_dir.join(repo_name);
+
+            match Repository::clone(template, &*template_path) {
+                Ok(_) => {},
+                Err(e) => {
+                    return Err(human(format!("Failed to clone repository: {} - {}", path.display(), e)))
+                }
+            };
+
+            template_path
+        }
+
+        // given template is assumed to already be present on the users system
+        // in .cargo/templates/<name>.
+        Some(template) => { template_dir.join(template) }
+
+        // no template given, use either "lib" or "bin" templates depending on the
+        // presence of the --bin flag.
+        None => { if opts.bin { bin_template } else { lib_template } }
+    };
+
+    // make sure that the template exists
+    if fs::metadata(&template).is_err() {
+        return Err(human(format!("Template `{}` not found", template.display())))
     }
 
+    // contruct the mapping used to populate the template
+    // if in the future we want to make more varaibles available in
+    // the templates, this would be the place to do it.
+    let data = mustache::MapBuilder::new()
+        .insert_str("name", name)
+        .insert_str("authors", toml::Value::String(author))
+        .build();
+
+
+    // For every file found inside the given template directory, compile it as a mustache
+    // template and render it with the above data to a new file inside the target directory
+    try!(walk_template_dir(&template, &mut |entry| {
+        let path = entry.path();
+        let entry_str = path.to_str().unwrap();
+        let template_str = template.to_str().unwrap();
+
+        // the path we have here is the absolute path to the file in the template directory
+        // we need to trim this down to be just the path from the root of the template.
+        // For example:
+        //    /home/user/.cargo/templates/foo/Cargo.toml => Cargo.toml
+        //    /home/user/.cargo/templates/foo/src/main.rs => src/main.rs
+        let mut file_name = entry_str.replace(template_str, "");
+        if file_name.starts_with("/") {
+            file_name.remove(0);
+        }
+
+        let template = match mustache::compile_path(&path) {
+            Ok(template) => template,
+            Err(e) => panic!("Problem generating template {} - {:?}", path.display(), e)
+        };
+        let mut new_path = PathBuf::from(name).join(file_name);
+
+        // file_name could now refer to a file inside a directory which doesn't yet exist
+        // to figure out if this is the case, get all the components in the file_name and check
+        // how many there are. Files in the root of the new project direcotory will have two
+        // components, anything more than that means the file is in a sub-directory, so we need
+        // to create it.
+        {
+            let components  = new_path.components().collect::<Vec<_>>();
+            if components.len() > 2 {
+                if let Some(p) = new_path.parent() {
+                    if fs::metadata(&p).is_err() {
+                        let _ = fs::create_dir_all(&p);
+                    }
+                }
+            }
+        }
+
+        // if the template file has the ".mustache" extension, remove that to get the correct
+        // name for the generated file
+        if let Some(ext) = new_path.clone().extension() {
+            if ext.to_str().unwrap() == "mustache" {
+                new_path.set_extension("");
+            }
+        }
+
+        // create the new file & render the template to it
+        let mut file = OpenOptions::new().write(true).create(true).open(&new_path).unwrap();
+        template.render_data(&mut file, &data);
+    }));
+
     Ok(())
 }
 
@@ -219,6 +316,94 @@ fn global_config(config: &Config) -> CargoResult<CargoNewConfig> {
     })
 }
 
+/// Recursively list directory contents under `dir`, only visiting files.
+///
+/// This will also filter out files & files types which we don't want to
+/// try generate templates for. Image files, for instance.
+///
+/// It also filters out certain files & file types, as we don't want t
+///
+/// We use this instead of std::fs::walk_dir as it is marked as unstable for now
+///
+/// This is a modified version of the example at:
+///    http://doc.rust-lang.org/std/fs/fn.read_dir.html
+fn walk_template_dir(dir: &Path, cb: &mut FnMut(DirEntry)) -> CargoResult<()> {
+    let attr = try!(fs::metadata(&dir));
+
+    let ignore_files = vec!(".gitignore");
+    let ignore_types = vec!("png", "jpg", "gif");
+
+    if attr.is_dir() {
+        for entry in try!(fs::read_dir(dir)) {
+            let entry = try!(entry);
+            let attr = try!(fs::metadata(&entry.path()));
+            if attr.is_dir() {
+                if !&entry.path().to_str().unwrap().contains(".git") {
+                    try!(walk_template_dir(&entry.path(), cb));
+                }
+            } else {
+                if let &Some(extension) = &entry.path().extension() {
+                    if ignore_types.contains(&extension.to_str().unwrap()) {
+                        continue
+                    }
+                }
+                if let &Some(file_name) = &entry.path().file_name() {
+                    if ignore_files.contains(&file_name.to_str().unwrap()) {
+                        continue
+                    }
+                }
+                cb(entry);
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Create a generic template
+///
+/// This consists of a Cargo.toml, and a src directory.
+fn create_generic_template(path: &PathBuf) -> CargoResult<()> {
+    match fs::metadata(&path) {
+        Ok(_) => {}
+        Err(_) => { try!(fs::create_dir(&path)); }
+    }
+    match fs::metadata(&path.join("src")) {
+        Ok(_) => {}
+        Err(_) => { try!(fs::create_dir(&path.join("src"))); }
+    }
+    try!(file(&path.join("Cargo.toml"), b"\
+[package]
+name = \"{{name}}\"
+version = \"0.1.0\"
+authors = [{{{authors}}}]
+"));
+    Ok(())
+}
+
+/// Create a new "lib" project
+fn create_lib_template(path: &PathBuf) -> CargoResult<()> {
+    try!(create_generic_template(&path));
+    try!(file(&path.join("src/lib.rs"), b"\
+#[test]
+fn it_works() {
+}
+"));
+    Ok(())
+}
+
+/// Create a new "bin" project
+fn create_bin_template(path: &PathBuf) -> CargoResult<()> {
+    try!(create_generic_template(&path));
+    try!(file(&path.join("src/main.rs"), b"\
+fn main() {
+    println!(\"Hello, world!\");
+}
+"));
+
+    Ok(())
+}
+
+
 #[cfg(test)]
 mod tests {
     use super::strip_rust_affixes;
diff --git a/src/cargo/sources/git/utils.rs b/src/cargo/sources/git/utils.rs
index c1d0b6068cd..6d43b8c6922 100644
--- a/src/cargo/sources/git/utils.rs
+++ b/src/cargo/sources/git/utils.rs
@@ -146,7 +146,7 @@ impl GitRemote {
         fetch(dst, &url, refspec)
     }
 
-    fn clone_into(&self, dst: &Path) -> CargoResult<git2::Repository> {
+    pub fn clone_into(&self, dst: &Path) -> CargoResult<git2::Repository> {
         let url = self.url.to_string();
         if fs::metadata(&dst).is_ok() {
             try!(fs::remove_dir_all(dst));
@@ -159,7 +159,7 @@ impl GitRemote {
 }
 
 impl GitDatabase {
-    fn path<'a>(&'a self) -> &'a Path {
+    pub fn path<'a>(&'a self) -> &'a Path {
         &self.path
     }
 
diff --git a/src/cargo/util/config.rs b/src/cargo/util/config.rs
index 90c971e8338..b4258a99b78 100644
--- a/src/cargo/util/config.rs
+++ b/src/cargo/util/config.rs
@@ -64,6 +64,10 @@ impl Config {
 
     pub fn home(&self) -> &Path { &self.home_path }
 
+    pub fn template_path(&self) -> PathBuf {
+        self.home_path.join("templates")
+    }
+
     pub fn git_db_path(&self) -> PathBuf {
         self.home_path.join("git").join("db")
     }
diff --git a/src/doc/guide.md b/src/doc/guide.md
index 914726c34d6..303894a1e60 100644
--- a/src/doc/guide.md
+++ b/src/doc/guide.md
@@ -35,6 +35,9 @@ We're passing `--bin` because we're making a binary program: if we
 were making a library, we'd leave it off. If you'd like to not initialize a new
 git repository as well (the default), you can also pass `--vcs none`.
 
+You can also use your own template to scaffold cargo projects! See the
+[Templates](#templates) section for more details.
+
 Let's check out what Cargo has generated for us:
 
 ```shell
@@ -439,3 +442,62 @@ To test your project on Travis-CI, here is a sample `.travis.yml` file:
 ```
 language: rust
 ```
+
+# Templates
+
+Cargo uses the mustache library to compile the templates used to scaffold
+projects. By default, there are only two templates available, `bin` and `lib`.
+These are used by cargo to create the standard project structure.
+
+You can also specify other templates from which to scaffold your project. The
+`--template` argument to `cargo new` accepts either a template name that you
+have downloaded on your system, or a URL to a remote Git repository containing
+the project template.
+
+```
+# use the mytemplate template which is located in .cargo/templates/mytemplate
+$ cargo new myproj --template mytemplate
+
+# download the template called mytemplate from your github package
+$ cargo new myproj --template http://github.com/you/mytemplate
+```
+
+## Creating new templates
+
+A cargo template is just a folder containing one or more files. Usually, there
+is a `Cargo.toml` and a `src` directory. Each file in the template directory
+will be treated as a mustache template. This means you can use mustache
+variables wherever you want dynamic content, and cargo will render the proper
+values. Let's create a simple example. Create a new folder called `mytemplate`.
+Add the following files:
+
+```toml
+# Cargo.toml
+[project]
+name = "{{name}}"
+version = "0.1.0"
+authors = [{{{authors}}}]
+```
+
+```rust
+// src/main.rs
+fn main() {
+    prinln!("This is the {{name}} project!");
+}
+```
+
+Upload this to a public git repository and anyone can now use it to start their
+projects with this command:
+
+```
+$ cargo new proj --template http://your/project/repo
+```
+
+## Available variables
+
+The variables available for use are:
+
+- name: the name of the project
+- authors: the toml formatted name of the project author
+
+In the future, more variables may be added. Suggestions welcome!
diff --git a/src/etc/_cargo b/src/etc/_cargo
index 3e5095bf053..3deeb76b990 100644
--- a/src/etc/_cargo
+++ b/src/etc/_cargo
@@ -126,6 +126,7 @@ case $state in
                     '(-h, --help)'{-h,--help}'[show help message]' \
                     '--hg[initialize new mercurial repo]' \
                     '--no-git[no new git repo]' \
+                    '--template[template from which to scaffold your project]' \
                     '(-v, --verbose)'{-v,--verbose}'[use verbose output]' \
                     ;;
 
@@ -284,7 +285,7 @@ regexp-replace manifest '\{"root":"|"\}' ''
 echo $manifest
 }
 
-# Extracts the values of "name" from the array given in $1 and shows them as 
+# Extracts the values of "name" from the array given in $1 and shows them as
 # command line options for completion
 _get_names_from_array()
 {
@@ -303,7 +304,7 @@ _get_names_from_array()
     do
         if [[ $last_line == "[[$block_name]]" ]]; then
             in_block=true
-        else 
+        else
             if [[ $last_line =~ '.*\[\[.*' ]]; then
                 in_block=false
             fi
@@ -314,7 +315,7 @@ _get_names_from_array()
                 regexp-replace line '^.*name *= *|"' ""
                 names+=$line
             fi
-        fi 
+        fi
 
         last_line=$line
     done < $manifest
diff --git a/src/etc/cargo.bashcomp.sh b/src/etc/cargo.bashcomp.sh
index 797e4b88df5..0a19026d6be 100644
--- a/src/etc/cargo.bashcomp.sh
+++ b/src/etc/cargo.bashcomp.sh
@@ -24,7 +24,7 @@ _cargo()
 	local opt__git_checkout="$opt_common --reference= --url="
 	local opt__locate_project="$opt_mani -h --help"
 	local opt__login="$opt_common --host"
-	local opt__new="$opt_common --vcs --bin --name"
+	local opt__new="$opt_common --vcs --bin --name --template"
 	local opt__owner="$opt_common -a --add -r --remove -l --list --index --token"
 	local opt__pkgid="${opt__fetch}"
 	local opt__publish="$opt_common $opt_mani --host --token --no-verify"

From 3ee5442815059bed033a2cd1196034a3f574411e Mon Sep 17 00:00:00 2001
From: Greg Chapple <gregchapple1@gmail.com>
Date: Fri, 26 Jun 2015 11:32:46 +0100
Subject: [PATCH 2/3] Revert changes to method visibility

---
 src/cargo/sources/git/utils.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/cargo/sources/git/utils.rs b/src/cargo/sources/git/utils.rs
index 6d43b8c6922..c1d0b6068cd 100644
--- a/src/cargo/sources/git/utils.rs
+++ b/src/cargo/sources/git/utils.rs
@@ -146,7 +146,7 @@ impl GitRemote {
         fetch(dst, &url, refspec)
     }
 
-    pub fn clone_into(&self, dst: &Path) -> CargoResult<git2::Repository> {
+    fn clone_into(&self, dst: &Path) -> CargoResult<git2::Repository> {
         let url = self.url.to_string();
         if fs::metadata(&dst).is_ok() {
             try!(fs::remove_dir_all(dst));
@@ -159,7 +159,7 @@ impl GitRemote {
 }
 
 impl GitDatabase {
-    pub fn path<'a>(&'a self) -> &'a Path {
+    fn path<'a>(&'a self) -> &'a Path {
         &self.path
     }
 

From 0aafbc5bfc5a9d62dc84539d449907339169e880 Mon Sep 17 00:00:00 2001
From: Greg Chapple <gregchapple1@gmail.com>
Date: Mon, 29 Jun 2015 10:38:37 +0100
Subject: [PATCH 3/3] Fixed line length issues

---
 src/cargo/ops/cargo_new.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/cargo/ops/cargo_new.rs b/src/cargo/ops/cargo_new.rs
index 68aa6321ff3..7a6eadef42c 100644
--- a/src/cargo/ops/cargo_new.rs
+++ b/src/cargo/ops/cargo_new.rs
@@ -177,7 +177,8 @@ fn mk(config: &Config, path: &Path, name: &str,
             let repo_name = match path.components().last().unwrap() {
                 Component::Normal(p) => p,
                 _ => {
-                    return Err(human(format!("Could not determine repository name from: {}", path.display())))
+                    return Err(human(format!(
+                        "Could not determine repository name from: {}", path.display())))
                 }
             };
             let template_path = template_dir.join(repo_name);
@@ -185,7 +186,8 @@ fn mk(config: &Config, path: &Path, name: &str,
             match Repository::clone(template, &*template_path) {
                 Ok(_) => {},
                 Err(e) => {
-                    return Err(human(format!("Failed to clone repository: {} - {}", path.display(), e)))
+                    return Err(human(format!(
+                        "Failed to clone repository: {} - {}", path.display(), e)))
                 }
             };