This library provides the core functionality of Leiningen. This
consists of the task execution implementation, project configuration,
and helper functions. The built-in tasks and the launcher scripts are
kept in the main
More detailed API reference is available.
- leiningen.core.main contains the
-mainentry point along with task handling functions like
- leiningen.core.project has
defprojectfor getting a project map from
project.cljfiles. It also handles applying profiles to the project map and loading plugins.
- leiningen.core.classpath is where the project's classpath is calculated. It handles Maven dependencies as well as checkout dependencies.
- leiningen.core.eval houses the
eval-in-projectfunction which implements the isolation of project code from Leiningen's own code.
- leiningen.core.user just has a handful of functions which handle user-level configuration.
When Leiningen is invoked, it first reads the
project.clj file and
applies any active profiles to the resulting project map. (See
Leiningen's own readme for a description of how profiles work.) Then
it looks up the task which was invoked. Tasks are just functions named
after the task they implement and defined in the
namespace. They usually take a project map as their argument, but can
also run outside the context of a project. See the
for more details on how tasks are written. The
looks up the task function, checks to make sure it can be applied to
the provided arguments, and then calls it.
When you launch Leiningen, it must start an instance of Clojure to load itself. But this instance must not affect the project that you're building. It may use a different version of Clojure or other dependencies from Leiningen itself, and Leiningen's code should not be visible to the project's functions.
Leiningen currently implements this by launching a sub-process using
leiningen.core.eval/eval-in-project. Any code that must execute
within the context of the project (AOT compilation, test runs, repls)
needs to go through this function. Before the process is launched, the
project must be "prepped", which consists of running all the tasks
named in the project's
:prep-tasks key. This defaults to
defproject or profiles may add additional tasks as
necessary. All prep tasks must be cheap to call if nothing has changed
since their last invocation.
The sub-process (referred to as the "project JVM") is an entirely new
invocation of the
java command with its own classpath calculated
from functions in the
leiningen.core.classpath namespace. It can
even use a different version of the JVM from Leiningen if the
:java-cmd key is provided. It can only communicate with Leiningen's
process via the file system, sockets, and its exit code.
The exception to this rule is when
project.clj is true, as is commonly used for Leiningen plugins.
Since Leiningen plugins are intended to be used inside Leiningen
itself, there's no need to enforce this isolation.
Copyright © 2011-2016 Phil Hagelberg and contributors.
Distributed under the Eclipse Public License, the same as Clojure.