internal dev: scripts updated to use new shell fn

Migrated from babashka process to bb tasks shell.

This allowed me to support continueing on non-zero exits
(via {:continue true}) and custom error reporting (via {:error-fn})
more gracefully. Other observations:
- opts are specified first, I like this for especially long arg lists,
  the opts could otherwise be less obvious at-a-glance.
- shell args are no longer wrapped in a vector and the the first
  arg will have shell args automatically parsed out. So we can
  (shell "ls -l") or (shell "ls" "-l"). When a vector is more convenient
  we call always (apply shell ["ls" "-l"]).
- one could argue that the new shell fn can be easier to use but also
  more complicated because it supports doing 1 thing in different ways.

Overall, I like the change, but as with everything there are pros and
cons.

Author: lread

CHANGELOG.adoc

@@ -16,6 +16,8 @@ For a list of breaking changes see link:#v1-breaking[breaking changes].
 
 === Unreleased
 
+* Internal rewrite-clj developer facing changes only
+
 === v1.0.644-alpha
 
 * user guide and docstrings better explain `sexpr-able?` and what invalid code elements rewrite-clj parses https://github.com/clj-commons/rewrite-clj/issues/150[#150] https://github.com/clj-commons/rewrite-clj/issues/151[#151]

script/apply_import_vars.clj

