bb.edn

{:tasks {cp
         
         {:doc  "Print the classpath"
          :task (do
                  (println "Computing and printing classpath...\n")
                  (doseq [line (sort (clojure.string/split (cp-string)
                                                           (re-pattern ":")))]
                    (println line)))}



         cp:del

         {:doc  "Delete cached classpath"
          :task (fs/delete-tree ".cpcache")}



         deploy

         {:depends [jar]
          :doc     "Deploy this project to Clojars ; need username and path to file with Clojars token"
          :task    (clojure {:extra-env {"CLOJARS_USERNAME" (first *command-line-args*)
                                         "CLOJARS_PASSWORD" (slurp (second *command-line-args*))}}
                            "-X:deploy")}



         dev:clojure

         {:doc  "Start Clojure JVM dev environment (NREPL on port 14563)"
          :task (clojure "-M:dev:test:nrepl")}



         dev:cljs

         {:doc  "Start CLJS dev environment (NREPL on port 14563, server on port 8000)"
          :task (clojure "-M:cljs:dev:test watch dev")}

        

         fcss:release

         {:doc  ""
          :task (clojure {:extra-env {"FCSS_MODE" :release}}
                         "-M:cljs:dev release release")}



         fcss:release-report

         {:doc  "Like 'fcss:release' but generates a Shadow-CLJS report"
          :task (clojure {:extra-env {"FCSS_MODE" :release}}
                         "-M:cljs:dev run shadow.cljs.build-report release fcss/optimized/shadow_report.html")}



         fcss:optimize

         {:doc  ""
          :task (clojure "-X:fcss-optimize")}



         install

         {:depends [jar]
          :doc     "Install jar to local Maven repo"
          :task    (clojure "-X:install")}



         jar

         {:doc  "Build a jar for this project"
          :task (clojure "-X:jar")}



         lint

         {:doc "Start Clj-kondo on './src' (further path can be provided as command-line argument)"
          :task (shell (str "clj-kondo --lint src/"
                                               (first *command-line-args*)))}



         lint:import

         {:doc  "Initialize Clj-kondo and copy configuration files from dependencies"
          :task (shell (format "clj-kondo --lint '%s' --dependencies --parallel --copy-configs"
                               (cp-string)))}



         pom

         {:doc  "Sync POM file with 'deps.edn'"
          :task (clojure "-Spom")}



         shadow:clean

         {:doc  "Remove the given profile from Shadow-CLJS cache (for full recompilation)"
          :task (shadow-clean (first *command-line-args*))}



         shadow:clean-test

         {:doc  "Like 'shadow:clean' but for the ':test-node' profile"
          :task (shadow-clean "test-node")}



         test:jvm

         {:doc  "Run tests on the JVM once ; accepts Kaocha CLI arguments"
          :task (test-jvm nil)}



         test:jvm:watch

         {:doc "Run tests on the JVM everytime a file is changed ; accepts Kaocha CLI arguments"
          :task (test-jvm ["--watch"])}



         test:node

         {:doc  "Run tests on NodeJS after unoptimized compilation"
          :task (test-node false)}



         test:node:optimize

         {:doc  "Run tests on NodeJS after advanced compilation"
          :task (test-node true)}



         :requires ([babashka.fs :as fs])



         :init

         (do
           (defn cp-string

             ;; Returns the classpath as a string, reading profiles from CLI args.

             []

             (with-out-str (clojure (str "-Spath "
                                         (when (some? *command-line-args*)
                                           (str "-A"
                                                (clojure.string/join ""
                                                                     *command-line-args*)))))))



           (defn shadow-clean
             
             ;; Deletes a Shadow-CLJS profile.

             [profile]

             (when (empty? profile)
               (println "A Shadow-CLJS profile must be provided.")
               (System/exit 42))
             (fs/delete-tree (str ".shadow-cljs/builds/"
                                  profile)))



           (defn test-jvm

             ;; Concats CLI args with the given ones.

             [arg+]

             (clojure (str "-M:kaocha:test -m kaocha.runner --config-file kaocha.edn :jvm "
                           (clojure.string/join " "
                                                (concat arg+
                                                        *command-line-args*)))))

           (defn test-node

             [optimize?]

             (clojure (format "-M:cljs:test %s test-node"
                              (if optimize?
                                "release"
                                "compile")))
             (shell "node ./compiled/node/test.js"))

           )}}