Add Vim help integration tests

With the magic of copy-pasta. Will refactor away the duplication presently.

Indentation

Add (Markdown) integration tests

Plaintext to follow. Just need to figure out a way to do it cleanly.

Add integration test files

Copied into place with:

git --git-dir ~/code/ferret/.git archive --prefix=ferret/input/ master | tar -x -C tests/fixtures/integration -f -
git --git-dir ~/code/scalpel/.git archive --prefix=scalpel/input/ master | tar -x -C tests/fixtures/integration -f -

Will add more of these, I guess, as I start using docvim in more places.

More misguided refactoring

Start refactoring golden tests to support end-to-end testing

Show compiled AST when debug flag is set

Remove a stale comment

Fix remaining lint about duplication

First lint-free status in months. Yay.

Make linter happier about duplication

Still not entirely happy.

Add bin/clean script

Add bin/build script and use it

Fix remaining warnings

Which means we can turn -Werror back on.

Made sure to get a full rebuild with:

```
rm -rf .stack-work/dist/*
bin/build # really just `stack build --file-watch`
bin/lint
bin/test
```

Further improve type annotations

Improve Parse.hs type signatures

With the help of:

http://stackoverflow.com/questions/37739029/understanding-parsec-type-annotations

Now warning-free.

Fix a bunch of warnings from -W -Wall

In many ways, this makes the code uglier, but have to get worse in order to get
better, I think. Will keep ploughing on.

Back out -Werror

Not ready for it yet after all, still plenty to do.

Remove some over-zealous indentation

Turn on -Wall -Werror -W

I think we're clean even with all these turned on. Great. Want this now that we
are not being explicit about imports.

Some tweaks needed to keep the tests clean. Notably, to deal with:

    Defaulting the following constraint(s) to type ‘Integer’
      (Eq a0) arising from a use of ‘@=?’ at tests/Tasty.hs:35:7-9
      (Num a0) arising from the literal ‘7’ at tests/Tasty.hs:35:5
      (Show a0) arising from a use of ‘@=?’ at tests/Tasty.hs:35:7-9
      (Num a0) arising from a use of ‘walk’ at tests/Tasty.hs:48:30-33

Need to opt out of `-fwarn-type-defaults` in Tasty.hs.

Cut back on explicit imports as per the GHC style guide

Quoting:

> Do not use explicit import lists, except to resolve name clashes. There are several reasons for this:
>
> - They slow down development: almost every change is accompanied by an import
>   list change.
> - They cause spurious conflicts between developers.
> - They lead to useless warnings about unused imports, and time wasted trying
>   to keep the import declarations "minimal".
> - GHC's warnings are useful for detecting unnecessary imports: see
>   `-fwarn-unused-imports`.
> - TAGS is a good way to find out where an identifier is defined (use `make tags`
>   in `ghc/compiler`, and hit `M-.` in emacs).

https://ghc.haskell.org/trac/ghc/wiki/Commentary/CodingStyle

Fair enough then!

Silence build complaints about tasty other-modules being messing

Specifically:

```
Warning: modules not listed in docvim.cabal for 'tasty' component (add to
other-modules):
```

Move under Text.* namespace

Closes: https://github.com/wincent/docvim/issues/7

doc: add CHANGELOG.md

doc: update README

- Note new annotations.
- Add notes on release process.
- Add links section.
- Add installation section.

Prepare for 0.0.0.2 release

Previous release doesn't seem to be available for download, possibly due to a
mismatch in the version numbers/tags.

Fix ordering within links in TOC

Don't hardwrap inside fenced codeblocks

Add source-repository info to docvim.cabal

As recommended by `cabal check`.

Try to make `toc` more readable

Instead of threading the `suffix` through multiple layers of function calls,
create a new scope with an inner function `toc'` that we can use to have
implicit access to it instead.

I think this might be more readable, although it is still somewhat of a hot
mess.

Print TOC in Vim output

Make sure generated headings appear in TOC node

Mostly-working TOC generation for AST

Not used in printers yet, and also note that because the printers may generate
headings of their own, we are missing generated headings.

Remove unused type declaration

Use function application operator as reducer

I like this.

Improve ordering in the compiler

Make the footer go at the end. Not that the order matters, this just looks
better. (And speaking of the ordering not matter, that makes me wonder if there
is something Applicative I could to here... Probably not. Also thinking of using
a State monad or even just a simple fold to get rid of those intermediate
bindings.)

Fix options parsing when no default value is provided

Prefer named imports

Inject other kinds of headings

Mostly seems to work? Other than some suspicious empty
headings in some golden files.

DRY up injection

Auto-inject @commands annotation when necessary

Fix lints

More elegant solution for state passthrough

Avoid unwanted intermediate list in `cosmosOf uniplate`

Who knows: perhaps Haskell's magical laziness would have made these equivalent,
or perhaps this still ends up producing an intermediate list. But at least it
*looks* better.

Figured out by poring over the function list in the lens docs looking for likely
candidates.

Use mapM_ rather than mapM in the Section visitor

To make it clear that we don't care about the results, only the state.

Add Section visitor

It's job is to check which kinds of annotations we have, in order to decide
which sections we need to render.

I am probably doing something clowny with the way I am mashing uniplate and
lenses etc together, but it does seem to work. That last `get`/`put` case is a
smell, but needed it given my use of `cosmosOf`; not sure how to avoid that.
Also, not sure why `mapM` does the right thing here, but it does.

Try to trick linter about duplication

It's been warning about this since forever:

