Checkers are for checking results of checkables, or checking
that appropriate arguments are passed to prerequisites

Core Midje functions that process expects and report on their results.

Checkers that explain more about a failure.

Checkers for collections and strings.

Code to use to compare collections.

Checkers for collections and strings.

Checkers that combine other checkers.

Various ways to define checkers.

Prepackaged functions that perform common checks.

Core ideas underlying all checking

Facts as something you check

Customizable configuration

A compendium is 'a collection of concise but detailed information
about a particular subject'. The Midje compendium contains
the currently relevant facts.

Facts as a data structure

A notation that avoids confusion between what’s essential
about data and what’s accidental. A stand in for constant data.

During checking of a fact, this contains pointers to the facts that contain it,
in outer-to-inner order. The fact itself is the `last` of the sequence.

Maintain the use of namespace-specific prerequisites

What we know about the changing project file/namespace tree.

In-repl user documentation

Emissions change global state: the output and the pass/fail record.

Execution boundaries that have to do with checking of faces

Midje makes use of clojure.test for its reporting. This
facade shows how.

Functions dealing with making various forms of
Midje output be ergonomically colorful.

Utilities to deprecate features.

print levels

The default for Midje output

How the default emitter reports on failures

JUnit formatter for Midje output

JUnit formatter for Midje that keeps original stdout output.

Progress formatter for Midje output

A template for emission maps that emit nothing.

TAP output. See http://testanything.org

An emission map whose functions can be mocked.

General purpose plugin utilities

The non-configuration state of the program. That is: the workings
that are normally invisible to any user, with the exception of tests
and people debugging.

Utility functions dealing with checking or tranforming forms.

Macros for using protocols in prerequisites.

The strategy for open protocols is to rewrite each function defined in the
deftype/defrecord so that it checks whether its corresponding symbol is
currently faked out. If so, it uses that function definition instead of
continuing on with its own implementation.

Midje's special blend of generative-style testing.

Check multiple facts given clojure.check generated values, failing values are shrunk before being shown.

A way to create multiple facts with the same template, but different data points.

Functions for working with explicit expect forms.

Parsing facts.

Parsing future-facts.

Transforming code in a way that produces metaconstants

Parsing metadata as found in facts, around-facts, and tables

Handles the parsing of background forms. For the moment, this includes both
state changes and fact-wide prerequisites.

Functions for turning provideds into explicit fakes

=contains=> prereqisites

generate a map for a particular checkable

An intermediate stage in the compilation of prerequisites.

Unfolding prerequisites like `(f (g 1)) => 3`

Generating functions that work on fake maps.

Lexicon of all Midje arrows. Arrows are used in both the sweet and expanded forms.

Lexicon of all symbols at the head of expanded forms.

checkable maps, redefine maps, failure maps

Parsing function argument lists

Utility functions dealing with checking or tranforming forms or zippers.

Utility functions dealing with checking or tranforming forms or zippers.

A fnref is the first symbol-or-var in a list. These utilities
allow you to interpret it in multiple ways.

A stupid whimsy that I must drag along with me forever

The idea of key-value overrides is common to various forms

Recognizing Midje forms

midje.background uses these to wrap extra code around
:contents, :facts, or :expects

Zipper util functions.

Functions useful when using Midje in the repl or from the command line.
See `midje-repl-help` for details.

Checkers that use structural-typing

A TDD library for Clojure that supports top-down ('mockish') TDD,
encourages readable tests, provides a smooth migration path from
clojure.test, balances abstraction and concreteness, and strives for
graciousness.

Utility code for testing private vars.

Functions for printing indented output for use in debugging.

Environmental factors.

Functions for Midje to deal elegantly with exceptions.

To evaluate a fact it needs to be eagerly evaluated.

This code was copied from an earlier version of the ordered library,
`https://github.com/flatland/ordered`, because of a version conflict.
That library is covered by the Eclipse Public License, V1.0, which
you can find in Midje's root directory.

This code was copied from an earlier version of the ordered library,
`https://github.com/flatland/ordered`, because of a version conflict.
That library is covered by the Eclipse Public License, V1.0, which
you can find in Midje's root directory.

This code was copied from an earlier version of the ordered library,
`https://github.com/flatland/ordered`, because of a version conflict.
That library is covered by the Eclipse Public License, V1.0, which
you can find in Midje's root directory.

This code was copied from an earlier version of the ordered library,
`https://github.com/flatland/ordered`, because of a version conflict.
That library is covered by the Eclipse Public License, V1.0, which
you can find in Midje's root directory.

Functions that are somewhat general purpose.

Running tasks after a delay.

Code used to swap out vars for faking prerequisites.

Unification is used in tabular and (against-)background code.