internal build: migrate to tools.build

Respond to depstar being deprecated in favour of tools.build.

Our new build.clj is responsible for:
- building jar
- local m2 repo installs (switched from deps-deploy to tools.build)
- deploys to clojars (still using deps-deploy, no equivalent in tools.build yet)
- generating artifact version
- returning last built artifact version

Our pom.xml has become anemic and now acts as a template to tools.build
when building pom.xml for artifacts.

Because our git commited pom.xml no longer contains deps, I no longer
have to suppress antq reporting on Clojure 1.9.0 being outdated in
pom.xml from our bb outdated task.

We had already been using a version suffix of canary for local install
of rewrite-clj created and used by test-libs bb task.
We now use a version suffix of cljdoc-preview for cljdoc-preview
bb task for locally installed rewrite-clj.

These suffixes are good signals for me to recognize the source of
these rewrite-clj test versions in my m2 repo.

Author: lread

.github/workflows/release.yml

@@ -68,7 +68,7 @@ jobs:
       run: bb ci-release commit
 
     - name: Make GitHub Actions aware of target version tag
-      run: echo "::set-output name=tag::v$(cat ./target/target-version.txt)"
+      run: echo "::set-output name=tag::v$(clojure -T:build built-version)"
       id: target-version
 
     - name: Create GitHub release (step 4 of 4)

CHANGELOG.adoc

@@ -16,6 +16,9 @@ For a list of breaking changes see link:#v1-breaking[breaking changes].
 
 === Unreleased
 
+* internal rewrite-clj developer facing:
+** Migrate from `depstar` to `tools.build`
+
 === v1.0.682-alpha
 
 * update clojure tools.reader dependency to v1.3.6

bb.edn

