lasagna-pattern/bb.edn at main · flybot-sg/lasagna-pattern · 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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
{:min-bb-version "1.0.0"
 :tasks
 {:requires [[babashka.fs :as fs]
             [clojure.string :as str]
             [clojure.edn :as edn]]

  -comp-task?
  {:task (fn [dir task]
           (let [{:keys [out]} (shell {:dir dir :out :string :continue true} "bb" "tasks")
                 pattern (re-pattern (str "^" task "\\s"))]
             (some (fn [line] (re-find pattern line)) (str/split-lines out))))}

  -load-env
  {:task (fn [dir]
           (let [env-file (fs/file dir ".env")
                 base-env (into {} (System/getenv))
                 dotenv (when (fs/exists? env-file)
                          (println (str "Loading .env from " dir))
                          (->> (slurp env-file)
                               str/split-lines
                               (remove (fn [line] (or (str/blank? line) (str/starts-with? line "#"))))
                               (map (fn [line] (str/split line (re-pattern "=") 2)))
                               (filter (fn [parts] (= 2 (count parts))))
                               (into {})))]
             (merge base-env dotenv)))}

  -components
  {:task (vec (concat
               (for [dir (fs/list-dir ".")
                     :let [dir-name (str (fs/file-name dir))]
                     :when (and (fs/directory? dir)
                                (not (str/starts-with? dir-name "."))
                                (not= dir-name "examples")
                                (fs/exists? (fs/file dir "deps.edn")))]
                 dir-name)
               (when (fs/exists? "examples")
                 (for [dir (fs/list-dir "examples")
                       :let [path (str "examples/" (fs/file-name dir))]
                       :when (and (fs/directory? dir)
                                  (fs/exists? (fs/file path "deps.edn")))]
                   path))))}

  list
  {:doc "List all components"
   :depends [-components]
   :task (doseq [c -components] (println c))}

  rct
  {:doc "Run RCT: bb rct [component]"
   :depends [-components -comp-task?]
   :task (let [target (first *command-line-args*)
               components (if target [target] -components)]
           (doseq [c components]
             (println (str "\n=== " c " ==="))
             (if (-comp-task? c "rct")
               (shell {:dir c} "bb" "rct")
               (clojure {:dir c} "-X:dev:rct"))))}

  test
  {:doc "Run tests (kaocha): bb test [component]"
   :depends [-components -comp-task?]
   :task (let [target (first *command-line-args*)
               components (if target [target] -components)]
           (doseq [c components]
             (println (str "\n=== " c " ==="))
             (if (-comp-task? c "test")
               (shell {:dir c} "bb" "test")
               (clojure {:dir c} "-M:dev:kaocha"))))}

  dev
  {:doc "Start REPL: bb dev <component>"
   :depends [-comp-task? -load-env]
   :task (if-let [component (first *command-line-args*)]
           (let [env (-load-env component)]
             (if (-comp-task? component "dev")
               (shell {:dir component :env env} "bb" "dev")
               (clojure {:dir component :env env} "-M:dev" "-m" "nrepl.cmdline" "--middleware" "[cider.nrepl/cider-middleware]")))
           (println "Usage: bb dev <component>"))}

  outdated
  {:doc "Check outdated deps: bb outdated [component]"
   :depends [-components]
   :task (let [target (first *command-line-args*)
               dirs (if target [target] (cons "." -components))]
           (doseq [d dirs]
             (println (str "\n=== " (if (= d ".") "root" d) " ==="))
             (clojure {:dir d :continue true}
                      "-Sdeps" "{:deps {com.github.liquidz/antq {:mvn/version \"RELEASE\"}}}"
                      "-M" "-m" "antq.core")))}

  clean
  {:doc "Clean: bb clean [component]"
   :depends [-components]
   :task (let [target (first *command-line-args*)
               components (if target [target] -components)]
           (doseq [c components]
             (println (str "Cleaning " c "..."))
             (shell {:dir c} "rm" "-rf" "target" ".cpcache" ".shadow-cljs")))}

  serve
  {:doc "Serve static UI: bb serve <component>"
   :depends [-comp-task?]
   :task (if-let [component (first *command-line-args*)]
           (if (-comp-task? component "serve")
             (shell {:dir component} "bb" "serve")
             (println (str "Component " component " has no 'serve' task")))
           (println "Usage: bb serve <component>"))}

  server
  {:doc "Start backend server: bb server <component>"
   :depends [-comp-task?]
   :task (if-let [component (first *command-line-args*)]
           (if (-comp-task? component "server")
             (shell {:dir component} "bb" "server")
             (println (str "Component " component " has no 'server' task")))
           (println "Usage: bb server <component>"))}

  jar
  {:doc "Build JAR: bb jar <component>"
   :depends [-comp-task?]
   :task (if-let [component (first *command-line-args*)]
           (if (-comp-task? component "jar")
             (shell {:dir component} "bb" "jar")
             (clojure {:dir component} "-T:build jar"))
           (println "Usage: bb jar <component>"))}

  install
  {:doc "Install to local Maven: bb install <component>"
   :depends [-comp-task?]
   :task (if-let [component (first *command-line-args*)]
           (if (-comp-task? component "install")
             (shell {:dir component} "bb" "install")
             (clojure {:dir component} "-T:build install"))
           (println "Usage: bb install <component>"))}

  deploy
  {:doc "Deploy component: bb deploy <component>"
   :depends [-comp-task? -load-env]
   :task (if-let [component (first *command-line-args*)]
           (if (-comp-task? component "deploy")
             (shell {:dir component :env (-load-env component)} "bb" "deploy")
             (clojure {:dir component} "-T:build deploy"))
           (println "Usage: bb deploy <component>"))}

  tag
  {:doc "Create release tag: bb tag <component>"
   :task (let [[component] *command-line-args*]
           (if component
             (let [comp-name (last (str/split component (re-pattern "/")))
                   version-file (fs/file component "resources" "version.edn")
                   version (when (fs/exists? version-file)
                             (:version (edn/read-string (slurp (str version-file)))))]
               (if version
                 (let [tag (str comp-name "-v" version)]
                   (println "Creating tag:" tag)
                   (shell "git" "tag" "-a" tag "-m" (str "Release " comp-name " " version))
                   (println "Pushing tag to origin...")
                   (shell "git" "push" "origin" tag)
                   (println (str "Done! CI/CD will deploy " component " with tag " tag)))
                 (println "Error: No resources/version.edn found in" component)))
             (do
               (println "Usage: bb tag <component>")
               (println "Example: bb tag examples/flybot-site")
               (println "")
               (println "Reads version from resources/version.edn, creates and pushes the tag."))))}}}