Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/vmchale/project-init

Project templates in rust
https://github.com/vmchale/project-init

command-line-tool cookiecutter elm elm-lang haskell idris miso mustache rust template-project

Last synced: 7 days ago
JSON representation

Project templates in rust

Awesome Lists containing this project

README 

        
# project init (pi)



[![Build Status](https://travis-ci.org/vmchale/project-init.svg?branch=master)](https://travis-ci.org/vmchale/project-init)

[![](https://img.shields.io/crates/d/project-init.svg)](https://crates.io/crates/project-init)

[![Windows build status](https://ci.appveyor.com/api/projects/status/github/vmchale/project-init?svg=true)](https://ci.appveyor.com/project/vmchale/project-init)



`pi` is a command-line utility to initialize projects. It is written in rust.



It is intended to provide something like 

[cookiecutter](https://github.com/audreyr/cookiecutter), but faster.



Reasons to use pi:

  - You want to automate the process of starting a new project, for *all* your

    projects.

  - You want project initialization that's *quick*



Reasons to use pi over cookiecutter:

  - Templates are smaller. Define files you need in a `.toml`.

  - *Fast*. pi is **30x faster** than cookiecutter when rendering the sample vim

    plugin template.

  - pi uses mustache, a logic-less language, for templates.

  - pi can initialize a darcs, pijul, mercurial, or git repository inside your projects

  - pi provides opinionated templates for many languages

  - pi is extensible in Rust



Reasons to not use pi over cookiecutter:

  - cookiecutter uses [jinja](http://jinja.pocoo.org/) templates, which are far more sophisticated.

  - pi is newer and presumably more buggy

  - cookiecutter is extensible in Python



Benchmarks (with Haskell's [bench](https://github.com/Gabriel439/bench)):



| Tool | Language | Time (vim example plugin) | Time (rust library) |

| ---- | -------- | ------------------------- | ------------------- |

| pi init | rust | 10.10 ms | 8.809 ms |

| pi new | rust | 6.672 ms | 8.653 ms |

| cookiecutter | python | 317.1 ms | 316.9 ms |



## Installation



### Script



Enter the following in a command prompt:



```

curl -LSfs https://japaric.github.io/trust/install.sh | sh -s -- --git vmchale/project-init

```



### Binary releases



The easiest way for most users is simply to download the prebuilt binaries.

You can find binaries for various platforms on the

[release](https://github.com/vmchale/project-init/releases) page.



### Cargo



First, install [cargo](https://rustup.rs/). Then:



```bash

 $ cargo install project_init

```



You will need to use the nightly release for this to work; if in doubt run



```bash

rustup run nightly cargo install project_init

```



## Use



`pi` reads from `$HOME/.pi_templates/` *and* your current directory. So, if you

place a template in the `$HOME/.pi_templates/idris/`, you can initialize a

project *anywhere* with



```bash

 $ pi init idris treesod

```



There is a repo containing pi templates

[here](https://github.com/vmchale/pi-templates). 



You can also use pi with built-in templates, viz. 



```bash

 $ pi new haskell really-good-project

Finished initializing project in really-good-project/

```



Or to fetch a template from github:



```bash

 $ pi git vmchale/haskell-ats ambitious-insane-project

```



### Examples



  * [haskell-ats](https://github.com/vmchale/haskell-ats) - a template for

    Haskell/ATS polyglot projects.

  * [madlang-miso](https://github.com/vmchale/madlang-miso) - a template for

    frontend using [Miso](https://haskell-miso.org/) and

    [Madlang](https://hub.darcs.net/vmchale/madlang).

  * [ats-makefile](https://github.com/vmchale/ats-makefile) - a template for ATS

    projects that uses a plain `Makefile`.



### Configuration



Global configuration is via the `$HOME/.pi.toml` file. The following is an example:



```toml

license = "BSD3"         # set default license to BSD3 

version_control = "git"  # initialize new repositories with git

version = "0.1.0"        # start new projects at version 0.1.0



[author]

name = "Vanessa McHale"

email = "[email protected]"

github_username = "vmchale"



# put any custom keys you want under a [[user]] table

[[user]]

website = "https://vmchale.com"

```



Project-specific config lives in `$PROJECT_NAME/template.toml`. The following is

an example for a vim plugin:



```toml

license = "BSD3"        # overrides global value if set

with_readme = true      # add README.md



[files]

files = ["syntax/{{ project }}.vim","plugin/{{ project }}.vim","doc/{{ project }}.txt"] # blank files

directories = ["doc","syntax","plugin"]

templates = ["vimball.txt"] # files to be processed



[config]

version = "0.1.0"

version_control = "darcs"



# put any custom keys you want below [[user]]

[[user]]

vim_org_username = "vmchale"

```



This will generate the following directory structure:



```

vim-plugin

├── LICENSE

├── README.md

├── doc

│  └── vim-plugin.txt

├── plugin

│  └── vim-plugin.vim

├── syntax

│  └── vim-plugin.vim

└── vimball.txt

```



For a more in-depth example, see

[here](https://github.com/vmchale/madlang-miso). This is a template based off

the [recursion schemes

generator](http://vmchale.com/recursion-scheme-generator/index.html).



### Templates



`pi` uses [mustache](https://mustache.github.io/) for templating, via the

[rustache](https://github.com/rustache/rustache) crate.



You can find examples and help on the [mustache page](https://mustache.github.io/), or you can my look at [the example repo](https://github.com/vmchale/pi-templates).