@@ -3,7 +3,6 @@
  :deps {org.clojure/data.zip {:mvn/version "1.0.0"}
         io.aviso/pretty {:mvn/version "1.1"}
         dev.nubank/docopt {:mvn/version "0.6.1-fix7"}
-        com.github.liquidz/antq {:mvn/version "1.0.1"}
         doric/doric {:mvn/version "0.9.0"}
         version-clj/version-clj {:mvn/version "2.0.2"}
         lread/status-line {:git/url "https://github.com/lread/status-line.git"

build.clj

@@ -0,0 +1,75 @@
+(ns build
+  (:require [clojure.edn :as edn]
+            [clojure.java.io :as io]
+            [clojure.tools.build.api :as b]
+            [deps-deploy.deps-deploy :as dd]))
+
+(def lib 'rewrite-clj/rewrite-clj)
+(def version (let [version-template (-> "version.edn" slurp edn/read-string)
+                   patch (b/git-count-revs nil)]
+               (str (:major version-template) "."
+                    (:minor version-template) "."
+                    patch
+                    (cond->> (:qualifier version-template)
+                      true (str "-")))))
+(def class-dir "target/classes")
+(def basis (b/create-basis {:project "deps.edn"}))
+(def jar-file (format "target/%s.jar" (name lib)))
+(def built-jar-version-file "target/built-jar-version.txt")
+
+(defn jar
+  "Build library jar file.
+  Also writes built version to target/built-jar-version.txt for easy peasy pickup by any interested downstream operation.
+
+  We use the optional :version-suffix to distinguish local installs from production releases.
+  For example, when testing 3rd party libs against rewrite-clj master we use the suffix: canary. "
+  [{:keys [version-suffix]}]
+  (b/delete {:path class-dir})
+  (b/delete {:path jar-file})
+  (let [version (if version-suffix (format "%s-%s" version version-suffix)
+                    version)]
+    (b/write-pom {:class-dir class-dir
+                  :lib lib
+                  :version version
+                  :scm {:tag (format "v%s" version)}
+                  :basis basis
+                  :src-dirs ["src"]})
+    (b/copy-dir {:src-dirs ["src" "resources"]
+                 :target-dir class-dir})
+    (b/jar {:class-dir class-dir
+            :jar-file jar-file})
+    (spit built-jar-version-file version)))
+
+(defn- built-version* []
+  (when (not (.exists (io/file built-jar-version-file)))
+    (throw (ex-info (str "Built jar version file not found: " built-jar-version-file) {})))
+  (slurp built-jar-version-file))
+
+(defn built-version
+  ;; NOTE: Used by release script and github workflow
+  "Spit out version of jar built (with no trailing newline).
+  A separate task because I don't know what build.tools might spit to stdout."
+  [_]
+  (print (built-version*))
+  (flush))
+
+(defn install
+  "Install built jar to local maven repo"
+  [_]
+  (b/install {:class-dir class-dir
+              :lib lib
+              :version (built-version*)
+              :basis basis
+              :jar-file jar-file}))
+
+(defn deploy
+  "Deploy built jar to clojars"
+  [_]
+  (dd/deploy {:installer :remote
+              :artifact jar-file
+              :pom-file (b/pom-path lib :class-dir class-dir)}))
+
+(defn project-lib
+  "Returns project groupid/artifactid"
+  [_]
+  (println lib))

deps.edn

@@ -106,23 +106,9 @@
            ;;
            ;; Deployment
            ;;
-           :jar {:replace-deps {com.github.seancorfield/depstar {:mvn/version "2.1.297"}}
-                 :exec-fn hf.depstar/jar
-                 :exec-args {:jar "target/rewrite-clj.jar"
-                             :paths-only true
-                             :verbose true
-                             :jar-type :thin}}
-
-           :deploy {:replace-deps {slipset/deps-deploy {:mvn/version "0.1.5"}}
-                    :exec-fn deps-deploy.deps-deploy/deploy}
-
-           ;; usage: :deploy:remote - for Clojars
-           :remote {:exec-args {:installer :remote
-                                :artifact "target/rewrite-clj.jar"}}
-
-           ;; usage: :deploy:local - for local maven repo
-           :local {:exec-args {:installer :local
-                               :artifact "target/rewrite-clj.jar"}}
+           :build {:deps {io.github.clojure/tools.build {:git/tag "v0.5.0" :git/sha "7d77952"}
+                          io.github.slipset/deps-deploy {:sha "3d20d0ee86c35c431e4fcf5b0830a3785e8116c0"}}
+                   :ns-default build}
 
            ;;
            ;; Maintenance support
@@ -131,6 +117,5 @@
                                    org.slf4j/slf4j-simple {:mvn/version "1.7.32"} ;; to rid ourselves of logger warnings
                                    }
                       :main-opts ["-m" "antq.core"
-                                  "--reporter=edn"
                                   "--exclude=lambdaisland/[email protected]" ;; https://github.com/lambdaisland/kaocha/issues/208
                                   ]}}}

doc/02-developer-guide.adoc

@@ -278,15 +278,11 @@ To see what new dependencies are available, run:
 bb outdated
 ----
 
-We use https://github.com/liquidz/antq[antq] which also checks `pom.xml`.
-If you see an outdated dependency reported for `pom.xml` after updating `deps.edn`, run the following:
+This task uses:
 
