bb.edn

{:min-bb-version "1.3.188"

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

 :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 os (System/getProperty "os.name"))
          (def windows? (str/starts-with? os "Windows"))
          (def macos? (str/starts-with? os "Mac"))
          (def linux? (str/starts-with? os "Linux"))

          (def java-home (System/getenv "JAVA_HOME"))
          (def graalvm-home (or (System/getenv "GRAALVM_HOME") java-home))
          (def gu (str (fs/file graalvm-home "bin" "gu")))
          (def native-image (str (fs/file graalvm-home "bin" "native-image")))

          (def organization "lazy-cat-io")
          (def repository "xdeps")
          (def lib "io.lazy-cat/xdeps")
          (def version (-> "version" (slurp) (str/trim-newline)))
          (def branch (execute "git rev-parse --abbrev-ref HEAD"))
          (def commit (execute "git rev-parse --short HEAD"))

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

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

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

  lint {:doc "Run linters"
        :task (case (first *command-line-args*)
                "fix" (do
                        (shell "clojure-lsp format")
                        (shell "clojure-lsp clean-ns"))
                (do
                  (shell "clojure-lsp format --dry")
                  (shell "clojure-lsp diagnostics")))}

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

  clean {:doc "Run cleanup"
         :task (doseq [dir ["target" "coverage"]]
                 (fs/delete-tree dir))}

  test {:doc "Run tests"
        :task (case (first *command-line-args*)
                "unit" (shell "clojure -M:nop:test --main kaocha.runner --focus :unit")
                "integration" (shell "clojure -M:nop:test --main kaocha.runner --focus :integration")
                (shell (str/join \space (into ["clojure -M:nop:test --main kaocha.runner"] *command-line-args*))))}

  run {:doc "Run application"
       :depends [clean -build:meta]
       :print-doc? false
       :override-builtin true
       :task (apply shell "clojure -M -m xdeps.main" *command-line-args*)}

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

  -build:uberjar {:doc "Build uberjar"
                  :depends [clean -build:meta]
                  :task (shell "clojure -T:build uberjar")}

  -build:native-image {:doc "Build native image"
                       :task (let [static? (and linux? (boolean (some #{"static"} *command-line-args*)))
                                   env (if macos? {"MACOSX_DEPLOYMENT_TARGET" "10.13"} {})
                                   args (cond-> ["-jar" "target/xdeps.jar"
                                                 "-H:Name=xdeps"
                                                 "-H:Path=target"
                                                 "-H:IncludeResources=io/lazy-cat/*"
                                                 "-H:+ReportExceptionStackTraces"
                                                 "-J-Dclojure.compiler.direct-linking=true"
                                                 "-J-Dclojure.spec.skip-macros=true"
                                                 "--enable-preview"
                                                 "--features=clj_easy.graal_build_time.InitClojureClasses"
                                                 "--install-exit-handlers"
                                                 "--native-image-info"
                                                 "--no-fallback"
                                                 "--no-server"]
                                          static? (conj "--static" "--libc=musl"))]
                               (println "Static:" static?)
                               (shell gu "install" "native-image")
                               (apply shell env native-image args))}

  build {:doc "Run build"
         :print-doc? false
         :task (case (first *command-line-args*)
                 "meta" (run '-build:meta)
                 "uberjar" (run '-build:uberjar)
                 "native-image" (run '-build:native-image)
                 (do
                   (run '-build:uberjar)
                   (run '-build:native-image)))}}}