Provides a simple way to setup the CIDER nREPL middleware in
Leiningen projects.

Middleware descriptors and related utility functions.

While normally middleware descriptors live alongside middleware
definitions, cider-nrepl separates those. The rationale behind this
is to avoid loading each middleware definition until its first usage.
For this purpose we're defining each middleware as a wrapper that
defers the loading of the actual middleware.

(require '[profile.core :refer :all])
(defn my-add [a b] (+ a b))
(defn my-mult [a b] (* a b))

(profile-vars my-add my-mult)

(profile {}
 (my-add (my-mult (rand-int 100000) (rand-int 1000000))
         (my-mult (rand-int 100000) (rand-int 1000000))))

|          :name | :n | :sum | :q1 | :med | :q3 | :sd | :mad |
|----------------+----+------+-----+------+-----+-----+------|
|  #'user/my-add |  1 |  2µs | 2µs |  2µs | 2µs | 0µs |  0µs |
| #'user/my-mult |  2 | 11µs | 3µs |  8µs | 3µs | 3µs |  5µs |

A Clojure library for profiling.

## Example

```clojure
(require '[profile.core :refer :all])
(defn my-add [a b] (+ a b))
(defn my-mult [a b] (* a b))

(profile-vars my-add my-mult)

(profile {}
 (my-add (my-mult (rand-int 100000) (rand-int 1000000))
         (my-mult (rand-int 100000) (rand-int 1000000))))
```

`profile` prints output to `*err*` using `pprint/print-table`; it
looks like this:

```
|          :name | :n | :sum | :q1 | :med | :q3 | :sd | :mad |
|----------------+----+------+-----+------+-----+-----+------|
|  #'user/my-add |  1 |  2µs | 2µs |  2µs | 2µs | 0µs |  0µs |
| #'user/my-mult |  2 | 11µs | 3µs |  8µs | 3µs | 3µs |  5µs |
```

This namespace mostly exists, so that
it's easy to share the list of provided middleware.

Eventually the deferred middleware loading code will be probably moved here as well.

Search symbols and docs matching a regular expression

This middleware allows you to query for data ClojureDocs.
It's a very simple wrapper around `orchard.clojuredocs`.

Code completion middleware.
Delegates to the compliment library for the heavy lifting.
Uses clj-suitable for ClojureScript completion.

Rich content handling for CIDER.
Mostly derived from the pprint middleware.

---

In the long ago, @technomancy [1] talked about his vision for using
nREPL to support multimedia results beyond plain text, ala DrRacket
and other "rich" REPLs. There was an initial cut at this [2],
which never became part of the mainline Emacs tooling.

The goal of this module is to provide some support for recognizing
multimedia objects (images and URIs thereto) as the result of
evaluation, so that they can be rendered by a REPL.

The design of this module is based heavily on RFC-2045 [3] which
describes messages packaged with `Content-Type`,
`Content-Transfer-Encoding` and of course a body in that it seeks to
provide decorated responses which contain metadata which a client
can use to provide a rich interpretation.

There's also RFC-2017 [4] which defines the `message/external-body`
MIME type for defining messages which don't contain their own
bodies.

The basic architecture of this changeset is that eval results are
inspected, and matched against two fundamental supported cases. One
is that the value is actually a binary Java image, which can be MIME
encoded and transmitted back directly. The other is that the object
is some variant of a URI (such as a file naming an image or other
content) which cannot be directly serialized. In this second case we
send an RFC-2017 response which provides the URL from which a client
could request the nREPL server slurp the desired content.

Hence the slurp middleware which slurps URLs and produces MIME coded
data.

---

[1] https://groups.google.com/forum/#!topic/clojure-tools/rkmJ-5086RY
[2] https://github.com/technomancy/nrepl-discover/blob/master/src/nrepl/discover/samples.clj#L135
[3] https://tools.ietf.org/html/rfc2045
[4] https://tools.ietf.org/html/rfc2017

Expression-based debugger for clojure code

Instrument user code to "light up" when it runs.
The instrumented code will report the value of local variables and
report its return value.
Implemented as an extension of the debugger.

Code and EDN formatting functionality.

Macroexpansion middleware.

Change *out*, *err*, System/out and System/err to print on sessions
in addition to process out.

Automatically changes the root binding of all output channels to
print to any active sessions. An active session is one that has sent
at least one "eval" op.

We use an eval message, instead of the clone op, because there's no
guarantee that the channel that sent the clone message will properly
handle output replies.

This profiler is intended for interactive profiling applications where you do
not expect a profiling tool to automatically compensate for JVM
warm-up and garbage collection issues. If you are doing numeric
computing or writing other purely functional code that can be
executed repeatedly without unpleasant side effects, I recommend you
at the very least check out Criterium.

If you are primarily concerned about the influence of JVM-exogenous
factors on your code—HTTP requests, SQL queries, other network-
or (possibly) filesystem-accessing operations—then this package may
be just what the doctor ordered.

Based on older middleware (nrepl-profile) that's not actively
maintained anymore.

Rich reading & handling for CIDER.

Goes with middleware.content-types, providing the capability to
convert URLs to values which can be handled nicely.

Cause and stacktrace analysis for exceptions

Test execution, reporting, and inspection

Extensions to `clojure.test` functionality.

These are kept in a separate namespace because they are, by definition,
opinionated.

State tracker for client sessions.

Middleware for undefining symbols.
Fully qualified symbols are interpreted as a var to be unmapped in its
original namespace, whereas unqualified symbols are interpreted as both a var
and ns alias to be unmapped from the current namespace.

Utility functions that might be useful in middleware.

Coercion utilities for coercing bencoded maps.

Utilities to safely reply to op requests and help deal with the
errors/exceptions that might arise from doing so.

Generic instrumentation for clojure code

Utility functions for extracting and manipulating metadata.

Common utilities for interaction with the client.

Return version info of the CIDER-nREPL middleware itself.

Find function dependencies and function references.

Pretty-print related utilities.
All functions here are simple wrappers compatible with the expectations of
nrepl.middleware.print/wrap-print.

Extending `print-method` defined in clojure.core, to provide
prettier versions of some objects. This applies to anything that
calls `print-method`, which includes return values, `pr`, `print`
and the likes.