-----
-clojure -Spom
-----
-
-This script also checks for outdated Node.js dependencies.
-Note that checks are only done against installed `./node_modules`, so you may want to run `npm install` first.
+* https://github.com/liquidz/antq[antq] for Clojure.
+* npm for JavaScript.
+It only checks against installed `./node_modules`, so you may want to run `npm install` first.
 
 [#linting]
 == Linting
@@ -363,6 +359,10 @@ bb cljdoc-preview ingest
 ----
 
 The ingest command automatically publishes rewrite-clj to your local maven repository (cljdoc only works with published jars).
+
+The locally published version will include a `-cljdoc-preview` suffix.
+I find this distinction helps to reduce confusion around locally vs remotely installed artifacts.
+
 You'll have to remember to git commit and git push your changes before ingesting.
 
 Repeat these steps any time you want to preview changes.

doc/04-maintainer-guide.adoc

@@ -12,13 +12,12 @@ The released workflow is handled by our https://github.com/clj-commons/rewrite-c
 
 The release workflow:
 
-. Calculates a version using our versioning scheme and applies it to:
-.. `deps.edn` usage example in the user guide
-.. "unreleased" and "unreleased breaking changes" headings in the change log
-.. ``pom.xml``'s `version` and `scm`->`tag`
-. Create a thin jar
+. Create a thin jar using our version scheme
+. Apply jar version to following docs:
+.. user guide docs `deps.edn` usage example
+.. change log "unreleased" and "unreleased breaking changes" headings
 . Deploy the jar to clojars
-. Commit and push updates made to `CHANGELOG.adoc`, `pom.xml` and `01-user-guide.adoc` back to the project
+. Commit and push updates made to `CHANGELOG.adoc` and `01-user-guide.adoc` back to the project
 . Create and push a release tag back to the project repo
 . Inform cljdoc of the new release
 
@@ -48,9 +47,9 @@ If you so wish, you can also locally run all steps up to, but not including, dep
 
 [source,shell]
 ----
-bb release prep
+bb ci-release prep
 ----
-Be aware though that you will NOT want to check in changes `prep` makes to `CHANGELOG.adoc`, `pom.xml` and `01-user-guide.adoc`.
+Be aware though that you will NOT want to check in changes `prep` makes to `CHANGELOG.adoc` and `01-user-guide.adoc`.
 
 === Invoking
 

pom.xml

@@ -1,41 +1,17 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
-  <groupId>rewrite-clj</groupId>
-  <artifactId>rewrite-clj</artifactId>
-  <version>1.0.682-alpha</version>
   <name>rewrite-clj</name>
-  <description>A library that reads and writes Clojure, ClojureScript and EDN from Clojure and ClojureScript in a whitespace and comment preserving way.</description>
+  <description>Rewrite Clojure code and edn2</description>
   <url>https://github.com/clj-commons/rewrite-clj</url>
   <scm>
     <url>https://github.com/clj-commons/rewrite-clj</url>
     <connection>scm:git:[email protected]:clj-commons/rewrite-clj.git</connection>
     <developerConnection>scm:git:[email protected]:clj-commons/rewrite-clj.git</developerConnection>
-    <tag>v1.0.682-alpha</tag>
   </scm>
-  <dependencies>
-    <dependency>
-      <groupId>org.clojure</groupId>
-      <artifactId>clojure</artifactId>
-      <version>1.9.0</version>
-    </dependency>
-    <dependency>
-      <groupId>org.clojure</groupId>
-      <artifactId>tools.reader</artifactId>
-      <version>1.3.6</version>
-    </dependency>
-  </dependencies>
   <properties>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
   </properties>
-  <build>
-    <sourceDirectory>src</sourceDirectory>
-    <resources>
-      <resource>
-        <directory>src</directory>
-      </resource>
-    </resources>
-  </build>
   <repositories>
     <repository>
       <id>clojars</id>

script/ci_release.clj

@@ -10,25 +10,18 @@
             [helper.fs :as fs]
             [helper.main :as main]
             [helper.shell :as shell]
-            [lread.status-line :as status]
-            [release.version :as version]))
+            [lread.status-line :as status]))
 
 (defn clean! []
   (doseq [dir ["target" ".cpcache"]]
     (fs/delete-file-recursively dir true)))
 
 (defn- last-release-tag []
-  (->  (shell/command {:out :string} 
+  (->  (shell/command {:out :string}
                       "git describe --abbrev=0 --match v[0-9]*")
        :out
        string/trim))
 
-(defn- calculate-version []
-  (status/line :head "Calculating release version")
-  (let [version (version/calc)]
-    (status/line :detail (str "version: " version))
-    version))
-
 (defn- update-file! [fname match-replacements]
   (let [old-content (slurp fname)
         new-content (reduce (fn [in [desc match replacement]]
@@ -105,14 +98,17 @@
                          #"(?im)(=+) +unreleased breaking changes *$"
                          (str "$1 v" version)]))))
 
-(defn- create-jar! [version]
-  (status/line :head (str "Creating jar for version " version))
-  (status/line :detail "Reflecting deps in deps.edn to pom.xml")
-  (shell/command "clojure -Spom")
-  (status/line :detail "Updating pom.xml version and creating thin jar")
-  (shell/command "clojure -X:jar :version" (pr-str version))
+(defn- create-jar! []
+  (status/line :head "Creating jar for release")
+  (shell/command "clojure -T:build jar")
   nil)
 
+(defn- built-version []
+  (-> (shell/command {:out :string}
+                     "clojure -T:build built-version")
+      :out
+      string/trim))
+
 (defn- assert-on-ci
   "Little blocker to save myself from myself when testing."
   [action]
@@ -124,15 +120,15 @@
   []
   (status/line :head "Deploying jar to clojars")
   (assert-on-ci "deploy a jar")
-  (shell/command "clojure -X:deploy:remote")
+  (shell/command "clojure -T:build deploy")
   nil)
 
 (defn- commit-changes! [version]
   (let [tag-version (str "v" version)]
     (status/line :head (str  "Committing and pushing changes made for " tag-version))
     (assert-on-ci "commit changes")
     (status/line :detail "Adding changes")
-    (shell/command "git add doc/01-user-guide.adoc CHANGELOG.adoc pom.xml")
+    (shell/command "git add doc/01-user-guide.adoc CHANGELOG.adoc")
     (status/line :detail "Committing")
     (shell/command "git commit -m" (str  "Release job: updates for version " tag-version))
     (status/line :detail "Version tagging")
@@ -155,7 +151,7 @@
     (when (not (zero? exit-code))
       (status/line :warn (str  "Informing cljdoc did not seem to work, exited with " exit-code)))))
 
-(def args-usage "Valid args: (prep|deploy-remote|commit|validate|version|--help)
+(def args-usage "Valid args: (prep|deploy-remote|commit|validate|--help)
 
 Commands:
   prep           Update user guide, changelog and create jar
@@ -168,48 +164,36 @@ To restrict the exposure of our CLOJARS secrets during deploy workflow
 
 Additional commands:
   validate      Verify that change log is good for release
-  version       Calculate and report version
 
 Options
   --help        Show this help")
 
 (defn -main [& args]
   (when-let [opts (main/doc-arg-opt args-usage args)]
-    (let [target-version-filename "target/target-version.txt"]
-      (cond
-        (get opts "prep")
-        (do (clean!)
-            (let [changelog-status (validate-changelog)
-                  target-version (calculate-version)
-                  last-version (last-release-tag)]
-              (status/line :detail (str "Last version released: " (or last-version "<none>")))
-              (status/line :detail (str "Target version:        " target-version))
-              (io/make-parents target-version-filename)
-              (spit target-version-filename target-version)
-              (update-user-guide! target-version)
-              (update-changelog! target-version last-version changelog-status)
-              (create-jar! target-version)))
-
-        (get opts "deploy-remote")
-        (deploy-jar!)
-
-        (get opts "commit")
-        (if (not (.exists (io/file target-version-filename)))
-          (status/die 1
-                      "Target version file not found: %s\nWas prep step run?"
-                      target-version-filename)
-          (let [target-version (slurp target-version-filename)]
-            (commit-changes! target-version)
-            (inform-cljdoc! target-version)))
-
-        (get opts "validate")
-        (do (validate-changelog)
-            nil)
-
-        (get opts "version")
-        (do (calculate-version)
-            nil)))))
+    (cond
+      (get opts "prep")
+      (do (clean!)
+          (let [changelog-status (validate-changelog)
+                last-version (last-release-tag)]
+            (status/line :detail (str "Last version released: " (or last-version "<none>")))
+            (io/make-parents "target")
+            (create-jar!)
+            (let [version (built-version)]
+              (status/line :detail (str "Built version: " version))
+              (update-user-guide! version)
+              (update-changelog! version last-version changelog-status))))
+
+      (get opts "deploy-remote")
+      (deploy-jar!)
+
+      (get opts "commit")
+      (let [version (built-version)]
+        (commit-changes! version)
+        (inform-cljdoc! version))
+
+      (get opts "validate")
+      (do (validate-changelog)
+          nil))))
 
 (main/when-invoked-as-script
  (apply -main *command-line-args*))
-