Merge pull request #185 from arichiardi/self-host-w-macrovich

Add ClojureScript self-host support

project.clj

@@ -5,7 +5,8 @@
   :url "https://github.com/jkk/honeysql"
   :scm {:name "git"
         :url "https://github.com/jkk/honeysql"}
-  :dependencies [[org.clojure/clojure "1.8.0"]]
+  :dependencies [[org.clojure/clojure "1.8.0"]
+                 [net.cgrand/macrovich "0.2.0"]]
   :aliases {"test-readme" ["with-profile" "midje" "midje"]}
   :cljsbuild {:builds {:release {:source-paths ["src"]
                                  :compiler {:output-to "dist/honeysql.js"
@@ -21,6 +22,8 @@
                                          :parallel-build true
                                          :target :nodejs}}}}
   :doo {:build "test"}
+  :tach {:test-runner-ns 'honeysql.self-host-runner
+         :source-paths ["src" "test"]}
   :profiles {:midje {:dependencies [[midje "1.9.0-alpha5"]]
                      :plugins      [[lein-midje "3.2.1"]
                                     [midje-readme "1.0.9"]]
@@ -33,4 +36,5 @@
                                   [cljsbuild "1.1.6"]]
                    :plugins [[lein-cljsbuild "1.1.6"]
                              [jonase/eastwood "0.2.4"]
-                             [lein-doo "0.1.6"]]}})
+                             [lein-doo "0.1.6"]
+                             [lein-tach "0.4.0"]]}})

src/honeysql/helpers.cljc

@@ -1,6 +1,8 @@
 (ns honeysql.helpers
   (:refer-clojure :exclude [update])
-  #?(:cljs (:require-macros [honeysql.helpers :refer [defhelper]])))
+  #?(:clj (:require [net.cgrand.macrovich :as macros])
+     :cljs (:require-macros [net.cgrand.macrovich :as macros]
+                            [honeysql.helpers :refer [defhelper]])))
 
 (defmulti build-clause (fn [name & args]
                          name))
@@ -13,48 +15,56 @@
     (map? m)
     (not (record? m))))
 