@@ -18,7 +18,7 @@ Options:
   (when-let [opts (main/doc-arg-opt args-usage args)]
     (let [cmd (if (get opts "check") "check" "gen-code")]
       (status/line :head (str "Running apply import vars " cmd))
-      (shell/command ["clojure" "-X:apply-import-vars:script" cmd])))
+      (shell/command "clojure -X:apply-import-vars:script" cmd)))
     nil)
 
 (main/when-invoked-as-script

script/ci_release.clj

@@ -18,7 +18,8 @@
     (fs/delete-file-recursively dir true)))
 
 (defn- last-release-tag []
-  (->  (shell/command ["git" "describe" "--abbrev=0" "--match" "v[0-9]*"] {:out :string})
+  (->  (shell/command {:out :string} 
+                      "git describe --abbrev=0 --match v[0-9]*")
        :out
        string/trim))
 
@@ -107,9 +108,9 @@
 (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"])
+  (shell/command "clojure -Spom")
   (status/line :detail "Updating pom.xml version and creating thin jar")
-  (shell/command ["clojure" "-X:jar" ":version" (pr-str version)])
+  (shell/command "clojure -X:jar :version" (pr-str version))
   nil)
 
 (defn- assert-on-ci
@@ -123,32 +124,33 @@
   []
   (status/line :head "Deploying jar to clojars")
   (assert-on-ci "deploy a jar")
-  (shell/command ["clojure" "-X:deploy:remote"])
+  (shell/command "clojure -X:deploy:remote")
   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 pom.xml")
     (status/line :detail "Committing")
-    (shell/command ["git" "commit" "-m" (str  "Release job: updates for version " tag-version)])
+    (shell/command "git commit -m" (str  "Release job: updates for version " tag-version))
     (status/line :detail "Version tagging")
-    (shell/command ["git" "tag" "-a" tag-version "-m" (str  "Release " tag-version)])
+    (shell/command "git" "tag" "-a" tag-version "-m" (str  "Release " tag-version))
     (status/line :detail "Pushing commit")
-    (shell/command ["git" "push"])
+    (shell/command "git push")
     (status/line :detail "Pushing version tag")
-    (shell/command ["git" "push" "origin" tag-version])
+    (shell/command "git push origin" tag-version)
     nil))
 
 (defn- inform-cljdoc! [version]
   (status/line :head (str "Informing cljdoc of new version " version))
   (assert-on-ci "inform cljdoc")
-  (let [exit-code (->  (shell/command-no-exit ["curl" "-X" "POST"
-                                               "-d" "project=rewrite-clj/rewrite-clj"
-                                               "-d" (str  "version=" version)
-                                               "https://cljdoc.org/api/request-build2"])
+  (let [exit-code (->  (shell/command {:continue true}
+                                      "curl" "-X" "POST"
+                                      "-d" "project=rewrite-clj/rewrite-clj"
+                                      "-d" (str  "version=" version)
+                                      "https://cljdoc.org/api/request-build2")
                        :exit)]
     (when (not (zero? exit-code))
       (status/line :warn (str  "Informing cljdoc did not seem to work, exited with " exit-code)))))
@@ -210,3 +212,4 @@ Options
 
 (main/when-invoked-as-script
  (apply -main *command-line-args*))
+

script/ci_unit_tests.clj

@@ -12,29 +12,29 @@
     (fs/delete-file-recursively dir true)))
 
 (defn lint []
-  (shell/command ["bb" "lint"]))
+  (shell/command "bb lint"))
 
 (defn check-import-vars []
-  (shell/command ["bb" "apply-import-vars" "check"]))
+  (shell/command "bb apply-import-vars check"))
 
 (defn doc-tests[]
-  (shell/command ["bb" "test-doc"]))
+  (shell/command "bb test-doc"))
 
 (defn clojure-tests []
   (doseq [version ["1.9" "1.10"]]
-    (shell/command ["bb" "test-clj" "--clojure-version" version])) )
+    (shell/command "bb test-clj --clojure-version" version)) )
 
 (defn cljs-tests []
   (doseq [env ["node" "chrome-headless"]
           opt ["none" "advanced"]]
-    (shell/command ["bb" "test-cljs" "--env" env "--optimizations" opt])))
+    (shell/command "bb" "test-cljs" "--env" env "--optimizations" opt)))
 
 (defn shadow-cljs-tests []
-  (shell/command ["bb" "test-shadow-cljs"]))
+  (shell/command "bb test-shadow-cljs"))
 
 (defn cljs-bootstrap-tests []
   (if (some #{(env/get-os)} '(:mac :unix))
-    (shell/command ["bb" "test-cljs" "--env" "planck" "--optimizations" "none"])
+    (shell/command "bb test-cljs --env planck --optimizations none")
     (status/line :warn "skipping planck tests, they can only be run on linux and macOS")) )
 
 (defn -main [& args]

script/cljdoc_preview.clj

@@ -52,9 +52,9 @@
 
 (defn local-install []
   (status/line :head "building thin jar")
-  (shell/command ["clojure" "-X:jar"])
+  (shell/command "clojure -X:jar")
   (status/line :head "installing project to local maven repo")
-  (shell/command ["clojure" "-X:deploy:local"]))
+  (shell/command "clojure -X:deploy:local"))
 
 (defn get-project []
   (str (get-from-pom :project :groupId) "/" (get-from-pom :project :artifactId) ))
@@ -67,8 +67,8 @@
 ;;
 
 (defn git-sha []
-  (-> (shell/command ["git" "rev-parse" "HEAD"]
-                     {:out :string})
+  (-> (shell/command {:out :string}
+                     "git rev-parse HEAD")
       :out
       string/trim))
 
@@ -89,22 +89,22 @@
         (string/replace #"^(ssh///)*git@" "https://"))))
 
 (defn git-origin-url-as-https []
-  (-> (shell/command ["git" "config" "--get" "remote.origin.url"]
-                     {:out :string})
+  (-> (shell/command {:out :string}
+                     "git config --get remote.origin.url")
       :out
       string/trim
       https-uri))
 
 (defn uncommitted-code? []
-  (-> (shell/command ["git" "status" "--porcelain"]
-                     {:out :string})
+  (-> (shell/command {:out :string}
+                     "git status --porcelain")
       :out
       string/trim
       seq))
 
 (defn unpushed-commits? []
-  (let [{:keys [:exit :out]} (shell/command-no-exit ["git" "cherry" "-v"]
-                                                    {:out :string})]
+  (let [{:keys [:exit :out]} (shell/command {:continue true :out :string}
+                                            "git cherry -v")]
     (if (zero? exit)
       (-> out string/trim seq)
       (status/die 1 "Failed to check for unpushed commits to branch, is your branch pushed?"))))
@@ -114,21 +114,21 @@
 ;;
 
 (defn status-server [ container ]
-  (let [container-id (-> ["docker" "ps" "-q" "-f" (str "name=" (:name container))]
-                         (shell/command {:out :string})
+  (let [container-id (-> (shell/command {:out :string}
+                                        "docker ps -q -f" (str "name=" (:name container)))
                          :out
                          string/trim)]
     (if (string/blank? container-id) "down" "up")))
 
 (defn docker-pull-latest [ container ]
-  (shell/command ["docker" "pull" (:image container)]))
+  (shell/command "docker pull" (:image container)))
 
 (defn stop-server [ container ]
   (when (= "down" (status-server container))
     (status/die 1
                 "%s does not appear to be running"
                 (:name container)))
-  (shell/command ["docker" "stop" (:name container) "--time" "0"]))
+  (shell/command "docker" "stop" (:name container) "--time" "0"))
 
 (defn wait-for-server
   "Wait for container's http server to become available, assumes server has valid root page"
@@ -158,21 +158,21 @@
 
 (defn cljdoc-ingest [container project version]
   (status/line :head "Ingesting project %s %s\ninto local cljdoc database" project version)
-  (shell/command ["docker"
-                  "run" "--rm"
-                  "-v" (str cljdoc-db-dir ":/app/data")
-                  "-v" (str (home-dir) "/.m2:/root/.m2")
-                  "-v" (str (cwd) ":" (cwd) ":ro")
-                  "--entrypoint" "clojure"
-                  (:image container)
-                  "-A:cli"
-                  "ingest"
+  (shell/command "docker"
+                 "run" "--rm"
+                 "-v" (str cljdoc-db-dir ":/app/data")
+                 "-v" (str (home-dir) "/.m2:/root/.m2")
+                 "-v" (str (cwd) ":" (cwd) ":ro")
+                 "--entrypoint" "clojure"
+                 (:image container)
+                 "-A:cli"
+                 "ingest"
                   ;; project and version are used to locate the maven artifact (presumably locally)
-                  "--project" project "--version" version
+                 "--project" project "--version" version
                   ;; use git origin to support folks working from forks/PRs
-                  "--git" (git-origin-url-as-https)
+                 "--git" (git-origin-url-as-https)
                   ;; specify revision to allow for previewing when working from branch
-                  "--rev" (git-sha)]))
+                 "--rev" (git-sha)))
 
 (defn start-cljdoc-server [container]
   (when (= "up" (status-server container))
@@ -182,15 +182,15 @@
   (status/line :head "Checking for updates")
   (docker-pull-latest container)
   (status/line :head "Starting %s on port %d" (:name container) (:port container))
-  (shell/command ["docker"
-                  "run" "--rm"
-                  "--name" (:name container)
-                  "-d"
-                  "-p" (str (:port container) ":8000")
-                  "-v" (str cljdoc-db-dir ":/app/data")
-                  "-v" (str (home-dir) "/.m2:/root/.m2")
-                  "-v" (str (cwd) ":" (cwd) ":ro")
-                  (:image container)]))
+  (shell/command "docker"
+                 "run" "--rm"
+                 "--name" (:name container)
+                 "-d"
+                 "-p" (str (:port container) ":8000")
+                 "-v" (str cljdoc-db-dir ":/app/data")
+                 "-v" (str (home-dir) "/.m2:/root/.m2")
+                 "-v" (str (cwd) ":" (cwd) ":ro")
+                 (:image container)))
 
 (defn view-in-browser [url]
   (status/line :head "opening %s in browser" url)

script/doc_api_diffs.clj

@@ -10,7 +10,7 @@
 
 (defn install-locally []
   (status/line :head "installing rewrite-clj v1 locally from dev")
-  (shell/command ["mvn" "install"]))
+  (shell/command "mvn install"))
 
 (defn wipe-rewrite-clj-diff-cache [ {:keys [coords version]}]
   (let [cache-dir (io/file "./.diff-apis/.cache")
@@ -38,14 +38,16 @@
 
 (defn diff-apis [{:keys [:notes-dir :report-dir]} projecta projectb report-name extra-args]
   (status/line :head "Diffing %s and %s" (describe-proj projecta) (describe-proj projectb))
-  (shell/command (concat ["clojure" "-M:diff-apis"]
-                         (map projecta [:coords :version :lang])
-                         (map projectb [:coords :version :lang])
-                         ["--arglists-by" ":arity-only"
-                          "--notes" (str (io/file notes-dir (str report-name ".adoc")))
-                          "--report-format" ":asciidoc"
-                          "--report-filename" (str  (io/file report-dir (str report-name ".adoc")))]
-                         extra-args)))
+  (apply shell/command 
+         (concat
+          ["clojure" "-M:diff-apis"]
+          (map projecta [:coords :version :lang])
+          (map projectb [:coords :version :lang])
+          ["--arglists-by" ":arity-only"
+           "--notes" (str (io/file notes-dir (str report-name ".adoc")))
+           "--report-format" ":asciidoc"
+           "--report-filename" (str  (io/file report-dir (str report-name ".adoc")))]
+          extra-args)))
 
 (defn -main [& args]
   (when (main/doc-arg-opt args)

script/doc_update_readme.clj

@@ -130,7 +130,7 @@
   (try
     (let [chrome (chrome)]
       {:exe chrome
-       :version (-> (shell/command [chrome "--version"] {:out :string})
+       :version (-> (shell/command {:out :string} chrome "--version")
                     :out
                     string/trim)})
     (catch Exception _e)))
@@ -139,14 +139,14 @@
   (let [html-file (str target-dir "/temp.html")]
     (try
       (spit html-file (generate-contributor-html github-id contributions))
-      (shell/command [(chrome)
-                      "--headless"
-                      (str "--screenshot=" target-dir "/" github-id ".png")
-                      (str "--window-size=" (:image-width image-opts) ",125")
-                      "--default-background-color=0"
-                      "--hide-scrollbars"
-                      html-file]
-                     {:out :string :err :string})
+      (shell/command {:out :string :err :string}
+                     (chrome)
+                     "--headless"
+                     (str "--screenshot=" target-dir "/" github-id ".png")
+                     (str "--window-size=" (:image-width image-opts) ",125")
+                     "--default-background-color=0"
+                     "--hide-scrollbars"
+                     html-file)
       (finally
         (fs/delete-file-recursively (io/file html-file) true)))))
 

script/helper/env.clj

@@ -19,7 +19,7 @@
   []
   (let [min-version "1.10.1.697"
         version
-        (->> (shell/command ["clojure" "-Sdescribe"] {:out :string})
+        (->> (shell/command {:out :string} "clojure -Sdescribe")
              :out
              edn/read-string
              :version)]

script/helper/graal.clj

@@ -19,7 +19,7 @@
 
 (defn- assert-min-native-image-version [native-image-exe]
   (let [min-major 21
-        version-out (->> (shell/command [native-image-exe "--version"] {:out :string})
+        version-out (->> (shell/command {:out :string} native-image-exe "--version")
                          :out)
         actual-major (->> version-out
                           (re-find #"(?i)GraalVM (Version )?(\d+)\.")
@@ -34,7 +34,7 @@
   (status/line :head "Locate GraalVM native-image")
   (if-let [gu (find-gu-prog)]
     ;; its ok (and simpler and safer) to request an install of native-image when it is already installed
-    (do (shell/command [gu "install" "native-image"])
+    (do (shell/command gu "install" "native-image")
         (let [native-image (or (find-native-image-prog)
                                (status/die 1 "failed to install GraalVM native-image, check your GraalVM installation"))]
           (status/line :detail (str "found: " native-image))
@@ -54,22 +54,22 @@
 
 (defn aot-compile-sources [classpath ns]
   (status/line :head "AOT compile sources")
-  (shell/command ["java"
-                  "-Dclojure.compiler.direct-linking=true"
-                  "-cp" classpath
-                  "clojure.main"
-                  "-e" (str "(compile '" ns ")")]))
+  (shell/command "java"
+                 "-Dclojure.compiler.direct-linking=true"
+                 "-cp" classpath
+                 "clojure.main"
+                 "-e" (str "(compile '" ns ")")))
 
 (defn compute-classpath [base-alias]
   (status/line :head "Compute classpath")
   (let [alias-opt (str "-A:" base-alias)
-        classpath (-> (shell/command ["clojure" alias-opt "-Spath"] {:out :string})
+        classpath (-> (shell/command {:out :string} "clojure" alias-opt "-Spath")
                       :out
                       string/trim)]
     (println "\nClasspath:")
     (println (str "- " (string/join "\n- " (fs/split-path-list classpath))))
     (println "\nDeps tree:")
-    (shell/command ["clojure" alias-opt "-Stree"])
+    (shell/command "clojure" alias-opt "-Stree")
     classpath))
 
 (defn run-native-image [{:keys [:graal-native-image :graal-reflection-fname
@@ -109,4 +109,4 @@
                         :unix ["/usr/bin/time" "-v"]
                         (status/line :warn (str "I don't know how to get run stats (user/real/sys CPU, RAM use, etc) for a command on " os))))]
 
-    (shell/command (concat time-cmd native-image-cmd))))
+    (apply shell/command (concat time-cmd native-image-cmd))))