# charter

![stability: experimental](https://img.shields.io/badge/stability-experimental-red.svg)

**Potential users beware!** This is basically a glorified personal
shell script (and in fact is literally a smarter Haskell
reimplementation of what I used to do using shell scripts.) It's
designed to do what I want, and very likely doesn't do what you want
(or does it poorly or buggily.) You might want to look at
[hi](https://github.com/fujimura/hi), a very similar and much more
full-featured tool!

The *charter* tool is a tool for setting up Haskell projects. It has
three basic modes of operation which correspond to three kinds of
projects:

- `charter quick foo` creates a project called `foo` that contains a
  single executable whose entry point is in `src/Main.hs`. This is
  good for quick-and-dirty Haskell executables that need little extra
  scaffolding.
- `charter library foo` creates a project called `foo` that
  contains a library whose sources are in `src`.
- `charter executable foo` creates a project called `foo` that
  contains a binary whose entry point is in `foo/Main.hs` as well as a
  library whose sources are in `src`, and also adds a built-in `foo`
  dependency to the executable.

Some of the information needed to set up these projects is grabbed
from command-line tools, and in particular from `git` (the author and
maintainer name and email) and from `date` (the current year for
copyright information). Other pieces of information are commented out,
but can also be provided via command-line flags (such as the category,
synopsis, description, and license). Command-line flags can also add
extra binary targets, add modules to the library, or add dependencies.

Note that the flags are processed in-order and sometimes order will
affect the output.

# Example Usage

Create a library `foo` that exposes two modules, `Data.Foo` and
`Data.Bar`, and has a dependency on `bytestring`.

```bash
$ charter library foo \
    -m Data.Foo \
    -m Data.Foo.Bar \
    -a bytestring
```

Create a simple executable `cat` that depends on `text`, and has a
filled-in category and synopsis

```bash
$ charter quick haskcat \
    -a text \
    -s 'The Haskcat program' \
    -d 'Probably a pure Haskell implementation of cat, I guess?'
```

Create a library `make-it-so` which exposes the module
`Web.Make.It.So` and which depends on `warp` and `wai`, and then
create three executables as well:

```bash
$ charter library make-it-so \
    -m Web.Make.It.So \
    -a warp \
    -a wai \
    -b do-this \
    -b do-that \
    -b do-the-other
```
