Data readers for tagged literals split into code and data related handlers

Author: siefca

resources/io/randomseed/bankster/bankster_data_readers.clj

@@ -1,3 +1,3 @@
-{currency io.randomseed.bankster.currency/lit,
- money io.randomseed.bankster.money/lit,
- money/crypto io.randomseed.bankster.money/lit-crypto}
+{currency io.randomseed.bankster.currency/code-literal,
+ money io.randomseed.bankster.money/code-literal,
+ money/crypto io.randomseed.bankster.money/code-literal-crypto}

src/data_readers.clj

@@ -1,3 +1,3 @@
-{currency io.randomseed.bankster.currency/lit,
- money io.randomseed.bankster.money/lit,
- money/crypto io.randomseed.bankster.money/lit-crypto}
+{currency io.randomseed.bankster.currency/code-literal,
+ money io.randomseed.bankster.money/code-literal,
+ money/crypto io.randomseed.bankster.money/code-literal-crypto}

src/data_readers.cljc

@@ -0,0 +1,3 @@
+{currency io.randomseed.bankster.currency/data-literal,
+ money io.randomseed.bankster.money/data-literal,
+ money/crypto io.randomseed.bankster.money/data-literal-crypto}

src/data_readers_edn.clj

@@ -493,10 +493,10 @@
   registry/with or with-registry)."
   {:added "1.0.0"}
   ([currency]
-   (let [cur# (parse-currency-code currency)]
+   (let [cur# (parse-currency-code currency &env)]
      `(unit ~cur#)))
   ([currency registry]
-   (let [cur# (parse-currency-code currency)]
+   (let [cur# (parse-currency-code currency &env)]
      `(unit ~cur# ~registry))))
 
 ;;
@@ -1544,15 +1544,25 @@
      ~@body))
 
 ;;
-;; Tagged literal handler.
+;; Tagged literals.
 ;;
 
-(defn lit
-  "Tagged literal handler."
-  {:added "1.0.0"}
+(defn code-literal
+  "Tagged literal handler for Clojure code. Emits compound forms that are going to be
+  evaluated."
+  {:added "1.2.4"}
+  [arg]
+  (if (or (nil? arg) (and (map? arg) (< (count arg) 1)))
+    '(quote nil)
+    `(of ~arg)))
+
+(defn data-literal
+  "Tagged literal handler for EDN data files. Emits Currency objects or nil values."
+  {:added "1.2.4"}
   [arg]
   (if (or (nil? arg) (and (map? arg) (< (count arg) 1)))
-    '(quote nil) (unit arg)))
+    '(quote nil)
+    (of arg)))
 
 ;;
 ;; Formatting.

src/io/randomseed/bankster/currency.clj

@@ -10,6 +10,7 @@
                             pos? neg? zero?])
 
   (:require [clojure.string]
+            [clojure.edn]
             [trptr.java-wrapper.locale       :as             l]
             [io.randomseed.bankster          :refer       :all]
             [io.randomseed.bankster.scale    :as         scale]
@@ -2015,18 +2016,49 @@
 ;; Tagged literals.
 ;;
 
-(defn lit
-  "Tagged literal handler."
-  {:added "1.0.0" :no-doc true}
-  ([arg]
-   (let [[c amount r] (if (sequential? arg) arg [arg nil nil])]
-     (if (or (nil? c) (and (sequential? c) (nil? (seq c))))
-       '(quote nil)
-       (if (nil? amount)
-         (of-gen parse c)
-         (if (nil? r)
-           (of-gen parse c amount)
-           (of-gen parse c amount r)))))))
+(defn lit-parse
+  "Internal pre-parser for tagged literals. Takes a parsing function and arguments
+  in decomposed form."
+  {:added "1.2.4" :private true}
+  ([a]
+   (of-gen parse a))
+  ([a b]
+   (if (nil? b)
+     (of-gen parse a)
+     (of-gen parse a b)))
+  ([a b r]
+   (if (nil? r)
+     (if (nil? b)
+       (lit-parse a)
+       (lit-parse a b))
+     (of-gen parse a b r))))
+
+(defn code-literal
+  "Tagged literal handler for Money objects expressed as tagged literals in Clojure
+  code. Returns compound forms (parsing function invocations that can be influenced
+  by the runtime environment, e.g. dynamic variables like scale/*rounding-mode*)."
+  {:added "1.2.4"}
+  [arg]
+  (if (nil? arg)
+    (lit-parse nil)
+    (if (sequential? arg)
+      (apply lit-parse (take 3 arg))
+      (if (map? arg)
+        (lit-parse (:currency arg)
+                   (:amount   arg)
+                   (or (:rounding-mode arg)
+                       (:rounding arg)))
+        (lit-parse arg)))))
+
+(defn data-literal
+  "Data reader for Money objects expressed as tagged literals in EDN data
+  files."
+  {:added "1.2.4" :tag io.randomseed.bankster.Money}
+  [arg]
+  (let [r (code-literal arg)]
+    (if (seq? r)
+      (apply (first r) (rest r))
+      r)))
 
 (defn defliteral
   "For the given currency identifier or a currency object it creates a tagged literal
@@ -2050,16 +2082,50 @@
                         (set! clojure.core/*data-readers*
                               (assoc clojure.core/*data-readers* snam varn)))))))
 
-(defn ns-lit
+(defn ns-data-literal
   {:private true :added "1.0.0"}
   [kw arg]
   (let [[a b r] (if (sequential? arg) arg [arg nil nil])
         [c am]  (if (and (some? b) (number? a)) [b a] [a b])
         c       (if (number? c) c (keyword kw (str (symbol c))))]
-    (lit [c am r])))
+    (data-literal [c am r])))
+
+(defn ns-code-literal
+  {:private true :added "1.0.0"}
+  [kw arg]
+  (let [[a b r] (if (sequential? arg) arg [arg nil nil])
+        [c am]  (if (and (some? b) (number? a)) [b a] [a b])
+        c       (if (number? c) c (keyword kw (str (symbol c))))]
+    (code-literal [c am r])))
 
 (load "money/reader_handlers")
 
+;;
+;; Data readers maps.
+;;
+
+(def ^{:tag clojure.lang.IPersistentMap :added "1.2.4"}
+  data-readers
+  "Data readers map for currency and money (intended to be used when reading EDN data
+  files containing tagged literals: #currency and #money). Handlers assigned to
+  literals are always emitting constant forms. Please note that tagged literal
+  handlers for Clojure code are using different readers (defined as code-readers)."
+  (when-some [r (fs/get-resource "data_readers_edn.clj")]
+    (when-some [d (clojure.edn/read-string (slurp r))]
+      (when (map? d)
+        (into {} (for [[k v] d] [k (resolve v)]))))))
+
+(def ^{:tag clojure.lang.IPersistentMap :added "1.2.4"}
+  code-readers
+  "Data readers map for currency and money (intended to be used when evaluating Clojure
+  code with tagged literals: #currency and #money). Handlers assigned to literals may
+  emit compound forms, like function call forms (as Clojure code). To operate on EDN
+  data files, see data-readers."
+  (when-some [r (fs/get-resource "data_readers.clj")]
+    (when-some [d (clojure.edn/read-string (slurp r))]
+      (when (map? d)
+        (into {} (for [[k v] d] [k (resolve v)]))))))
+
 ;;
 ;; Formatting.
 ;;

src/io/randomseed/bankster/money.clj

@@ -1,3 +1,5 @@
 (in-ns 'io.randomseed.bankster.money)
 
-(defn lit-crypto {:no-doc true} [arg] (ns-lit "crypto" arg))
+(defn code-literal-crypto {:no-doc true} [arg] (ns-code-literal "crypto" arg))
+
+(defn data-literal-crypto {:no-doc true} [arg] (ns-data-literal "crypto" arg))

src/io/randomseed/bankster/money/reader_handlers.clj

@@ -46,13 +46,13 @@
 
 (def ^{:const true :tag String :added "1.0.0"}
   default-reader-filenames
-  "Default data reader filenames."
+  "Default data reader filenames (Clojure code)."
   ["data_readers.clj" "data_readers.cljc"])
 
-(def ^{:const true :tag String :added "1.2.3"}
-  default-reader-filename-res
-  "Data reader filename in resources subdirectory."
-  "bankster_data_readers.clj")
+(def ^{:const true :tag String :added "1.2.4"}
+  default-data-reader-filename
+  "Default data reader filename (pure data)."
+  "data_readers_edn.clj")
 
 (def ^{:const true :tag String :added "1.0.0"}
   default-handlers-pathname
@@ -248,16 +248,23 @@
    (let [nsp (symbol (str "'" handlers-namespace))]
      (list 'in-ns nsp))))
 
-(defn handler-gen
-  "Generates handler functions for tagged literals for each namespaced currency."
-  {:no-doc true :added "1.0.0"}
-  [names]
+(defn handler-gen-for-prefix
+  {:private true :added "1.0.0"}
+  [prefix names]
   (map
-   (fn [n] (list 'defn (symbol (str "lit-" n))
-                 '{:no-doc true}
-                 '[arg] (list 'ns-lit (str n) 'arg)))
+   (fn [n]
+     (list 'defn (symbol (str prefix "-" n))
+           '{:no-doc true}
+           '[arg] (list (symbol (str "ns-" prefix)) (str n) 'arg)))
    names))
 
+(defn handler-gen
+  "Generates handler functions for tagged literals for each namespaced currency. Each
+  function will have a prefixed name."
+  [names]
+  (concat (handler-gen-for-prefix "code-literal" names)
+          (handler-gen-for-prefix "data-literal" names)))
+
 (defn readers-export
   "Creates clojure source code files with reader functions for tagged literals handling
   on a basis of registry information and data reader map files referring to the
@@ -290,56 +297,64 @@
   ([]
    (readers-export (registry/state)
                    default-reader-filenames
-                   default-reader-filename-res
+                   default-data-reader-filename
                    default-handlers-pathname
                    default-handlers-namespace))
   ([^Registry registry]
    (readers-export registry
                    default-reader-filenames
-                   default-reader-filename-res
+                   default-data-reader-filename
                    default-handlers-pathname
                    default-handlers-namespace))
   ([^Registry registry filenames]
    (readers-export registry
                    filenames
-                   default-reader-filename-res
+                   default-data-reader-filename
                    default-handlers-pathname
                    default-handlers-namespace))
-  ([^Registry registry filenames res-filename]
+  ([^Registry registry filenames data-filename]
    (readers-export registry
                    filenames
-                   res-filename
+                   data-filename
                    default-handlers-pathname
                    default-handlers-namespace))
-  ([^Registry registry filenames res-filename handlers-pathname handlers-namespace]
+  ([^Registry registry filenames data-filename handlers-pathname handlers-namespace]
    (when-some [nsses (->> (.cur-id->cur ^Registry registry)
                           (map (comp namespace first))
                           (filter identity)
                           set seq)]
-     (let [m (->> nsses
-                  (map #(vector (symbol "money" %) (symbol handlers-namespace (str "lit-" %))))
-                  (into {'money    'io.randomseed.bankster.money/lit
-                         'currency 'io.randomseed.bankster.currency/lit}))]
+     (let [m  (->> nsses
+                   (map #(vector (symbol "money" %) (symbol handlers-namespace (str "code-literal-" %))))
+                   (into {'money    'io.randomseed.bankster.money/code-literal
+                          'currency 'io.randomseed.bankster.currency/code-literal}))
+           dm (->> nsses
+                   (map #(vector (symbol "money" %) (symbol handlers-namespace (str "data-literal-" %))))
+                   (into {'money    'io.randomseed.bankster.money/data-literal
+                          'currency 'io.randomseed.bankster.currency/data-literal}))]
        (when-some [fdir (io/resource (first filenames))]
          (when-some [pdir (.getParent (io/file fdir))]
            (when-some [hfile (io/file pdir handlers-pathname)]
              (println)
-             (println "------------------- readers map:")
+             (println "------------- data readers map (for handling Clojure code):")
              (println)
              (puget/cprint m)
              (println)
+             (println "------------- data readers map (for handling EDN data):")
+             (println)
+             (puget/cprint dm)
+             (println)
              (doseq [f filenames]
                (let [fname (io/file pdir f)]
                  (println "Exporting to:" (str fname))
                  (spit fname (puget/pprint-str m))))
-             (when-some [rdir (fs/resource-pathname default-resource-name
-                                                    default-resource-must-exist-file)]
-               (let [fname (io/file (.getParent ^java.io.File (io/file rdir)) res-filename)]
+             (when (some? (seq data-filename))
+               (when-some [fname (io/file pdir data-filename)]
                  (println "Exporting to:" (str fname))
-                 (spit fname (puget/pprint-str m))))
+                 (spit fname (puget/pprint-str dm))))
+             (println)
              (println "Generating handlers code to:" (str hfile))
              (some->> nsses
-                      handler-gen
+                      (handler-gen)
                       (cons (handler-preamble handlers-namespace))
                       (map puget/pprint-str)
                       (str/join (str \newline \newline))

src/io/randomseed/bankster/util/importer.clj

@@ -77,7 +77,10 @@
              #currency {:id :EUR :numeric 1000 :scale 2 :kind :FIAT} => {:id :EUR :domain nil :kind :FIAT :numeric 1000 :scale 2 :weight 0}
              #currency {:id :EUR :kind :FIAT} => {:id :EUR :domain nil :kind :FIAT :numeric -1 :scale -1 :weight 0}
              #currency {:id :EUR :numeric 1000 :kind :FIAT} => {:id :EUR :domain nil :kind :FIAT :numeric 1000 :scale -1 :weight 0}
-             #currency {:id :EUR :scale 2 :kind :FIAT :domain :ISO-4217} => {:id :EUR :domain :ISO-4217 :kind :FIAT :numeric -1 :scale 2 :weight 0}))
+             #currency {:id :EUR :scale 2 :kind :FIAT :domain :ISO-4217} => {:id :EUR :domain :ISO-4217 :kind :FIAT :numeric -1 :scale 2 :weight 0})
+       (fact "when it can use different registries"
+             (let [r (c/update (registry/get) #currency{:id PLN :scale 10})]
+               (c/with-registry r #currency PLN)) => {:id :PLN :scale 10 :numeric -1 :weight 0 :kind nil :domain nil}))
 
 (facts "about currency registering"
        (fact "when it returns nil for nil or empty map"