Add :cabal Ex command to Vim2

The :cabal command runs `cabal build`, which allows me to run `:cabal` and
then `:reload` from with yi in order to incorporate the latest changes I've
made. Or if `cabal build` fails to press enter on the error message line and
be taken to the source of the error.
:cabal supports passing arguments to cabalBuildE
Remove vim incompatibilities for :buffer command
:bdelete command works again

The Buffer command's :b abbreviation was parsing the :bdelete command and then
not doing anything due to having been given no argument.
Better fix for :b :bdelete contention

Rather than rely on `BufferDelete.parse` appearing before `Buffer.parse`,
let's fix `Buffer.parse` to not parse `bdelete`.

The change is to allow `b` to be immediately followed by digits (representing
a buffer reference), but other characters require a space before them.  Also,
make sure to allow no characters at all to follow the command name, which is
done by parsing `P.eof` and returning the empty string representing the
current buffer.
Improve ex command parsing failure message

If an unknown ex command is entered, include the command in the complaint.
This is not only compatible with Vim, it is very helpful for discovering
errors when writing ex command parsers.
Fix some compiler warnings
Merge pull request #492 from benarmston/vim2-cabal-ex-commands

Add :cabal Ex command to Vim2
Merge pull request #496 from benarmston/vim2-buffer-ex-command-improvements

Vim2 buffer ex command improvements
Tests for Vim2 ex command parsers

These tests check two things:

 1. The parser successfully parses the commands it is expected to.
 2. For each sample string, the expected `ExCommand` is selected from the
    `defExCommandParsers`.

They don't check that any `ExCommand` has the affect that it should. Some of
the tests in `TestVim.getTestGroup` do that.

Generating the sample strings for each ex command parser is currently a manual
exercise. Which is why there are currently tests for only a few commands. It
should be possible to generate the command strings using SmallCheck or
QuickCheck.
QuickCheck generates the command strings to parse

Instead of manually generating a hopefully exhaustive set of command strings
to test, use QuickCheck to generate them.

Each ex command parser to test is now contained in a `CommandParser` record.
Along with the parser, the record contains all of the synonyms for the
command, whether the command accepts a `!`, and a `Gen`erator or command line
arguments it is expected to parse.

A number of combinators have been written to ease the generation of arguments.

Currently, only three parsers are tested. However, it should be simple to add
new ones.
Switch form TestFramework to Tasty

In his branch on changing `Rope` to use `Text` instead of `ByteString`,
ethercrow has switched from TestFramework to Tasty. I shall follow his lead
and adjust these too.

I've also reverted `getTestGroup` back to `getTests`.
Tests for pure-editor-manipulating Vim2 actions

The TestVim module provides a nice mechanism for writing tests which are 1)
pure and 2) affect only a single buffer. It doesn't provide a mechanism for
tests which affect more than a single buffer.

Pure manipulations of the editor refers to such things as changing layout,
navigating buffers, creating or deleting buffers, creating or deleting tabs.
In short, anything which 1) doesn't perform IO and 2) interacts with something
other than a single buffer.

This module provides the start of a basis for writing such tests.
Refactor of Vim2 keymap tests

 - A `Vim2` module houses all of the Vim2 keymap specific tests.

 - Split what was `TestVim2PureEditorManipulations` into a number of modules.
   `Vim2.TestUtils` contains utility functions for testing the Vim2 keymaps.
   `Vim2.EditorManipulations.BufferExCommand` contains tests of the `:buffer`
   ex command under the Vim2 keymap. `Vim2.TestPureEditorManipulations` pulls
   the `Vim2.EditorManipulations.BufferExCommand` tests into a test group.

 - Renamed `TestVim` to `Vim2.TestPureBufferManipulations` to reflect that 1)
   it tests the Vim2 keymaps (not the Vim keymaps); 2) it isn't the only set
   of tests for the Vim2 keymaps; and 3) what it tests are pure manipulations
   of a single buffer.
Refactor mkTestCase to use runTest

Refactor `mkTestCase` in `TestPureBufferManipulations` to use `runTest` and
functions from `Vim2.TestUtils`.
Fix parser tests

Include `%` and `#` in the buffer identifier generator, and fix the `:buffer`
command parser to parse them. Specify the correct arguments which `:bdelete`
should parse.
Add and correct module documentation
Remove accidentally committed file
Add some links to further reading
Merge remote-tracking branch 'refs/remotes/upstream/master'