Facade grouping the core apis in one place.
      

Api providing utilities when manipulating classpaths generated using `clojure.tools.deps`.
      

File cleaning api.
      

Api providing clojure compilation utilities.
      

Minimal api wrapping some of the `java.tools` apis providing java compilation utilities.
      

Api providing some utilities working with `clojure.tools.deps`.
      

Api providing git utilities. Mostly a wrapper for some functionality from `clj-jgit`.
      

Api providing gpg utilities.
      

Api grouping the different utilities around building jars provided in
`fr.jeremyschoffen.mbt.alpha.core.jar.XXX` namespaces.
      

Api providing the tools to make a jar archive from a directory.
      

Api providing some jar file system utilies.
      

Api providing utilities when generating manifest files.
      

Protocols used in to create a flexible way to approach the creation of jar sources.

See [[fr.jeremyschoffen.mbt.alpha.core.jar.sources]] to have an example of how to use these
protocols.
      

Default implementations of the protocols found in [[fr.jeremyschoffen.mbt.alpha.core.jar.protocols]].

Types implementing [[fr.jeremyschoffen.mbt.alpha.core.jar.protocols/JarSource]]:
- `clojure.lang.Sequential`: sequences of `:jar/entry` producing itself as a
  [[fr.jeremyschoffen.mbt.alpha.core.building.jar.protocols/JarEntries]].
- `java.nio.file.Path`: path to a directory or a jar. A path to a directory will produce a
  [[fr.jeremyschoffen.mbt.alpha.core.jar.sources/SourceDir]] record. A path to a jar will
  produce a [[fr.jeremyschoffen.mbt.alpha.core.jar.sources/SourceDir]] record. Both record types
  implement [[fr.jeremyschoffen.mbt.alpha.core.jar.protocols/JarEntries]].
      

Api providing facilities to copy files from different sources into a unique directory.
This directory is intended to be zipped into a jar file.

The function [[fr.jeremyschoffen.mbt.alpha.core.jar.temp/add-srcs!]] is the entry point when
copying sources to the temp directory.
      

Utilites common to different maven related tasks.
      

Api providing  maven deployment utilites.
      

Api providing a maven install utilities.
      

Api providing maven pom.xml files generation.
      

Api wrapping `clojure.java.shell`
      

Specs used in `mbt's` core apis.
      

Building blocks of a versioning system based on git commit distance.
      

Building blocks to versioning systems following the maven or semver model.
      

Facade grouping the default apis in one place.
      

Higher level api to compile java files.
      

(def conf {:project/name 'my-project
           :maven/group-id 'com.my-group
           :maven/classifier 'sources
           :versioning/major :alpha

           :maven/artefact-name (calc compute-artefact-name :project/name :versioning/major)
           :computed-coordinate (calc compute-coord-name :maven/artefact-name
                                                         :maven/group-id
                                                         :maven/classifier)})

(compute-artefact-name {:project/name 'my-project
                        :versioning/major :alpha})
;=> 'my-project-alpha


(compute-artefact-name {:maven/artefact-name 'my-project-alpha
                        :maven/group-id 'com.my-group
                        :maven/classifier 'sources})
;=> 'com.my-group/my-project-alpha$sources

(compute-conf conf)
;=> {:project/name 'my-project
     :maven/group-id 'com.my-group
     :maven/classifier 'sources
     :versioning/major :alpha

     :maven/artefact-name 'my-project-alpha
     :computed-coordinate 'com.my-group/my-project-alpha$sources}

In mbt's default api, several config value are computed by default. This API provides the mechanisms used to construct
a project's config map.

Lets take an example to illustrate the way this API is tu be used.

The name of an artefact in tools deps is a symbol whose namespace represents its group id and whose name represents
its general name. The name is itself subject to be divided into artefact name and classifier. Mbt also has a concept of
major version that will add a suffix to artefact names.

Let's say we are building an artefact named `com.my-group/my-project-alpha$sources.`
A simplified config could then look like this:
```clojure
(def conf {:project/name 'my-project
           :maven/group-id 'com.my-group
           :maven/classifier 'sources
           :versioning/major :alpha

           :maven/artefact-name (calc compute-artefact-name :project/name :versioning/major)
           :computed-coordinate (calc compute-coord-name :maven/artefact-name
                                                         :maven/group-id
                                                         :maven/classifier)})
```
Here, the first 4 values in the map are given. The last 2 are to be computed, the second one depending on the result of
the first. These computations are 'declared' with the `(calc computation & dependencies)` scheme.
Assuming we have the functions such as:
```clojure
(compute-artefact-name {:project/name 'my-project
                        :versioning/major :alpha})
;=> 'my-project-alpha


(compute-artefact-name {:maven/artefact-name 'my-project-alpha
                        :maven/group-id 'com.my-group
                        :maven/classifier 'sources})
;=> 'com.my-group/my-project-alpha$sources
```
The compute utility perform several operations with this config. It will:

1) find the keys that need to be computed (`:maven/artefact-name` & `:computed-coordinate`)
2) establish a dependency graph between these computation
3) run the computations in order to satisfy dependencies (topological sort of the dependency graph)
4) return a map based on the original where the value that were computations are now the result of these computations.

```clojure
(compute-conf conf)
;=> {:project/name 'my-project
     :maven/group-id 'com.my-group
     :maven/classifier 'sources
     :versioning/major :alpha

     :maven/artefact-name 'my-project-alpha
     :computed-coordinate 'com.my-group/my-project-alpha$sources}
```

`:maven/artefact-name` and  `:computed-coordinate` have been computed based on other values in the config map.
      

Default config pertaining to building utilities.
      

Default config pertaining to the cleaning utility..
      

Default config pertaining compilation utilities.
      

Default config pertaining to git utilities.
      

Default config pertaining to gpg utilities.
      

The implementation details of the config API.
      

Default config pertaining to maven utilities.
      

Default config pertaining to general project value.
      

Default config pertaining to versioning utilities.
      

Utilities used to generate deps coordintes for the project.
      

Apis providing the jar sources used by default and the utilities to build jars and uberjars.
      

Api providing default behaviour for maven tasks.
      

Common maven utilities used in the default apis.
      

Specs used in the default api.
      

Higher level apis.
      

Grouping of the different versioning utilities.
      

Api containing the default logic for using git state as a versioning mechanism.
      

Api used when versioning the project using git state.
      

Implementation of versioning schemes using the git disatnce building blocks from the core api
([[fr.jeremyschoffen.mbt.alpha.core.versioning.simple-version]]).
      

Implementation of versioning schemes using the maven and semver building blocks from the core api
([[fr.jeremyschoffen.mbt.alpha.core.versioning.maven-like]]).
      

Protocol used to make version schemes.
      

Api used to generate version files.
      

This namespace distills mbt's API to build mbt itself.

Utilities used in the whole project.