root-deps

Usage: (root-deps)

DEPRECATED: Use clojure.tools.deps.edn/root-deps

slurp-deps

Usage: (slurp-deps dep-file)

DEPRECATED: use clojure.tools.deps.edn/read-deps

user-deps-path

Usage: (user-deps-path)

DEPRECATED: Use clojure.tools.deps.edn/user-deps-path

canonicalize

Usage: (canonicalize deps-edn & opts)

Canonicalize a deps.edn map (convert simple lib symbols to qualified lib symbols).
Returns the deps-edn map.

Opts:
  :path String path to file being read

combine-aliases

Usage: (combine-aliases edn-map alias-kws)

Find, read, and combine alias maps identified by alias keywords from
a deps edn map into a single args map.

create-edn-maps

Usage: (create-edn-maps)
       (create-edn-maps {:keys [root user project extra], :as params, :or {root :standard, user :standard, project :standard}})

Takes optional map of location sources, keys = :root :user :project :extra
where each key may be:
  :standard (default) - to get the default source
  string - for file path to source, relative to current dir context
  nil - to omit
  map - a literal map to use

Returns a set of deps edn maps with the same keys :root :user :project :extra.
Keys may be missing if source was nil or file was missing.

merge-alias-maps

Usage: (merge-alias-maps & ms)

Like merge-with, but using custom per-alias-key merge function

merge-edns

Usage: (merge-edns deps-edn-maps)

Merge multiple deps edn maps from left to right into a single deps edn map.

project-deps

Usage: (project-deps)

Calculate the project deps.edn location, read and return the deps.edn data.

You may use clojure.tools.deps.util.dir/with-dir to read from a custom project
dir, either absolute or relative to the current dir context.

project-deps-path

Usage: (project-deps-path)

Calculate the project deps.edn location. This
is the deps.edn in the current directory, as defined by
clojure.tools.deps.util.dir/*the-dir* - use with-dir
to push a new local directory context around a call to
project-deps-path.

read-deps

Usage: (read-deps f & opts)

Corece f to a file with jio/file, then read, validate, and canonicalize
the deps.edn. This is the primary entry point for reading.
Use read-edn, validate, or canonicalize for individual steps.

Opts: none for now

read-edn

Usage: (read-edn r & opts)

Read edn from Reader r, which should contain exactly one edn value.
If source exists but is blank, nil is returned.
Throws if source is unreadable or contains multiple values.

Opts:
  :path String path to file being read, for error reporting

root-deps

Usage: (root-deps)

Read the root deps.edn resource from the classpath at the path
clojure/tools/deps/deps.edn

user-deps

Usage: (user-deps)

Calculate the user deps.edn per user-deps-path, read and
return the deps.edn data

user-deps-path

Usage: (user-deps-path)

Use the same logic as clj to calculate the location of the user deps.edn.
Note that it's possible no file may exist at this location.

validate

Usage: (validate deps-edn & opts)

Validate a deps-edn map according to the specs, throw if invalid.
Returns the deps-edn map.

Opts:
  :path String path to file being read

explain-deps

Usage: (explain-deps deps-map)

If a spec is invalid, return a message explaining why, suitable
for an error message

valid-deps?

Usage: (valid-deps? deps-map)

Determine whether the deps map is valid according to the specs

::alias

keyword?

::aliases

(map-of ::alias any?)

::classpath

string?

::classpath-args

(keys :opt-un [::classpath-overrides ::extra-paths])

::classpath-overrides

(map-of ::lib ::path)

::coord

(nilable (or :mvn :mvn/coord :local :local/coord :git :git/coord))

::default-deps

(map-of ::lib ::coord)

::dependents

(coll-of ::lib)

::deps

(map-of ::lib ::coord)

::deps-map

(nilable
  (keys
   :opt-un [::paths ::deps ::aliases]
   :opt [:mvn/repos :mvn/local-repo :tools/usage :deps/prep-lib]))

::exec-args

(nilable map?)

::extra-deps

(map-of ::lib ::coord)

::extra-paths

(coll-of ::path-ref :into [] :kind vector?)

::lib

symbol?

::lib-map

(map-of ::lib ::resolved-coord)

::ns-aliases

(map-of simple-symbol? simple-symbol?)

::ns-default

simple-symbol?

::override-deps

(map-of ::lib ::coord)

::path

string?

::path-ref

(or :path ::path :alias ::alias)

::paths

(coll-of ::path-ref :into [] :kind vector?)

::replace-deps

(map-of ::lib ::coord)

::replace-paths

(coll-of ::path-ref :into [] :kind vector?)

::repo

(nilable (keys :opt-un [::url :mvn/releases :mvn/snapshots]))

::repo-id

string?

::resolve-args

(keys :opt-un [::extra-deps ::override-deps ::default-deps])

::resolved-coord

(merge ::coord (keys :opt-un [:aliased/paths ::dependents]))

::threads

pos-int?

::tool-args

(keys :opt-un [::replace-deps ::replace-paths ::deps ::paths])

::trace

boolean?

::url

string?

install-tool

Usage: (install-tool lib coord as)

Procure the lib+coord, install the tool to the user tools dir (with lib, coord)

list-tools

Usage: (list-tools)

Return seq of available tool names

remove-tool

Usage: (remove-tool tool)

Removes tool installation, if it exists. Returns true if it exists and was deleted.

resolve-tool

Usage: (resolve-tool tool)

Resolve a tool by name, look up and return:
{:lib lib
 :coord coord}
Or nil if unknown.

usage

Usage: (usage tool)

Resolve a tool and return it's usage data, which may be nil.
Throws ex-info if tool is unknown.

trace->tree

Usage: (trace->tree trace)

Convert a deps trace data structure into a deps tree.

A deps tree has the structure of the full dependency expansion.
Each node of the tree is a map from lib to coord-info with at least these keys:
  :lib - library symbol
  :coord - the coord map that was used (may not be the original coord if replaced
           due to default-deps or override-deps)
  :include - boolean of whether this node is included in the returned deps
  :reason - why the node was or was not included
  :children - vector of child nodes

*the-dir*

Thread-local directory context for resolving relative directories.
Defaults to current directory. Should always hold an absolute directory
java.io.File, never null.

canonicalize

Usage: (canonicalize f)

Make canonical File in terms of the current directory context.
f may be either absolute or relative.

sub-path?

Usage: (sub-path? path)

True if the path is a sub-path of the current directory context.
path may be either absolute or relative. Will return true if path
has a parent that is the current directory context, false otherwise.
Handles relative paths, .., ., etc. The sub-path does not need to
exist on disk (but the current directory context must).

with-dir

Usage: (with-dir dir & body)

Push directory into current directory context for execution of body.