Falderal

* Removed the old, bitrotting Haskell implementation.
* Removed deprecated `%(test-text)` and `%(test-file)` variables
(`%(test-body-text)` and `%(test-body-file)` should be used now.)
* Added some adapters in the `script/` directory of the repo:
* `fa-under-pty` runs a target program under a pseudoterminal
* `fa-bin-to-hex` converts 8-bit binary output to hexadecimal codes
* `fa-hex-to-bin` converts hexadecimal codes to 8-bit binary output
* Added the rule that a test may consist of an input section (`+`) if
there was a previous test, and the test body of the previous test will
be re-used with the new input in the new test.

* `py-falderal` now insists that blocks are indented four spaces, as the
specification says. It ignores blocks that are not indented.
* In an error report `py-falderal` reports the location (filename and line
number of the beginning of the test text) of each test that failed, as
well as the name of the functionality that was being tested.
* Several internal renamings of class and variable names for greater clarity.
* Trying to standardize on the terminology "test body" for the body of a
test (as opposed to its "input", and opposed to it being passed to a shell
command line "as text".)
* Support for specifying a block of text to be used as input for a test.
* Dropped support for "implemented by Haskell function" backwards-compatibility.
* Temporary files are no longer always created in the current directory. That
was a workaround to support `ghc` from Haskell Platform under Cygwin. They
are now created where the system wants them to be created (but you can set
the `TMP` environment variable to "." if you really want them to be created
in the current directory.)
* `py-falderal` now complains and stops early if there were no documents
specified, no functionality definitions were found in any of the documents,
no implementations were found for some defined functionality, or if no
tests were found in any of the documents, unless `--cavalier` is passed on
the command line.
* In `--verbose` mode, `py-falderal` will issue warnings about any test that
has been run twice (i.e. more than run on identical test body text and
implementation.)
* If `py-falderal` catches a `KeyboardInterrupt` exception while running tests,
it shows a report of all the tests that it did manage to run until that
point, and a warning message to the effect that not all tests were run.

* The reference implementation is now `py-falderal`.
* Blocks *must* now be indented four spaces. That Falderal test documents
will be embedded in Markdown is generally assumed (although not strictly
required) and they generally have the file extension `.markdown` so that
other software (e.g. Bitbucket and Github) knows how to pretty-display
them.
* Various documentation which was on Bitbucket (wiki, issues) and Github
(py-falderal issues) have been moved into Markdown documents in the
distribution, which have themselves been re-organized.
* Added the `-v`/`--verbose` flag and made it and the `-d`/`--dump` flag
do what you would expect from them.
* The `-f`/`--functionalities` and `-c`/`--clear-functionalities` flags
have been *removed*. The rationale is that implementations of
functionalities are clumsy to express on the command line (and anyway
the syntax would have to be different) while it is not difficult to
create a "configuration" Falderal file which specifies *only* the
desired implementations of the desired functionalities, and to load
it just before loading a "tests" Falderal file which specified the
functionalities being tested, but not their implementations.

* **Note that this is the final version of Falderal where `Test.Falderal`
is the reference implementation.** In subsequent versions,
`py-falderal` (written in Python) will be the reference implementation.
`Test.Falderal` will still be in this repository (under the `impl`
directory) but will no longer be definitive, and will go essentially
unmaintained.
* Fixed a bug where number of lines in the intermediary results file
was sometimes being counted incorrect.
* Slightly improved support for running under Cygwin.
* Tests that are implemented by a shell command are now run directly
from the `falderal` process (instead of creating an intermediary
shell script and running it.) This resulted in better performance.
* Addition of `-b` command-line option, which considers a test to
have passed if the expected exception message is a substring (rather
than an exact match) of the actual produced exception message.
TODO: write test for this.
* Blocks may now be indented four spaces, to allow them to be
embedded directly in Markdown files as pre-formatted text.
* A script to just build the binary, without installing it, was added.

* Variables may be included in the specification of a shell command
implementation; these will be expanded before generating the results
generator. These variable include `%(test-text)`, `%(test-file)`,
and `%(output-file)`.
* `falderal` now lets the user specify, on the command line, the
implementations for a named functionality. Supplying `-f 'foo:shell
command "foo.sh %(test-file)"'` has the same effect as including the
pragma `Functionality "foo" is implemented by shell command "foo.sh
%(test-file)"` in the Falderal file. Note that this is in addition
to the Functionality-definition pragmas given in the Falderal file;
to replace them, you must first clear the ones with that name from
the file by supplying `-c foo` on the command line.
* `falderal` also allows tests for named functionalities to be skipped
completely, by passing the name of the functionality to be skipped
after a `-k` flag on the command line.
* The Markdown formatter now formats Bird-style embedded code with
HTML embedded in the Markdown document. This is so that it can
be styled independently from, and thus distinguished from, any plain
Markdown indented code blocks which may appear in the literate portion
of the source code.
* In failure reports, the implementation of the functionality of the test
that failed is now reported in each failure.
* A race condition(?) that could occur when testing multiple implementations
of a functionality, of different kinds (Haskell and shell), has been
prevented. Both tests were writing to `results.txt` and immediately
deleting it, and this would sometimes confuse `falderal` into thinking
one had produced no results (perhaps a result of some creative
scheduling by `ghc`, although really, I haven't a clue.) Results are
now written to different temporary files with different, generated
names.
* Previously, if the output of a shell command being tested did not end
with a newline, the intermediate results file was not being generated
correctly, resulting in failures being misreported. This has been
recitified.
* Previously, if there were tests given in a Falderal file before any
Tests-for pragma was specified, those tests would just be ignored.
An error message is now issued, and no testing takes place.
* Previously, if multiple Falderal files were given on the command
line, they were simply concatenated when loaded, the result being
that Functionality-definitions from the first file were visible in
the second file, and that any Tests-for in effect at the end of the
first file would be in effect at the start of the second file.
Files are now loaded and processed seperately.

* The command-line format of `falderal` has changed, for the better.
The `test` subcommand no longer requires that the failure reporting
style be specified; instead, it defaults to `standard`, and can be
changed with a command-line option. There are also command-line
options for selecting the programs to run results generators, and to
keep generated files around instead of cleaning them up after testing.
* The dependency on `ghc` for running Haskell results generators has been
removed; these can be run by `runhaskell` now, and are run by
`runhaskell` by default.
* Failure reporting is now consistent across languages; both Haskell and
Bourne shell results generators generate an intermediate format, which
`falderal` digests.
* A new pragma `encoding:` was added, so that this directive can be
embedded in your Falderal document (for the benefit of your text editor)
without necessarily appearing in the formatted document.
* We began giving release milestones colorful names. The naming
convention is to choose names of Chicagoland neigborhoods, suburbs,
landmarks, and institutions. Version 0.5 was named after The Loop in
recognition of its ability to shuttle test results between `falderal`
and the various results generators implemented in different languages.
Previous versions of `Test.Falderal` were retroactively given milestone
names during this release.