Nightcoders.net/prod.clj at master · ClojureBridgeAmsterdam/Nightcoders.net · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
(require
  '[clojure.java.io :as io]
  '[clojure.string :as str]
  '[cljs.build.api :as api]
  '[leiningen.core.project :as p :refer [defproject]]
  '[leiningen.clean :refer [clean]]
  '[leiningen.uberjar :refer [uberjar]])

(defn read-project-clj []
  (p/ensure-dynamic-classloader)
  (-> "project.clj" load-file var-get))

(defn read-deps-edn [aliases-to-include]
  (let [{:keys [paths deps aliases]} (-> "deps.edn" slurp clojure.edn/read-string)
        deps (->> (select-keys aliases aliases-to-include)
                  vals
                  (mapcat :extra-deps)
                  (into deps)
                  (map (fn parse-coord [coord]
                         (let [[artifact info] coord
                               s (str artifact)]
                           (if-let [i (str/index-of s "$")]
                             [(symbol (subs s 0 i))
                              (assoc info :classifier (subs s (inc i)))]
                             coord))))
                  (reduce
                    (fn [deps [artifact info]]
                      (if-let [version (:mvn/version info)]
                        (conj deps
                          (transduce cat conj [artifact version]
                            (select-keys info [:exclusions :classifier])))
                        deps))
                    []))
        paths (->> (select-keys aliases aliases-to-include)
                   vals
                   (mapcat :extra-paths)
                   (into paths))]
    {:dependencies deps
     :source-paths []
     :resource-paths paths}))

(defn delete-children-recursively! [f]
  (when (.isDirectory f)
    (doseq [f2 (.listFiles f)]
      (delete-children-recursively! f2)))
  (when (.exists f) (io/delete-file f)))

(defn build-cljs [file-name opts]
  (let [out-file (str "resources/public/" file-name ".js")
        out-dir (str "resources/public/" file-name ".out")]
    (println "Building" out-file)
    (delete-children-recursively! (io/file out-dir))
    (api/build "src" (merge
                       {:output-to     out-file
                        :output-dir    out-dir}
                       opts))
    (delete-children-recursively! (io/file out-dir))))

(defmulti task first)

(defmethod task :default
  [_]
  (let [all-tasks  (-> task methods (dissoc :default) keys sort)
        interposed (->> all-tasks (interpose ", ") (apply str))]
    (println "Unknown or missing task. Choose one of:" interposed)
    (System/exit 1)))

(defmethod task "uberjar"
  [_]
  (build-cljs "nightcoders"
              {:main          'nightcoders.core
               :optimizations :advanced})
  (build-cljs "loading"
              {:main          'nightcoders.loading
               :optimizations :advanced})
  (let [project (-> (read-project-clj)
                    (merge (read-deps-edn []))
                    (assoc
                      :aot '[nightcoders.core]
                      :main 'nightcoders.core)
                    p/init-project)]
    (clean project)
    (uberjar project)))

;; entry point

(task *command-line-args*)