format ns loading and usable on node and jvm

Author: henryw374

cljs/java_time/util.clj

@@ -0,0 +1,9 @@
+(ns java-time.util)
+
+(defmacro static-prop [target prop]
+  `(goog.object/get ~target (str ~prop)))
+
+(defmacro static-call [target prop & args]
+  `((goog.object/get ~target (str ~prop)) ~@args))
+
+

dev/cljs_repl.clj

@@ -0,0 +1,13 @@
+ (ns cljs-repl)
+
+(require
+  '[cljs.repl :as cljs-repl]
+  '[cljs.repl.node :as node])
+
+(cljs-repl/repl* (node/repl-env)
+  {:output-dir "out"
+   :optimizations :none
+   :cache-analysis true
+   :source-map true})
+
+ 

project.clj

@@ -5,7 +5,10 @@
             :url "http://opensource.org/licenses/MIT"}
   :scm {:name "git"
         :url "http://github.com/dm3/clojure.java-time"}
-  :dependencies [[clj-tuple "0.2.2"]]
+  :dependencies [[clj-tuple "0.2.2"]
+                 [cljsjs/js-joda "1.6.2-0"]
+                 [org.clojure/clojurescript "1.9.946"]]
+  :source-paths ["src" "cljs"]
   :profiles {:dev {:dependencies [[org.clojure/clojure "1.8.0"]
                                   [criterium "0.4.4"]
                                   [com.taoensso/timbre "4.1.4"]

src/java_time/core.clj renamed to src/java_time/core.cljc

@@ -1,7 +1,16 @@
 (ns java-time.core
   (:refer-clojure :exclude (zero? range max min))
-  (:import [java.time.temporal ValueRange]
-           [java.time.chrono Chronology]))
+  #?(:clj
+     (:import [java.time.temporal ValueRange]
+       [java.time.chrono Chronology])
+     :cljs (:require [cljsjs.js-joda])
+     ))
+
+#?( :cljs (def ValueRange (.. js/JSJoda -ValueRange)))
+#?( :cljs (def Chronology (.. js/JSJoda -IsoChronology)))
+#?( :cljs (def Number js/Number))
+
+
 
 (defprotocol Amount
   (zero? [a]

src/java_time/format.clj renamed to src/java_time/format.cljc

@@ -2,22 +2,32 @@
   (:refer-clojure :exclude (format))
   (:require [clojure.string :as string]
             [java-time.core :as jt.c]
-            [java-time.util :as jt.u])
-  (:import [java.time.temporal TemporalAccessor]
-           [java.time.format DateTimeFormatter DateTimeFormatterBuilder ResolverStyle]))
+            [java-time.util :as jt.u :include-macros true])
+  #?(:clj (:import [java.time.temporal TemporalAccessor]
+       [java.time.format DateTimeFormatter DateTimeFormatterBuilder ResolverStyle])))
+
+#?(:cljs
+   (do
+     (def DateTimeFormatter (.. js/JSJoda -DateTimeFormatter))
+     (def ResolverStyle (.. js/JSJoda -ResolverStyle))))
+
+
+(def formatter-fields
+  #?(:clj (jt.u/get-static-fields-of-type DateTimeFormatter DateTimeFormatter)
+     :cljs (jt.u/get-fields-matching DateTimeFormatter #"ISO.*")))
 
 (def predefined-formatters
-  (->> (jt.u/get-static-fields-of-type DateTimeFormatter DateTimeFormatter)
+  (->> formatter-fields
        (jt.u/map-kv
          (fn [^String n fmt]
            [(string/lower-case (.replace n \_ \-)) fmt]))))
 
 (defn- get-resolver-style [s]
   (if (instance? ResolverStyle s) s
     (case s
-      :strict ResolverStyle/STRICT
-      :smart ResolverStyle/SMART
-      :lenient ResolverStyle/LENIENT)))
+      :strict (jt.u/static-prop ResolverStyle 'STRICT)
+      :smart (jt.u/static-prop ResolverStyle 'SMART)
+      :lenient (jt.u/static-prop ResolverStyle 'LENIENT))))
 
 (defn ^DateTimeFormatter formatter
   "Constructs a DateTimeFormatter out of a
@@ -33,7 +43,7 @@
   ([fmt {:keys [resolver-style]}]
    (let [^DateTimeFormatter fmt
          (cond (instance? DateTimeFormatter fmt) fmt
-               (string? fmt) (DateTimeFormatter/ofPattern fmt)
+               (string? fmt) (jt.u/static-call DateTimeFormatter 'ofPattern fmt)
                :else (get predefined-formatters (name fmt)))
          fmt (if resolver-style
                (.withResolverStyle fmt (get-resolver-style resolver-style))

src/java_time/seqs.clj renamed to src/java_time/seqs.cljc

@@ -0,0 +1,81 @@
+(ns java-time.util
+  (:require [clojure.string :as string]
+            #?@(:clj
+            [[java-time.util-macros]
+             [java-time.potemkin.namespaces :as potemkin]]))
+  #?(:clj
+     (:import [java.lang.reflect Field])))
+
+#?(:clj 
+   (potemkin/import-vars 
+     [java-time.util-macros static-prop static-call]))
+
+#?(:clj
+   (defn get-static-fields-of-type [^Class klass, ^Class of-type]
+     (->> (seq (.getFields klass))
+          (map (fn [^Field f]
+                 (when (.isAssignableFrom of-type (.getType f))
+                   [(.getName f) (.get f nil)])))
+          (keep identity)
+          (into {})))
+   :cljs 
+   (defn get-fields-matching [obj regex]
+     (->>
+       (js-keys obj)
+       (filter #(re-matches regex %))
+       (map #(vector % (goog.object/get obj %)))
+       (into {}))))
+
+(defn dashize [camelcase]
+  (let [words (re-seq #"([^A-Z]+|[A-Z]+[^A-Z]*)" camelcase)]
+    (string/join "-" (map (comp string/lower-case first) words))))
+
+
+#?(:clj
+   (defmacro if-threeten-extra [then-body else-body]
+     (if (try (Class/forName "org.threeten.extra.Temporals")
+              (catch Throwable e))
+       `(do ~then-body)
+       `(do ~else-body)))
+   :cljs (defn if-threeten-extra [] false))
+
+#?(:clj
+   (defmacro when-threeten-extra [& body]
+     (if (try (Class/forName "org.threeten.extra.Temporals")
+              (catch Throwable e))
+       `(do ~@body)))
+   :cljs (defn when-threeten-extra []))
+
+#?(:clj
+   (defmacro when-joda-time-loaded
+     "Execute the `body` when Joda-Time classes are found on the classpath.
+   
+     Take care - when AOT-compiling code using this macro, the Joda-Time classes
+     must be on the classpath at compile time!"
+     [& body]
+     (if (try (Class/forName "org.joda.time.DateTime")
+              (catch Throwable e))
+       `(do ~@body)))
+   :cljs (defn when-joda-time-loaded []))
+
+;; From Medley, C Weavejester
+(defn editable? [coll]
+  #?(:clj  (instance? clojure.lang.IEditableCollection coll)
+     :cljs (satisfies? cljs.core.IEditableCollection coll)))
+
+(defn reduce-map [f coll]
+  (if (editable? coll)
+    (persistent! (reduce-kv (f assoc!) (transient (empty coll)) coll))
+    (reduce-kv (f assoc) (empty coll) coll)))
+
+(defn map-vals
+  "Maps a function over the values of an associative collection."
+  [f coll]
+  (reduce-map (fn [xf] (fn [m k v] (xf m k (f v)))) coll))
+
+(defn map-kv
+  "Maps a function over the key/value pairs of an associate collection. Expects
+  a function that takes two arguments, the key and value, and returns the new
+  key and value as a collection of two elements."
+  [f coll]
+  (reduce-map (fn [xf] (fn [m k v] (let [[k v] (f k v)] (xf m k v)))) coll))

src/java_time/util.clj

@@ -0,0 +1,8 @@
+(ns java-time.util-macros)
+
+(defmacro static-prop [target prop]
+  `(. ~target ~(second prop)))
+
+(defmacro static-call [target prop & args]
+  `(. ~target ~(second
+                 prop) ~@args))