Plantation NPM

Plantation

plantation is a collection of cake tasks to simplify working on projects using multiple transpilers, particularly coffeescript and YAML. It has strong opinions about the tools you want to use.

Status

The project is currently under very fitful development, and may be subject to breaking rewrites at any time.

Installation

There are two ways to install plantation:

Install globally
You can install plantation globally:
```
npm install -g plantation
```
You can then run plantation in your shell to see the list of commands available.
This option is not really recommended, it ties all your projects to the same version.
Install locally
You can install plantation locally on a per-project basis:
```
npm install plantation
```
You can then run node_module/.bin/plantation in your shell to see the list of commands available. Alternatively, you can create/modify a Cakefile to contain:
```
do require 'plantation'
```
You can then run cake in your shell to see the list of commands available.
This will load the tasks from the local installation of plantation. This allows you to lock your project on a specific version of plantation, giving you a way to hide from breaking changes.

Usage

Run the commands below with the executable you installed.

info

Shows the configuration that plantation will run with. Configuration is typically inferred based on convention, but can be given explicitly (see API).

The configuration shown will look something like:

Plantation options:
  directories:         # the directories plantation will use
    current: <cwd>     # the 'project directory'
    source:  <cwd>/src # the directory in which plantation will look for source files to compile
    target:  <cwd>     # the directory in which plantation will write compiled files
  compilers:           # the compilers plantation has registered
    coffee             # the coffeescript compiler
    yaml               # the YAML compiler

build:compiler
Performs a build, either with all registered compilers or a specific compiler.
A build involves trying to compile every source file with every compiler (though typically the compiler will only agree to compile files with a specific file extension).
Running plantation build will produce something like:
```
coffee : src/lib/class.coffee > lib/class.js
  yaml : src/package.yml      > package.json
```
watch:compiler
Starts watching all files in the source directory. When they change they will be built, either with the given compiler or with all registered compilers.
Running plantation watch, then editting src/package.yml will produce something like:
```
yaml : src/package.yml  >  package.json
```
test:watch
test runs all tests using mocha. test:watch provides the --watch argument to mocha. chai.expect and sinon are available globally in the tests, and chai is configured to use sinon-chai assertions.
Default mocha configuration can be overidden by setting the mocha key when configuring plantation.
See the mocha homepage for more information about mocha.
bump:{major,minor,patch,pre}
Bumps a bit of the version and overwrites the version in <source directory>/package.yml, then performs a build to update package.json. Uses semver for manipulating versions.
The output from bump:minor might look like:
```
bumping 0.2.3 -> 0.3.0
wrote src/package.yml
  yaml : src/package.yml  >  package.json
```
tag:{major,minor,patch,pre}
Performs a bump of the given bit, then commits the changed package file and tags the commit. The commit message, tag name, and tag message will all simply equal <new version>.
The output from tag:minor might look like:
```
bumping 0.2.3 -> 0.3.0
wrote src/package.yml
  yaml : src/package.yml  >  package.json
tagged 0.3.0
```
publish:{major,minor,patch,pre}
Performs a tag of the given bit, then pushes the new HEAD to origin/master, pushes the new tag and publishes the new version to npm.
The output from publish:minor might look like:
```
bumping 0.2.3 -> 0.3.0
wrote src/package.yml
  yaml : src/package.yml  >  package.json
tagged 0.3.0
[git push output]
   abc123..def456  HEAD -> master
 * [new tag]       0.3.0 -> 0.3.0
published 0.3.0
```