@@ -4,10 +4,6 @@

 ; TODO remove this duplication

 ; TODO find a way to load this data at runtime

-(defn- hashmap-by

-    [vec k]

-    (zipmap (map #(-> % k keyword) vec) vec))

-

 (def open-game-license

   (-> "5e-database/5e-SRD-License.json"

       rc/inline

@@ -22,29 +18,21 @@

     [x]

     (assoc x :license-notice ogl-notice))

-(def spells

-  (-> "5e-database/5e-SRD-Spells.json"

-      rc/inline

-      (#(.parse js/JSON %))

-      (js->clj :keywordize-keys true)

-      (as-> s (map add-ogl-notice s))

-      (hashmap-by :index)))

-

+(def srd-data {:spells (rc/inline "5e-database/5e-SRD-Spells.json")

+               :equipment (rc/inline "5e-database/5e-SRD-Equipment.json")})

-(def equipment

-  (-> "5e-database/5e-SRD-Equipment.json"

-      rc/inline

-      (#(.parse js/JSON %))

-      (js->clj :keywordize-keys true)

-      (as-> s (map add-ogl-notice s))

-      (hashmap-by :index)))

+(defn- parse-srd-data [raw-data]

+  (as-> raw-data x

+      (.parse js/JSON x)

+      (js->clj x :keywordize-keys true)

+      (map add-ogl-notice x)))

+(defn- fmap [f m] (zipmap (keys m) (map f (vals m))))

 (def default-db

   {:name "DMR"

    :cmdline {:current ""

              :selected-history nil

              :history []}

-   :spells spells

-   :equipment equipment

+   :entities (fmap parse-srd-data srd-data)

    :license open-game-license})

@@ -1,6 +1,6 @@

 (ns dmr.events

   (:require

-   [clojure.string :refer [trim]]

+   [clojure.string :refer [lower-case split join]]

    [re-frame.core :as re-frame]

    [dmr.db :as db]

    [day8.re-frame.tracing :refer-macros [fn-traced]]))

@@ -11,25 +11,40 @@

  (fn-traced [_ _]

    db/default-db))

+(defn single-space [s]

+  (as-> s x

+        (split x " ")

+        (filter not-empty x)

+        (join " " x)))

+

+(defn normalize-cmdline [cmdline]

+    (-> cmdline single-space lower-case))

+

 (re-frame/reg-event-db

  ::update-cmdline

  (fn-traced [db [_ current]]

   (assoc-in db [:cmdline :current] current)))

+(defn get-using [f coll]

+  (->> coll (filter f) first))

+

+(defn- concatv [m]

+    (->> m vals (apply concat)))

+

 (defn execute [db cmdline]

  (let [append-history #(update-in db [:cmdline :history] conj {:input cmdline :output %})

-       spells (db :spells)

-       equipment (db :equipment)

-       cmd (keyword cmdline)]

+       entities (db :entities)

+       lcc (normalize-cmdline cmdline)

+       get-using-name (partial get-using #(some-> % :name normalize-cmdline (= lcc)))]

   ; TODO: Replace with the 'match' macro

   (cond

    (empty? cmdline) db

    (= "clear" cmdline) (assoc-in db [:cmdline :history] [])

    (= "Open Game License" cmdline) (append-history (db :license))

-   (= "spells" cmdline) (append-history (vals spells))

-   (= "items" cmdline) (append-history (vals equipment))

-   (contains? spells cmd) (append-history (spells cmd))

-   (contains? equipment cmd) (append-history (equipment cmd))

+   (= "spells" cmdline) (-> entities :spells append-history)

+   (= "items" cmdline)  (-> entities :equipment append-history)

+   ; TODO: refactor this to avoid 2 lookups (cond -> or)

+   (-> entities concatv (get-using-name)) (-> entities concatv get-using-name append-history)

    :else (append-history {:err (str "Unknown command '" cmdline "'")}))))

 (re-frame/reg-fx

@@ -84,7 +99,7 @@

  ::submit-cmd

  (fn [cofx [_ prompt]]

   (let [db (cofx :db)

-        cmdline (some-> db :cmdline :current trim)]

+        cmdline (some-> db :cmdline :current)]

     {:db

      (-> db

       (update-in [:cmdline :current] (constantly nil))