@@ -40,30 +40,43 @@

  (fn [_ [_ x]]

      {:window/scroll-to x}))

-(defn- up [x]

-  (case x

-    nil 0

-    (inc x)))

-

-(defn- down [x]

-  (case x

-    nil nil

-    0   nil

-    (dec x)))

+(defn- cycle-history [cs direction]

+  (let [history (-> cs :history)

+        current (-> cs :current)

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

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

+        history-end (- (count history) 1)

+        next (case direction :back dec :fwd inc)

+        at-first? (= idx history-end)

+        at-last?  (= idx 0)

+        going-forward? (= direction :fwd)

+        going-backward? (= direction :back)

+        not-cycling? (-> cs :selected-history nil?)]

+    (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 not-cycling? going-backward?) {:current (-> history (get history-end) :input)

+                                          :selected-history {:orig current

+                                                             :index history-end}}

+      :else                              {:current (-> history (get (next idx)) :input)

+                                          :selected-history {:orig orig

+                                                             :index (next idx)}})))

 (re-frame/reg-event-db

  ::prompt-keypress

- (fn [db [_ x]]

-   (case (.-key x)

-     "ArrowUp"

-       (do (.preventDefault x)

-           (println "up")

-           (update-in db [:cmdline :selected-history] up))

-     "ArrowDown"

-       (do (.preventDefault x)

-           (println "down")

-           (update-in db [:cmdline :selected-history] down))

-     nil)))

+ (re-frame/path :cmdline)

+ (fn [cmd [_ event]]

+   (let [

+         direction (case (.-key event)

+                     "ArrowUp" :back

+                     "ArrowDown" :fwd

+                     nil)]

+     (if direction

+       (do (.preventDefault event)

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

+       cmd))))

 (re-frame/reg-event-fx

  ::submit-cmd