Format project using pruner

Author: julienvincent

packages/kmono-build/src/k16/kmono/build.clj

@@ -16,14 +16,14 @@
 (defn published?
   "A `predicate-fn` designed to be used with [[k16.kmono.core.graph/filter-by]].
 
-  Checks whether a given `package` has been published to it's maven repository.
-  The repositories from the packages `:mvn/deps` map will be used to run this
-  check.
+   Checks whether a given `package` has been published to it's maven repository.
+   The repositories from the packages `:mvn/deps` map will be used to run this
+   check.
 
-  Requires that the package has a `:version` set in order to perform a maven
-  query.
+   Requires that the package has a `:version` set in order to perform a maven
+   query.
 
-  This fn will just return `false` if the package `:version` is not set."
+   This fn will just return `false` if the package `:version` is not set."
   [package]
   (let [local-repo-override (str (fs/create-temp-dir))]
     (try
@@ -49,24 +49,24 @@
 (defn join
   "Attempt to join together a given a series of paths.
 
-  For example - given `(join \"/a/b/c\" \"../d\")` return `\"/a/b/d\"`"
+   For example - given `(join \"/a/b/c\" \"../d\")` return `\"/a/b/d\"`"
   [& paths]
   (->> (apply fs/file paths)
        fs/normalize
        str))
 
 (defn create-basis
   "Constructs a basis using [[clojure.tools.build.api/create-basis]] with a
-  modified set of `:libs`.
+   modified set of `:libs`.
 
-  Any `:local/root` kmono dependencies within the basis are replaced with their
-  respective `:mvn/version` coordinate derived from the given `packages` map.
+   Any `:local/root` kmono dependencies within the basis are replaced with their
+   respective `:mvn/version` coordinate derived from the given `packages` map.
 
-  These `:libs` are then used to generate a correctly referenced `pom.xml` when
-  using [[clojure.tools.build.api/write-pom]].
+   These `:libs` are then used to generate a correctly referenced `pom.xml` when
+   using [[clojure.tools.build.api/write-pom]].
 
-  Additional `opts` can be optionally provided and these will be given directly
-  to `create-basis`."
+   Additional `opts` can be optionally provided and these will be given directly
+   to `create-basis`."
   ([packages package] (create-basis packages package {}))
   ([packages package opts]
    (let [dependencies
@@ -96,26 +96,26 @@
 (defn for-each-package
   "Execute a given `build-fn` for each package in the given `packages` map.
 
-  Accepts an optional `opts` map containing:
+   Accepts an optional `opts` map containing:
 
-  - **`:concurrency`** :int (default 4) - The maximum number of packages that
-    can be executing at a time.
-  - **`:run-in-order`** :boolean (default `true`) - Set this to false to run
-    all packages concurrently ignoring their dependency order.
-  - **`silent`** :boolean (default `false`) - Set this to true to disable
-    logging the package name and version.
+   - **`:concurrency`** :int (default 4) - The maximum number of packages that
+     can be executing at a time.
+   - **`:run-in-order`** :boolean (default `true`) - Set this to false to run
+     all packages concurrently ignoring their dependency order.
+   - **`silent`** :boolean (default `false`) - Set this to true to disable
+     logging the package name and version.
 
-  The `build-fn` will be called with the `*project-root*` var (from
-  `clojure.tools.build.api`) bound to the subdirectory of the relevant package.
-  This allows using the various API's from `tools.build` under the assumption
-  that all specified paths will be relative to the package subdirectory.
+   The `build-fn` will be called with the `*project-root*` var (from
+   `clojure.tools.build.api`) bound to the subdirectory of the relevant package.
+   This allows using the various API's from `tools.build` under the assumption
+   that all specified paths will be relative to the package subdirectory.
 
-  TIP: Use the [[clojure.tools.build.api/resolve-path]] API to resolve a path
-  relative to the current package dir.
+   TIP: Use the [[clojure.tools.build.api/resolve-path]] API to resolve a path
+   relative to the current package dir.
 
-  The `build-fn` will be called concurrently (up to max of `:concurrency` or
-  `4`) but packages with dependencies will only be executed after each of their
-  respective dependencies have run unless `:run-in-order` is `false`."
+   The `build-fn` will be called concurrently (up to max of `:concurrency` or
+   `4`) but packages with dependencies will only be executed after each of their
+   respective dependencies have run unless `:run-in-order` is `false`."
   {:style/indent :defn
    :malli/schema
    [:function

packages/kmono-core/src/k16/kmono/core/config.clj

@@ -31,9 +31,9 @@
 (defn resolve-workspace-config
   "Read in and validate kmono workspace config at a given `root` dir.
 
-  This will attempt to load the key `:kmono/workspace` from both a `deps.edn`
-  file and a `deps.local.edn` file at the given `root`. These will be merged
-  together with the `deps.local.edn` taking precedence."
+   This will attempt to load the key `:kmono/workspace` from both a `deps.edn`
+   file and a `deps.local.edn` file at the given `root`. These will be merged
+   together with the `deps.local.edn` taking precedence."
   [root]
   (let [root-workspace-config (read-kmono-config (fs/file root "deps.edn") :kmono/workspace)
         local-workspace-config (read-kmono-config (fs/file root "deps.local.edn") :kmono/workspace)
@@ -49,7 +49,7 @@
 
 (defn resolve-package-config
   "Read in and validate kmono package config from a package at the given
-  `package-path`."
+   `package-path`."
   [package-path]
   (let [deps-file-path (fs/file package-path "deps.edn")
 

packages/kmono-core/src/k16/kmono/core/deps.clj

@@ -79,15 +79,15 @@
 
 (defn filter-package-aliases
   "Filter the given `packages` map by those that contain aliases described by at
-  least one of the given given `globs`.
+   least one of the given given `globs`.
 
-  Returns a map with pkg-name as the key and the set of aliases from that
-  package that matched the globs.
+   Returns a map with pkg-name as the key and the set of aliases from that
+   package that matched the globs.
 
-  ```clojure
-  (filter-package-aliases {:package-a {}} [:*/test])
-  ;; => {:package-a #{:test}}
-  ```"
+   ```clojure
+   (filter-package-aliases {:package-a {}} [:*/test])
+   ;; => {:package-a #{:test}}
+   ```"
   [globs packages]
   (reduce
    (fn [packages [pkg-name pkg]]
@@ -113,17 +113,17 @@
 
 (defn generate-sdeps-aliases
   "Generate an `-Sdeps` compatible map containing aliases generated from various
-  workspace sources.
+   workspace sources.
 
-  This is the primary way of augmenting clojure with new classpath information.
+   This is the primary way of augmenting clojure with new classpath information.
 
-  Aliases are generated from:
+   Aliases are generated from:
 
-  1. The set of packages in the workspace. These are added into an alias called
-     `:kmono/packages` containing `:extra-deps`.
-  2. All the aliases from all packages in the workspace are raised up and
-     combined, scoping their alias names to the package name.
-  3. The aliases from `deps.local.edn` in the project root."
+   1. The set of packages in the workspace. These are added into an alias called
+      `:kmono/packages` containing `:extra-deps`.
+   2. All the aliases from all packages in the workspace are raised up and
+      combined, scoping their alias names to the package name.
+   3. The aliases from `deps.local.edn` in the project root."
   [project-root packages]
   (let [local-deps
         (fs/file project-root "deps.local.edn")

packages/kmono-core/src/k16/kmono/core/fs.clj

@@ -56,8 +56,8 @@
        (find-project-root parent current-root)))))
 
 (defn find-project-root!
-  "This is the same as [[k16.kmono.core.fs/find-project-root]] but will throw
-   an exception if no project root can be found."
+  "This is the same as [[k16.kmono.core.fs/find-project-root]] but will throw an
+   exception if no project root can be found."
   ([] (find-project-root! nil))
   ([dir]
    (let [root (find-project-root dir)]

packages/kmono-core/src/k16/kmono/core/graph.clj

@@ -46,8 +46,8 @@
 (defn find-cycle
   "Find a dependency cycle in `packages` and returns it as a closed path.
 
-  Returns a vector like `[a b c a]` for a cycle `a -> b -> c -> a`, or nil if
-  no cycle is found."
+   Returns a vector like `[a b c a]` for a cycle `a -> b -> c -> a`, or nil if
+   no cycle is found."
   [packages]
   (loop [nodes (sort (keys packages))
          visited #{}
@@ -73,19 +73,19 @@
 
 (defn parallel-topo-sort
   "Sort a given `packages` map by the order in which the packages therein depend
-  on each other.
+   on each other.
 
-  As an example, if I have 3 packages `a`, `b`, `c` and `b` depends on `a`
-  then:
+   As an example, if I have 3 packages `a`, `b`, `c` and `b` depends on `a`
+   then:
 
-  ```clojure
-  (parallel-topo-sort {a {} b {} c {}})
-  ;; => [[a c] [b]]
-  ```
+   ```clojure
+   (parallel-topo-sort {a {} b {} c {}})
+   ;; => [[a c] [b]]
+   ```
 
-  This is generally used to calculate the execution order of packages when
-  trying to run commands in subpackages or build/release packages in the
-  correct order."
+   This is generally used to calculate the execution order of packages when
+   trying to run commands in subpackages or build/release packages in the
+   correct order."
   {:malli/schema [:=> [:cat core.schema/?PackageMap] [:maybe ?ExecOrder]]}
   [packages]
   (let [stage
@@ -113,7 +113,7 @@
 (defn query-dependents
   "Find all dependent packages of `pkg-name` within the give `packages` map.
 
-  This includes all transitive dependencies."
+   This includes all transitive dependencies."
   {:malli/schema [:=> [:cat core.schema/?PackageMap :symbol] [:set :symbol]]}
   [packages pkg-name]
 
@@ -156,15 +156,15 @@
 (defn filter-by
   "Filter a given `packages` map by those that match the given `predicate-fn`.
 
-  If the `:include-dependents` property is `true` then all dependent packages
-  of the retained packages will also be kept.
+   If the `:include-dependents` property is `true` then all dependent packages
+   of the retained packages will also be kept.
 
-  This function will update the `:depends-on` and `:dependent` keys of each
-  retained package to include only other packages that still remain in the map.
+   This function will update the `:depends-on` and `:dependent` keys of each
+   retained package to include only other packages that still remain in the map.
 
-  It's generally recommended to use this function instead of writing your own
-  package filtering. If you need to write your own then you should also make
-  sure to keep the `:depends-on` and `:dependents` updated."
+   It's generally recommended to use this function instead of writing your own
+   package filtering. If you need to write your own then you should also make
+   sure to keep the `:depends-on` and `:dependents` updated."
   ([predicate-fn packages] (filter-by predicate-fn {} packages))
   ([predicate-fn {:keys [include-dependents]} packages]
    (let [filtered

packages/kmono-core/src/k16/kmono/core/packages.clj

@@ -90,18 +90,18 @@
 (defn glob-matches?
   "Compare a namespaced keyword or symbol against a keyword `glob`.
 
-  The keyword `glob` should be provided as a keyword where either the namespace
-  or name component can be substituted with a `*`. For example the below are
-  all valid globs
-
-  ```clojure
-  (glob-matches? :*/* :a/b) ;; true
-  (glob-matches? :a/* :a/b) ;; true
-  (glob-matches? :*/b :a/b) ;; true
-  (glob-matches? :*/b 'a/b) ;; true
-
-  (glob-matches? :a/a :a/b) ;; false
-  ```"
+   The keyword `glob` should be provided as a keyword where either the namespace
+   or name component can be substituted with a `*`. For example the below are
+   all valid globs
+
+   ```clojure
+   (glob-matches? :*/* :a/b) ;; true
+   (glob-matches? :a/* :a/b) ;; true
+   (glob-matches? :*/b :a/b) ;; true
+   (glob-matches? :*/b 'a/b) ;; true
+
+   (glob-matches? :a/a :a/b) ;; false
+   ```"
   {:malli/schema [:-> :keyword [:or :keyword :symbol] :boolean]}
   [glob kw|sym]
   (let [ns-matches
@@ -116,27 +116,27 @@
 
 (defn name-matches?
   "A `predicate-fn` constructor (returns a `predicate-fn`) designed to be used
-  with [[k16.kmono.core.graph/filter-by]].
+   with [[k16.kmono.core.graph/filter-by]].
 
-  Compares a give `pkg` :fqn against a given set of `globs` in the format
-  described by [[glob-matches?]]. Returns true if a match is found.
+   Compares a give `pkg` :fqn against a given set of `globs` in the format
+   described by [[glob-matches?]]. Returns true if a match is found.
 
-  ```clojure
-  (core.graph/filter-by (name-matches? [:*/*]))
-  ```"
+   ```clojure
+   (core.graph/filter-by (name-matches? [:*/*]))
+   ```"
   [globs]
   (fn name-matches-filter-fn [pkg]
     (boolean (some #(glob-matches? % (:fqn pkg)) globs))))
 
 (defn resolve-packages
   "Resolve the packages graph for a clojure project.
 
-  This will find all packages as described by the given `workspace-config` and
-  will use them to build a graph of all workspace packages and their
-  dependencies.
+   This will find all packages as described by the given `workspace-config` and
+   will use them to build a graph of all workspace packages and their
+   dependencies.
 
-  See [[k16.kmono.core.schema/?PackageMap]] for a schema of the returned
-  package map."
+   See [[k16.kmono.core.schema/?PackageMap]] for a schema of the returned
+   package map."
   {:malli/schema [:=> [:cat :string core.schema/?WorkspaceConfig] core.schema/?PackageMap]}
   [project-root workspace-config]
   (let [globs (:packages workspace-config)

packages/kmono-core/src/k16/kmono/core/thread.clj

@@ -1,8 +1,8 @@
 (ns ^:no-doc k16.kmono.core.thread
   (:import
    java.util.concurrent.ExecutionException
-   java.util.concurrent.ExecutorService
-   java.util.concurrent.Executors))
+   java.util.concurrent.Executors
+   java.util.concurrent.ExecutorService))
 
 (set! *warn-on-reflection* true)
 
@@ -16,8 +16,8 @@
 (defn batch
   "Execute the given `coll` in batches of `batch-size`.
 
-   Each batch will be executed in parallel and a new batch will only be
-   executed when all items in the previous batch have completed.
+   Each batch will be executed in parallel and a new batch will only be executed
+   when all items in the previous batch have completed.
 
    If any items fail the entire operation fails."
   ([f batch-size]

packages/kmono-core/src/k16/kmono/cp.clj

@@ -30,18 +30,18 @@
 (defn collect-aliases
   "Collect a set of 'active' aliases from the workspace.
 
-  This function works by:
+   This function works by:
 
-  1. Discovering all available package aliases in the workspace and filtering
-     them based on the `:package-aliases` config from the provided
-     `workspace-config`.
-  2. Merging this set with the aliases defined in the `:aliases` key on the
-     `workspace-config`.
-  3. Adding the special `:kmono/packages` alias which contains the base package
-     classpaths.
+   1. Discovering all available package aliases in the workspace and filtering
+      them based on the `:package-aliases` config from the provided
+      `workspace-config`.
+   2. Merging this set with the aliases defined in the `:aliases` key on the
+      `workspace-config`.
+   3. Adding the special `:kmono/packages` alias which contains the base package
+      classpaths.
 
-  This function is designed to be used to collect the relevant set of aliases
-  to provide to the clojure flags `-A`, `-M`, `-T`, `-X`."
+   This function is designed to be used to collect the relevant set of aliases
+   to provide to the clojure flags `-A`, `-M`, `-T`, `-X`."
   [workspace-config packages]
   (let [package-alias-globs (:package-aliases workspace-config)
         package-aliases (->> packages
@@ -74,10 +74,10 @@
 (defn resolve-classpath
   "Resolve a classpath string for a workspace.
 
-  This works by shelling out to `clojure -Spath` with additional flags
-  generated from analysing the workspace.
+   This works by shelling out to `clojure -Spath` with additional flags
+   generated from analysing the workspace.
 
-  See [[generate-classpath-command]] for the command construction logic."
+   See [[generate-classpath-command]] for the command construction logic."
   [project-root workspace-config packages]
   (:out
    (proc/shell