@@ -32,6 +32,7 @@

 (def default-db

   {:name "DMR"

    :cmdline {:current ""

+             :suggestions {:options nil :selected nil}

              :selected-history nil

              :history []}

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

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

 (ns dmr.events

   (:require

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

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

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

    [dmr.db :as db]

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

@@ -20,17 +20,30 @@

 (defn normalize-cmdline [cmdline]

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

+(defn- concatv [m]

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

+

+(defn autocomplete-suggestions [db current]

+  (let [entities (db :entities)

+        cur (normalize-cmdline current)

+        best-match #(< (count %1) (count %2))]

+      (when (not-empty cur)

+        (->> (concatv entities)

+             (filter #(-> % :name normalize-cmdline (starts-with? cur)))

+             (map :name)

+             (sort best-match)))))

+

 (re-frame/reg-event-db

  ::update-cmdline

  (fn-traced [db [_ current]]

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

+  (-> db

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

+      (assoc-in [:cmdline :suggestions] {:options (autocomplete-suggestions db current)

+                                         :selected nil}))))

 (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 %})

        entities (db :entities)

@@ -63,7 +76,7 @@

         orig (some-> cs :selected-history :orig)

         idx (some-> cs :selected-history :index)

         history-end (- (count history) 1)

-        historical-input #(-> history (get %) :input)

+        historical-input #(-> history (nth %) :input)

         next (case direction :backward dec :forward inc)

         at-first? (= idx history-end)

         at-last?  (= idx 0)

@@ -73,8 +86,8 @@

     (cond

       (empty? history)                   {:current current :selected-history nil}

       (and at-first? going-forward?)     {:current orig :selected-history nil}

-      (and at-last? going-backward?)     {} ; do nothing

-      (and not-cycling? going-forward?)  {} ; do nothing

+      (and at-last? going-backward?)     nil ; do nothing

+      (and not-cycling? going-forward?)  nil ; do nothing

       (and not-cycling? going-backward?) {:current (historical-input history-end)

                                           :selected-history {:orig current

                                                              :index history-end}}

@@ -82,6 +95,26 @@

                                           :selected-history {:orig orig

                                                              :index (next idx)}})))

+(defn cycle-suggestions [cmd direction]

+  (let [{:keys [options selected]} (cmd :suggestions)

+        next (case direction :backward dec :forward inc)

+        nopts (count options)

+        next-selected (cond

+                        (nil? selected)     (case direction

+                                                  :backward (- nopts 1)

+                                                  :forward 0)

+                        (>= (next selected) nopts) 0

+                        (< (next selected) 0) (- nopts 1)

+                        :else               (next selected))]

+    (when (not-empty options)

+      {:suggestions {:options options :selected next-selected}})))

+

+(def null-suggestions {:options nil :selected nil})

+

+(defn complete-suggestion [{:keys [suggestions]}]

+  (let [{:keys [options selected]} suggestions]

+    {:current (nth options selected) :suggestions null-suggestions}))

+

 (re-frame/reg-event-db

  ::prompt-keypress

  (re-frame/path :cmdline)

@@ -89,11 +122,28 @@

    (let [direction (case (.-key event)

                      "ArrowUp"   :backward

                      "ArrowDown" :forward

-                     nil)]

-     (if direction

-       (do (.preventDefault event)

-           (merge cmd (cycle-history cmd direction)))

-       cmd))))

+                     "ArrowRight" :right

+                     nil)

+         tab (= (.-key event) "Tab")

+         escape (= (.-key event) "Escape")]

+     (println (.-key event) direction (contains? #{:backward :forward} direction))

+     (cond

+      (contains? #{:backward :forward} direction) (do (.preventDefault event)

+                                                      (if (some-> cmd :suggestions :options)

+                                                          (merge cmd (cycle-suggestions cmd direction))

+                                                          (merge cmd (cycle-history cmd direction))))

+      (and (= :right direction)

+           (some-> cmd :suggestions :selected)) (do (.preventDefault event)

+                                                    (merge cmd (complete-suggestion cmd)))

+      (and tab

+           (= 1 (some-> cmd :suggestions :options count))

+           (some-> cmd :suggestions :selected)) (do (.preventDefault event)

+                                                    (merge cmd (complete-suggestion cmd)))

+      tab (do (.preventDefault event)

+              (merge cmd (cycle-suggestions cmd :forward)))

+      (and escape (some-> cmd :suggestions :options)) (do (.preventDefault event)

+                                                          (merge cmd {:suggestions null-suggestions}))

+      :else     cmd))))

 (re-frame/reg-event-fx

  ::submit-cmd

@@ -102,8 +152,9 @@

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

     {:db

      (-> db

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

-      (update-in [:cmdline :selected-history] (constantly nil))

+      (assoc-in [:cmdline :current] nil)

+      (assoc-in [:cmdline :selected-history] nil)

+      (assoc-in [:cmdline :suggestions] {:options nil :selected nil})

       (execute cmdline))

      ; dispatch-later to ensure that the DOM has already been updated,

@@ -202,4 +202,17 @@

     :padding 0

     :width (calc "100% - 2ch")}

    [:&:focus

-    {:outline :none}]])

