bb.edn

{:min-bb-version "1.12.194"

 :deps {babashka/fs {:mvn/version "0.5.22"}}

 :tasks
 {:requires ([babashka.fs :as fs]
             [babashka.process :as process]
             [clojure.pprint :as pprint]
             [clojure.string :as str])

  :init (do
          (def -zone-id (java.time.ZoneId/of "UTC"))
          (def -formatter java.time.format.DateTimeFormatter/ISO_OFFSET_DATE_TIME)
          (def -timestamp (.format (java.time.ZonedDateTime/now -zone-id) -formatter))

          (defn execute
            [cmd]
            (some->> cmd
                     (process/tokenize)
                     (process/process)
                     :out
                     (slurp)
                     (str/trim-newline)))

          (defn pretty-print
            ([x]
             (pretty-print x {}))
            ([x {:keys [right-margin]
                 :or   {right-margin 80}}]
             (binding [*print-namespace-maps* false
                       pprint/*print-right-margin* right-margin]
               (pprint/pprint x))))

          (def -organization "lazy-cat-io")
          (def -repository "tenet")
          (def -lib "io.lazy-cat/tenet")
          (def -branch (-> (execute "git rev-parse --abbrev-ref HEAD") (str/lower-case)))
          (def -commit (-> (execute "git rev-parse --short HEAD") (str/lower-case)))
          (def -git-count-revs (-> (execute "git rev-list HEAD --count")))

          (def -deployable?
            (= "main" -branch))

          (def -version
            (-> "version.tmpl"
                (slurp)
                (str/trim-newline)
                (str/replace "{{ git-count-revs }}" -git-count-revs)))

          (def -meta
            {:organization -organization
             :repository -repository
             :branch -branch
             :commit -commit
             :version -version
             :timestamp -timestamp}))

  :enter (let [{:keys [doc print-doc?]
                :or   {print-doc? true}} (current-task)]
           (when (and print-doc? doc)
             (println (format "\n▸ [%s v%s] %s" -lib -version doc))))

  ;;
  ;; Tasks
  ;;

  version {:doc "Show version"
           :print-doc? false
           :override-builtin true
           :task (println -version)}

  setup {:doc  "Setup dependencies"
         :task (shell "npm ci")}

  outdated {:doc "Check for outdated dependencies"
            :task (case (some-> *command-line-args* first str/lower-case)
                    "upgrade" (shell "clojure -M:nop:outdated --main antq.core --upgrade --force")
                    (shell "clojure -M:nop:outdated --main antq.core"))}

  clean {:doc "Run cleanup"
         :task (doseq [dir ["target" "coverage" "out" ".cljs_node_repl"]]
                 (println (format "Removing %s..." dir))
                 (fs/delete-tree dir))}

  lint {:doc "Run linters"
        :task (case (some-> *command-line-args* first str/lower-case)
                "fix" (shell "cljfmt fix src")
                (do
                  (shell "cljfmt check src")
                  (shell "clj-kondo --lint src")))}

  repl {:doc "Run nREPL"
        :override-builtin true
        :depends [clean -build:meta]
        :task (shell "clj -M:bench:test:develop --main nrepl.cmdline --interactive --middleware '[cider.nrepl/cider-middleware,cider.piggieback/wrap-cljs-repl]'")}

  -test:bb {:doc "Run babashka tests"
            :task (shell "./src/test/bb/runner.clj")}
  -test:clj {:doc "Run clojure tests"
             :task (shell "clojure -M:nop:test --main kaocha.runner --focus :clojure")}
  -test:cljs {:doc "Run clojurescript tests"
              :task (shell "clojure -M:nop:test --main kaocha.runner --focus :clojurescript")}
  -test:all {:task (do
                     (shell "clojure -M:nop:test --main kaocha.runner")
                     (run '-test:bb))}

  test {:doc "Run tests"
        :depends [clean]
        :task (case (some-> *command-line-args* first str/lower-case)
                "all" (run '-test:all)
                "bb" (run 'test:bb)
                "clj" (run 'test:clj)
                "cljs" (run 'test:cljs)
                (shell (str/join \space (into ["clojure -M:nop:test --main kaocha.runner"] *command-line-args*))))}

  -build:meta {:doc "Build metadata"
               :task (do
                       (fs/create-dirs "src/main/resources/io/lazy-cat/tenet")
                       (->> -meta
                            (pretty-print)
                            (with-out-str)
                            (spit "src/main/resources/io/lazy-cat/tenet/meta.edn")))}

  -build:jar {:doc "Build jar"
              :depends [clean -build:meta]
              :task (shell (format "clojure -T:build jar :version '\"%s\"'" -version))}

  build {:doc "Run build"
         :print-doc? false
         :task (case (some-> *command-line-args* first str/lower-case)
                 "meta" (run '-build:meta)
                 "jar" (run '-build:jar)
                 (run '-build:jar))}

  install {:doc "Install jar"
           :depends [-build:jar]
           :task (shell "clojure -T:build install")}

  deploy {:doc "Deploy jar"
          :task (if-not -deployable?
                  (do
                    (println "Allowed branches: main, develop")
                    (println (format "Current branch: %s" -branch)))
                  (do
                    (run '-build:jar)
                    (shell "clojure -T:build deploy")))}}}