-#?(:clj
+(macros/deftime
-    (defmacro defhelper [helper arglist & more]
+  (defmacro defhelper [helper arglist & more]
-      (when-not (vector? arglist)
+    (when-not (vector? arglist)
-        (throw (IllegalArgumentException. "arglist must be a vector")))
+      (throw #?(:clj (IllegalArgumentException. "arglist must be a vector")
-      (when-not (= (count arglist) 2)
+                :cljs (js/Error. "arglist must be a vector"))))
-        (throw (IllegalArgumentException. "arglist must have two entries, map and varargs")))
+    (when-not (= (count arglist) 2)
-      (let [kw (keyword (name helper))
+      (throw #?(:clj (IllegalArgumentException. "arglist must have two entries, map and varargs")
-            [m-arg varargs] arglist]
+                :cljs (js/Error. "arglist must have two entries, map and varargs"))))
-        `(do
-           (defmethod build-clause ~kw ~['_ m-arg varargs] ~@more)
-           (defn ~helper [& args#]
-             (let [[m# args#] (if (plain-map? (first args#))
-                                [(first args#) (rest args#)]
-                                [{} args#])]
-               (build-clause ~kw m# args#)))
 
-           ;; maintain the original arglist instead of getting
+    (let [kw (keyword (name helper))
-           ;; ([& args__6880__auto__])
+          [m-arg varargs] arglist]
-           (alter-meta!
+      `(do
-             (var ~helper)
+         (defmethod build-clause ~kw ~['_ m-arg varargs] ~@more)
-             assoc
+         (defn ~helper [& args#]
-             :arglists
+           (let [[m# args#] (if (plain-map? (first args#))
-             '(~['& varargs]
+                              [(first args#) (rest args#)]
-               ~[m-arg '& varargs]))))))
+                              [{} args#])]
+             (build-clause ~kw m# args#)))
+
+         ;; maintain the original arglist instead of getting
+         ;; ([& args__6880__auto__])
+         (alter-meta!
+          (var ~helper)
+          assoc
+          :arglists
+          '(~['& varargs]
+            ~[m-arg '& varargs]))))))
 
 (defn collify [x]
   (if (coll? x) x [x]))
 
-(defhelper select [m fields]
+(macros/usetime
-  (assoc m :select (collify fields)))
+ (defhelper select [m fields]
+   (assoc m :select (collify fields))))
 
-(defhelper merge-select [m fields]
+(macros/usetime
-  (update-in m [:select] concat (collify fields)))
+ (defhelper merge-select [m fields]
+   (update-in m [:select] concat (collify fields))))
 
-(defhelper un-select [m fields]
+(macros/usetime
-  (update-in m [:select] #(remove (set (collify fields)) %)))
+ (defhelper un-select [m fields]
+   (update-in m [:select] #(remove (set (collify fields)) %))))
 
-(defhelper from [m tables]
+(macros/usetime
-  (assoc m :from (collify tables)))
+ (defhelper from [m tables]
+   (assoc m :from (collify tables))))
 
-(defhelper merge-from [m tables]
+(macros/usetime
-  (update-in m [:from] concat (collify tables)))
+ (defhelper merge-from [m tables]
+   (update-in m [:from] concat (collify tables))))
 
 (defmethod build-clause :where [_ m pred]
   (if (nil? pred)
@@ -94,29 +104,37 @@
                         [logic-op (:where m) pred]
                         pred)))))
 
-(defhelper join [m clauses]
+(macros/usetime
-  (assoc m :join clauses))
+ (defhelper join [m clauses]
+   (assoc m :join clauses)))
 
-(defhelper merge-join [m clauses]
+(macros/usetime
-  (update-in m [:join] concat clauses))
+ (defhelper merge-join [m clauses]
+   (update-in m [:join] concat clauses)))
 
-(defhelper left-join [m clauses]
+(macros/usetime
-  (assoc m :left-join clauses))
+ (defhelper left-join [m clauses]
+   (assoc m :left-join clauses)))
 
-(defhelper merge-left-join [m clauses]
+(macros/usetime
-  (update-in m [:left-join] concat clauses))
+ (defhelper merge-left-join [m clauses]
+   (update-in m [:left-join] concat clauses)))
 
-(defhelper right-join [m clauses]
+(macros/usetime
-  (assoc m :right-join clauses))
+ (defhelper right-join [m clauses]
+   (assoc m :right-join clauses)))
 
-(defhelper merge-right-join [m clauses]
+(macros/usetime
-  (update-in m [:right-join] concat clauses))
+ (defhelper merge-right-join [m clauses]
+   (update-in m [:right-join] concat clauses)))
 
-(defhelper full-join [m clauses]
+(macros/usetime
-  (assoc m :full-join clauses))
+ (defhelper full-join [m clauses]
+   (assoc m :full-join clauses)))
 
-(defhelper merge-full-join [m clauses]
+(macros/usetime
-  (update-in m [:full-join] concat clauses))
+ (defhelper merge-full-join [m clauses]
+   (update-in m [:full-join] concat clauses)))
 
 (defmethod build-clause :group-by [_ m fields]
   (assoc m :group-by (collify fields)))
@@ -127,8 +145,9 @@
                      [{} args])]
     (build-clause :group-by m fields)))
 
-(defhelper merge-group-by [m fields]
+(macros/usetime
-  (update-in m [:group-by] concat (collify fields)))
+ (defhelper merge-group-by [m fields]
+   (update-in m [:group-by] concat (collify fields))))
 
 (defmethod build-clause :having [_ m pred]
   (if (nil? pred)
@@ -156,36 +175,43 @@
                          [logic-op (:having m) pred]
                          pred)))))
 
-(defhelper order-by [m fields]
+(macros/usetime
-  (assoc m :order-by (collify fields)))
+ (defhelper order-by [m fields]
+   (assoc m :order-by (collify fields))))
 
-(defhelper merge-order-by [m fields]
+(macros/usetime
-  (update-in m [:order-by] concat (collify fields)))
+ (defhelper merge-order-by [m fields]
+   (update-in m [:order-by] concat (collify fields))))
 
-(defhelper limit [m l]
+(macros/usetime
-  (if (nil? l)
+ (defhelper limit [m l]
-    m
+   (if (nil? l)
-    (assoc m :limit (if (coll? l) (first l) l))))
+     m
+     (assoc m :limit (if (coll? l) (first l) l)))))
 
-(defhelper offset [m o]
+(macros/usetime
-  (if (nil? o)
+ (defhelper offset [m o]
-    m
+   (if (nil? o)
-    (assoc m :offset (if (coll? o) (first o) o))))
+     m
+     (assoc m :offset (if (coll? o) (first o) o)))))
 
-(defhelper lock [m lock]
+(macros/usetime
-  (cond-> m
+ (defhelper lock [m lock]
-          lock
+   (cond-> m
-          (assoc :lock lock)))
+     lock
+     (assoc :lock lock))))
 
-(defhelper modifiers [m ms]
+(macros/usetime
-  (if (nil? ms)
+ (defhelper modifiers [m ms]
-    m
+   (if (nil? ms)
-    (assoc m :modifiers (collify ms))))
+     m
+     (assoc m :modifiers (collify ms)))))
 
-(defhelper merge-modifiers [m ms]
+(macros/usetime
-  (if (nil? ms)
+ (defhelper merge-modifiers [m ms]
-    m
+   (if (nil? ms)
-    (update-in m [:modifiers] concat (collify ms))))
+     m
+     (update-in m [:modifiers] concat (collify ms)))))
 
 (defmethod build-clause :insert-into [_ m table]
   (assoc m :insert-into table))
@@ -194,11 +220,13 @@
   ([table] (insert-into nil table))
   ([m table] (build-clause :insert-into m table)))
 
-(defhelper columns [m fields]
+(macros/usetime
-  (assoc m :columns (collify fields)))
+ (defhelper columns [m fields]
+   (assoc m :columns (collify fields))))
 
-(defhelper merge-columns [m fields]
+(macros/usetime
-  (update-in m [:columns] concat (collify fields)))
+ (defhelper merge-columns [m fields]
+   (update-in m [:columns] concat (collify fields))))
 
 (defmethod build-clause :values [_ m vs]
   (assoc m :values vs))
@@ -243,11 +271,13 @@
   ([table] (delete-from nil table))
   ([m table] (build-clause :delete-from m table)))
 
-(defhelper with [m ctes]
+(macros/usetime
-  (assoc m :with ctes))
+ (defhelper with [m ctes]
+   (assoc m :with ctes)))
 
-(defhelper with-recursive [m ctes]
+(macros/usetime
-  (assoc m :with-recursive ctes))
+ (defhelper with-recursive [m ctes]
+   (assoc m :with-recursive ctes)))
 
 (defmethod build-clause :union [_ m maps]
   (assoc m :union maps))

test/honeysql/self_host_runner.cljs

@@ -0,0 +1,9 @@
+(ns honeysql.self-host-runner
+  (:require [cljs.test :as t :refer-macros [run-tests]]
+            honeysql.core-test
+            honeysql.format-test))
+
+(enable-console-print!)
+
+(run-tests 'honeysql.core-test
+           'honeysql.format-test)