+    {:outline :none}]]

+  [:ul.suggestions

+   {:position :absolute

+    :padding-left 0

+    :padding-right 0

+    :bottom 0

+    :left 0

+    :margin-bottom :1.2rem

+    :background-color (colorscheme :light0-soft)}

+   [:li {:list-style :none

+         :padding-left :3ch

+         :padding-right :1ch}

+     [(s/& :.selected)

+      {:background-color (colorscheme :neutral-purple)}]]])

@@ -12,6 +12,11 @@

  (fn [db]

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

+(re-frame/reg-sub

+ ::cmdline-suggestions

+ (fn [db]

+   (get-in db [:cmdline :suggestions])))

+

 (re-frame/reg-sub

  ::cmd-history

  (fn [db]

@@ -8,24 +8,6 @@

    [dmr.subs :as subs]

    [dmr.events :as events]))

-(defn prompt []

-  (let [cmdline (re-frame/subscribe [::subs/cmdline])

-        update-cmdline #(re-frame/dispatch-sync

-                         [::events/update-cmdline (-> % .-target .-value)])

-        key-pressed #(re-frame/dispatch-sync [::events/prompt-keypress %])

-        submit-cmd #(do (.preventDefault %)

-                        (re-frame/dispatch [::events/submit-cmd (-> % .-target)]))]

-    [:form {:class (styles/prompt-style)

-            :on-submit submit-cmd}

-     [:input {:value @cmdline

-              :on-change update-cmdline

-              :on-keyDown key-pressed

-              :type "text"}]]))

-

-(defn title []

-  (let [name (re-frame/subscribe [::subs/name])]

-    [:h1 "Welcome to " @name]))

-

 ; TODO: move this functionto a separate 'utils' module

 (defn ordinal [n]

     (let [final-digit (mod n 10)

@@ -58,6 +40,33 @@

 (defn- enumerated [& colls] (apply zip (range) colls))

+

+(defn prompt []

+  (let [cmdline (re-frame/subscribe [::subs/cmdline])

+        suggestions (re-frame/subscribe [::subs/cmdline-suggestions])

+        update-cmdline #(re-frame/dispatch-sync

+                         [::events/update-cmdline (-> % .-target .-value)])

+        key-pressed #(re-frame/dispatch-sync [::events/prompt-keypress %])

+        submit-cmd #(do (.preventDefault %)

+                        (re-frame/dispatch [::events/submit-cmd (-> % .-target)]))]

+    [:form {:class (styles/prompt-style)

+            :on-submit submit-cmd}

+     [:input {:value @cmdline

+              :on-change update-cmdline

+              :on-keyDown key-pressed

+              :type "text"}]

+

+     [:ul.suggestions

+      (let [{:keys [options selected]} @suggestions]

+         (for [[idx x] (enumerated options)]

+           ^{:key x} [:li

+                      (when (= idx selected) {:class :selected})

+                      x]))]]))

+

+(defn title []

+  (let [name (re-frame/subscribe [::subs/name])]

+    [:h1 "Welcome to " @name]))

+

 (defn- property-list [& props]

     (into

      [:ul {:class (styles/property-list)}]