Fix create basis package resolution

packages/kmono-build/deps.edn

@@ -9,4 +9,10 @@
         babashka/fs {:mvn/version "0.5.30"}
 
         com.kepler16/kmono-core {:local/root "../kmono-core"}
-        com.kepler16/kmono-log {:local/root "../kmono-log"}}}
+        com.kepler16/kmono-log {:local/root "../kmono-log"}}
+
+ :aliases {:test {:extra-paths ["test"]
+                  :extra-deps {lambdaisland/kaocha {:mvn/version "1.91.1392"}
+                               nubank/matcher-combinators {:mvn/version "3.9.2"}
+                               local/kmono-test {:local/root "../kmono-test"}}
+                  :main-opts ["-m" "kaocha.runner" "-c" "../../tests.edn"]}}}

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

@@ -59,33 +59,36 @@
   "Constructs a basis using [[clojure.tools.build.api/create-basis]] with a
    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 resolved basis `:libs` are
+   replaced with their respective `:mvn/version` coordinate by looking up the
+   lib's symbol in the given `packages` map.
 
    These `:libs` are then used to generate a correctly referenced `pom.xml` when
    using [[clojure.tools.build.api/write-pom]].
 
+   The `packages` map should contain all workspace packages required for version
+   lookup (typically the full unfiltered package map).
+
    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
+   (let [basis (b/create-basis opts)
+
+         libs
          (into {}
-               (comp
-                (map (fn [pkg-name]
-                       (let [version (get-in packages [pkg-name :version])
-                             dep {:deps/manifest :mvn
-                                  :mvn/version version
-                                  :parents #{[]}
-                                  :paths []}]
-                         (when version
-                           [pkg-name dep]))))
-                (remove nil?))
-               (:depends-on package))
-
-         basis (b/create-basis opts)]
-
-     (update basis :libs merge dependencies))))
+               (map (fn [[lib-name coord]]
+                      (let [version (get-in packages [lib-name :version])
+                            local-dep? (some? (get-in packages [(:fqn package) :deps-edn :deps lib-name :local/root]))]
+                        (if (and version local-dep?)
+                          [lib-name {:deps/manifest :mvn
+                                     :mvn/version version
+                                     :parents #{[]}
+                                     :paths []}]
+                          [lib-name coord]))))
+               (:libs basis))]
+
+     (assoc basis :libs libs))))
 
 (def ^:no-doc ?BuildOpts
   [:map

packages/kmono-build/test/k16/kmono/build_test.clj

@@ -0,0 +1,57 @@
+(ns k16.kmono.build-test
+  (:require
+   [clojure.test :refer [deftest is testing use-fixtures]]
+   [clojure.tools.build.api :as b]
+   [k16.kmono.build :as kmono.build]
+   [k16.kmono.core.config :as core.config]
+   [k16.kmono.core.packages :as core.packages]
+   [k16.kmono.test.helpers.repo :refer [*repo* with-test-repo]]
+   [matcher-combinators.test]))
+
+(use-fixtures :once with-test-repo)
+
+(defn- load-packages []
+  (let [config (core.config/resolve-workspace-config *repo*)
+        packages (core.packages/resolve-packages *repo* config)]
+    packages))
+
+(deftest create-basis-replaces-local-deps-with-mvn-version-test
+  (testing "replaces :local/root workspace libs with :mvn/version"
+    (let [packages (load-packages)
+          packages (assoc-in packages ['com.kepler16/a :version] "1.2.3")
+          pkg-b (get packages 'com.kepler16/b)]
+      (b/with-project-root (:absolute-path pkg-b)
+        (let [basis (kmono.build/create-basis packages pkg-b)]
+          (is (match? {'com.kepler16/a {:deps/manifest :mvn
+                                        :mvn/version "1.2.3"}}
+                      (:libs basis))))))))
+
+(deftest create-basis-after-filter-by-test
+  (testing "works when :depends-on has been cleared by filter-by"
+    (let [packages (load-packages)
+          packages (assoc-in packages ['com.kepler16/a :version] "1.2.3")
+          pkg-b (assoc (get packages 'com.kepler16/b) :depends-on #{})]
+      (b/with-project-root (:absolute-path pkg-b)
+        (let [basis (kmono.build/create-basis packages pkg-b)]
+          (is (match? {'com.kepler16/a {:deps/manifest :mvn
+                                        :mvn/version "1.2.3"}}
+                      (:libs basis)))))))
+
+  (testing "leaves non-workspace libs unchanged"
+    (let [packages (load-packages)
+          packages (assoc-in packages ['com.kepler16/a :version] "1.2.3")
+          pkg-b (get packages 'com.kepler16/b)]
+      (b/with-project-root (:absolute-path pkg-b)
+        (let [basis (kmono.build/create-basis packages pkg-b)]
+          (is (match? {'org.clojure/clojure {:deps/manifest :mvn
+                                             :mvn/version "1.12.0"}}
+                      (:libs basis)))))))
+
+  (testing "leaves workspace libs with no version unchanged"
+    (let [packages (load-packages)
+          pkg-b (get packages 'com.kepler16/b)]
+      (b/with-project-root (:absolute-path pkg-b)
+        (let [basis (kmono.build/create-basis packages pkg-b)]
+          (is (match? {'com.kepler16/a {:deps/manifest :deps}}
+                      (:libs basis)))
+          (is (nil? (get-in basis [:libs 'com.kepler16/a :mvn/version]))))))))