```
Found:
  first <- firstLine
  rest <- many otherLine
  let nodes = concatMap appendWhitespace (first : rest)
  let compressed = compress nodes
  return
    (if last compressed == Whitespace then init compressed else
       compressed)

Why not:
  Combine with lib/Docvim/Parse.hs:202:7

lib/Docvim/Parse.hs:164:7: Warning: Reduce duplication
Found:
  first <- firstLine
  rest <- many otherLine
  let nodes = concatMap appendWhitespace (first : rest)
  let compressed = compress nodes
  return
    (if last compressed == Whitespace then init compressed else
       compressed)

Why not:
  Combine with lib/Docvim/Parse.hs:285:7
```

However, it is too smart. Even with this change, it still complains:

```
Found:
  first <- firstLine
  rest <- many otherLine
  let nodes = concatMap appendWhitespace (first : rest)
  let compressed = compress nodes
  return
    (if last compressed == Whitespace then init compressed else
       compressed)

Why not:
  Combine with lib/Docvim/Parse.hs:282:7

lib/Docvim/Parse.hs:165:7: Suggestion: Reduce duplication
Found:
  rest <- many otherLine
  let nodes = concatMap appendWhitespace (first : rest)
  let compressed = compress nodes
  return
    (if last compressed == Whitespace then init compressed else
       compressed)

Why not:
  Combine with lib/Docvim/Parse.hs:203:7
```

This one is tricky to factor out because of the dependence on bindings visible
within the scope of the defined functions, and also the monadic execution
context. I think the linter *is* probably right that there is a code smell here,
though; I just have to figure out how to remove it.

Add @option headings to Markdown printer

Add a target for |:Command| links in Markdown

Remove unnecessary explicit anchors in headings

GitHub is going to add them anyway. Note that our |:Ack| links
don't work, because we aren't rendering that link target (we should).

Do some linkification in the Markdown printer

This is provisional as I think putting the explicit link targets in the heading
for GitHub is wrong.

Teach Markdown printer about @mapping and @command

Add @mapping support to Vim printer

Get @command annotation working

Make wrapping aware of concealed characters

This is the cheap-but-approximate approach. Results are reasonable, costs are
very low, and the consequences of being (slightly) wrong are livable. Let's go
with this for now.

Kill a stray comment

Use worktree as issue tracker

Taking standards to new lows.

Fix misplaced whitespace in output

Add test showing @option output

Something buggy in the parser: note that we have to explicitly say "none" for
the no-default case, but I intended that to be simply omittable.

Print options

Alignment will need a bit of work here, but this is a good first draft.

Specifically, if we want things to look like this in the UI:

                                g:SomeOpt
    g:SomeOpt        string (default: 10)

The output will actually need to be:

                                *g:SomeOpt*
    |g:SomeOpt|        string (default: 10)

Because `|` and `*` don't take up any width due to being concealed by Vim.

Fix lints

Use actual max int rather than hard-coded constant

Handle overlength headings

#uglycode

Fix duplicate content

Initial cut at @mapping, @command, @option, @function

Still some bugs to sort out (eg. duplicate symbol table entry due to extra
`MappingsAnnotation` when we perform extraction) and polish to apply (not
actually printing the options/functions etc).

Make Vim headings work by colocating link targets on same line

Add entries to symbol table for generated headings

Autogen headings in Vim printer too

Add auto-generated headings to Markdown printer

For @functions, @commands, @mappings, @options.

Add basic support for @options, @functions and @commands annotations

Still need to auto-emit headings for these, but I think they basically work.
Also need to make `Option`, `Function` and `Command` visitors.

Overhaul testing and compilation

We now "compile" in the test suite, meaning that we pipe our translation units
through the various extraction transforms after parsing. This means three main
things:

- Everything is nested inside a `Project` node type now, consisting of one or
  more translation units.
- Nodes within the project are ordered (or reordered) to maintain desired
  section ordering.
- As we add more phases to "compilation" (eg. automated insertion of table
  of contents etc), these will get reflected in the test suite automatically.

As part of this, extracted test-specific bits out into a new `Util` module (ie.
pretty-printing methods, convenience functions) and the "compile" pipeline into
a `Compile` module.

Add a missing type annotation

Don't rely on transformers

Don't want two monad transformer libraries at play here
needlessly.

Kill off an out-of-date comment

Fix copy pasta error

Suprised neither the compiler nor the tests seemed to
complain about this.

DRY up other visitors

More simplification

Trim down imports

More DRYing

Further visitor DRYing

Tidy indentation

Fix lints

Extract Visitor module

First step in factoring out some of the duplication here.

Remove some old comments

Fix indentation

Suppress unwanted trailing whitespace

Further refine hard-wrapping

Be better about hard-wrap placement

Still needs a refactor, but the output is better.

Rename `hardwrap` -> `textwidth`

Because I want to use the name `hardwrap` for a function as part of some
imminent refactoring.

Align

Always link unconditionally in Vim help output

May not even need the symbol table at all in this printer, but we'll keep it
around for now, just in case.

Replace a literal that I missed with a constant

Move hardwrapping from `plaintext` into `append`

Solves a bunch of issues, creates others, which I will have to fix in a
follow-up. The code itself is a complex, fragile, ugly, clusterfuck, so consider
this a work-in-progress.

Additionally, there are some unfortunate breaks which were there before and
continue to be there, like just inside parens, and things like that. Will need
to sort all that out too.

Tidy

Get rid of meaningless distinction in Markdown printer

All the cases must return Env, so let's put them all together
whether or not they explicitly access the state.

Share integration tests inputs across output types

May eventually share other things too (I still have some
manual symlinks going on), but this is a good start.

Make slurping a little more robust

But note remaining caveat inline. This really
should only be used to trim whitespace, at least
for now.

Remove unwanted blank lines before fenced code blocks

But note that this is a little bit fragile, even though
the tests pass. More work can be done to make this more
robust.

Fix some lints

Reorder things

Eliminate unwanted trailing whitespace