Rework statemachine

core.fnl

@@ -219,6 +219,7 @@ Returns nil. This function causes side-effects.
                 :apps
                 :lib.bind
                 :lib.modal
+                :lib.new-modal
                 :lib.apps])
 
 (defadvice get-config-impl

lib/functional.fnl

@@ -206,6 +206,16 @@
   (let [filtered (filter f tbl)]
     (<= 1 (length filtered))))
 
+(fn conj
+  [tbl e]
+  "Return a new list with the element e added at the end"
+  (concat tbl [e]))
+
+(fn butlast
+  [tbl]
+  "Return a new list with all but the last item"
+  (slice 1 -1 tbl))
+
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Others
@@ -226,9 +236,11 @@
 ;; Exports
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-{: call-when
+{: butlast
+ : call-when
  : compose
  : concat
+ : conj
  : contains?
  : count
  : eq?

lib/modal.fnl

@@ -12,8 +12,10 @@ switching menus in one place which is then powered by config.fnl.
 (local atom (require :lib.atom))
 (local statemachine (require :lib.statemachine))
 (local apps (require :lib.apps))
-(local {: call-when
+(local {: butlast
+        : call-when
         : concat
+        : conj
         : find
         : filter
         : has-some?
@@ -272,7 +274,7 @@ switching menus in one place which is then powered by config.fnl.
    :stop-timeout :nil
    :unbind-keys (bind-menu-keys menu.items)
    :history (if history
-                (concat [] history [menu])
+                (conj history menu)
                 [menu])})
 
 
@@ -438,7 +440,7 @@ switching menus in one place which is then powered by config.fnl.
                (show-modal-menu (merge state
                                        {:menu prev-menu
                                         :prev-menu menu}))
-               {:history (slice 1 -1 history)})
+               {:history (butlast history)})
         (idle->active state))))
 
 
@@ -536,4 +538,12 @@ switching menus in one place which is then powered by config.fnl.
 
 
 {:init           init
+ : modal-alert ;; DELETEME: Temporary for PR
+ : timeout ;; DELETEME: Temporary for PR
+ : by-key ;; DELETEME: Temporary for PR
+ : activate-modal ;; DELETEME: Temporary for PR
+ : deactivate-modal ;; DELETEME: Temporary for PR
+ : previous-modal ;; DELETEME: Temporary for PR
+ : proxy-app-action ;; DELETEME: Temporary for PR
+ : bind-menu-keys
  :activate-modal activate-modal}

lib/new-modal.fnl

@@ -0,0 +1,297 @@
+"
+Displays the menu modals, sub-menus, and application-specific modals if set
+in config.fnl.
+
+We define a state machine, which uses our local states to determine states, and
+transitions. Then we can signal events that may transition between specific
+states defined in the table.
+
+Allows us to create the machinery for displaying, entering, exiting, and
+switching menus in one place which is then powered by config.fnl.
+"
+(local atom (require :lib.atom))
+(local statemachine (require :lib.new-statemachine))
+(local om (require :lib.modal)) ;; DELETEME: For PR
+(local apps (require :lib.apps))
+(local {: butlast
+        : call-when
+        : concat
+        : conj
+        : find
+        : filter
+        : has-some?
+        : identity
+        : join
+        : map
+        : merge
+        : noop}
+       (require :lib.functional))
+(local {:align-columns align-columns}
+       (require :lib.text))
+(local {:action->fn action->fn
+        :bind-keys bind-keys}
+       (require :lib.bind))
+(local lifecycle (require :lib.lifecycle))
+
+(local log (hs.logger.new "\tmodal.fnl\t" "debug"))
+(var fsm nil)
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Display Modals
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(fn show-modal-menu
+  [context]
+  "
+  Main API to display a modal and run side-effects
+    - Display the modal alert
+  Takes current modal state from our modal statemachine
+  Returns the function to cleanup everything it sets up
+  "
+  (lifecycle.enter-menu context.menu)
+  (om.modal-alert context.menu)
+  (let [unbind-keys (om.bind-menu-keys context.menu.items)
+        stop-timeout context.stop-timeout]
+    (fn []
+      (hs.alert.closeAll 0)
+      (unbind-keys)
+      (call-when stop-timeout)
+      (lifecycle.exit-menu context.menu)
+      )))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; State Transition Functions
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(fn idle->active
+  [state action extra]
+  "
+  Transition our modal statemachine from the idle state to active where a menu
+  modal is displayed to the user.
+  Takes the current modal state table plus the key of the menu if submenu
+  Kicks off an effect to display the modal or local app menu
+  Returns updated modal state machine state table.
+  "
+  (let [config state.context.config
+        app-menu (apps.get-app)
+        menu (if (and app-menu (has-some? app-menu.items))
+                 app-menu
+                 config)]
+    (log.wf "TRANSITION: idle->active app-menu %s menu %s config %s" app-menu menu config) ;; DELETEME
+    {:state {:current-state :active
+             :context (merge state.context {:menu menu
+                                            :history (if state.history
+                                                         (conj history menu)
+                                                         [menu])})}
+     :effect :show-modal-menu}))
+
+
+(fn active->idle
+  [state action extra]
+  "
+  Transition our modal state machine from the active, open state to idle.
+  Takes the current modal state table.
+  Kicks off an effect to close the modal, stop the timeout, and unbind keys
+  Returns updated modal state machine state table.
+  "
+  (log.wf "TRANSITION: active->idle") ;; DELETEME
+  {:state  {:current-state :idle
+            :context (merge state.context {:menu :nil
+                                           :history []})}
+   :effect :close-modal-menu})
+
+
+(fn active->enter-app
+  [state action extra]
+  "
+  Transition our modal state machine the main menu to an app menu
+  Takes the current modal state table and the app menu table.
+  Displays updated modal menu if the current menu is different than the previous
+  menu otherwise results in no operation
+  Returns new modal state
+  "
+  (log.wf "TRANSITION: active->enter-app") ;; DELETEME
+  (let [{:config config
+         :menu prev-menu} state.context
+        app-menu (apps.get-app)
+        menu (if (and app-menu (has-some? app-menu.items))
+                 app-menu
+                 config)]
+    (if (= menu.key prev-menu.key)
+        ; nil transition object means keep all state
+        nil
+        {:state {:current-state :submenu
+                 :context (merge state.context {:menu menu})}
+         :effect :open-submenu})))
+
+
+(fn active->leave-app
+  [state action extra]
+  "
+  Transition to the regular menu when user removes focus (blurs) another app.
+  If the leave event was fired for the app we are already in, do nothing.
+  Takes the current modal state table.
+  Returns new updated modal state if we are leaving the current app.
+  "
+  (log.wf "TRANSITION: active->leave-app") ;; DELETEME
+  (let [{:config config
+        :menu prev-menu} state.context]
+    (if (= prev-menu.key config.key)
+        nil
+        (idle->active state action extra))))
+
+
+(fn active->submenu
+  [state action menu-key]
+  "
+  Enter a submenu like entering into the Window menu from the default main menu.
+  Takes the current menu state table and the submenu key as 'extra'.
+  Returns updated menu state
+  "
+  (let [{:config config
+         :menu prev-menu} state.context
+        menu (if menu-key
+                 (find (om.by-key menu-key) prev-menu.items)
+                 config)]
+    (log.wf "TRANSITION: active->submenu with menu-key %s menu %s" menu-key menu) ;; DELETEME
+    {:state {:current-state :submenu
+             :context (merge state.context {:menu menu})}
+     :effect :open-submenu}))
+
+(fn add-timeout-transition
+  [state action extra]
+  "
+  Transition from active to idle, but this transition only fires when the
+  timeout occurs. The timeout is only started after firing a repeatable action.
+  For instance if you enter window > jump east you may want to jump again
+  without having to bring up the modal and enter the window submenu. We wait for
+  more modal keypresses until the timeout triggers which will deactivate the
+  modal.
+  Takes the current modal state table.
+  Returns a the old state with a :stop-timeout added
+  "
+  (log.wf "TRANSITION: add-timeout-transition") ;; DELETEME
+  {:state {:current-state state.context.current-state
+           :context
+           (merge state.context {:stop-timeout (om.timeout om.deactivate-modal)})}
+   :effect :open-submenu})
+
+(fn submenu->previous
+  [state action extra]
+  "
+  Transition to the previous submenu. Like if you went into the window menu
+  and wanted to go back to the main menu.
+  Takes the modal state table.
+  Returns a partial modal state table update.
+  Dynamically calls another transition depending on history.
+  "
+  (let [{:config config
+         :history hist
+         :menu menu} state.context
+        prev-menu (. hist (- (length hist) 1))]
+    (log.wf "TRANSITION: submenu->previous") ;; DELETEME
+    (if prev-menu
+        {:state {:current-state :submenu
+                 :context (merge state.context {:menu prev-menu
+                                                :history (butlast hist)})}
+         :effect :open-submenu}
+        (idle->active state))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Finite State Machine States
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;; State machine states table. Maps states to actions to transition functions.
+;; These transition functions return transition objects that contain the new
+;; state key and context.
+(local states
+       {:idle   {:activate       idle->active
+                 :enter-app      noop
+                 :leave-app      noop}
+        :active {:deactivate     active->idle
+                 :activate       active->submenu
+                 :start-timeout  add-timeout-transition
+                 :enter-app      active->enter-app
+                 :leave-app      active->leave-app}
+        :submenu {:deactivate    active->idle
+                  :activate      active->submenu
+                  :previous      submenu->previous
+                  :start-timeout add-timeout-transition
+                  :enter-app     noop
+                  :leave-app     noop}})
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Watchers, Dispatchers, & Logging
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(fn start-logger
+  [fsm]
+  "
+  Start logging the status of the modal state machine.
+  Takes our finite state machine.
+  Returns nil
+  Creates a watcher of our state atom to log state changes reactively.
+  "
+  (atom.add-watch
+   fsm.state :log-state
+   (fn log-state
+     [state]
+     (log.df "state is now: %s" state.current-state) ;; DELETEME
+     (when state.context.history
+       (log.df (hs.inspect (map #(. $1 :title) state.context.history)))))))
+
+; TODO: Bind show-modal-menu direct
+; TODO: Do we only need one effect?
+(local modal-effect
+       (statemachine.effect-handler
+        {:show-modal-menu (fn [state extra]
+                            (log.wf "Effect: show modal") ;; DELETEME
+                            (show-modal-menu state.context))
+         :open-submenu (fn [state extra]
+                         (log.wf "Effect: Open submenu with extra %s" extra) ;; DELETEME
+                         (show-modal-menu state.context))}))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Initialization
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(fn init
+  [config]
+  "
+  Initialize the modal state machine responsible for displaying modal alerts
+  to the user to trigger actions defined by their config.fnl.
+  Takes the config.fnl table.
+  Causes side effects to start the state machine, show the modal, and logging.
+  Returns a function to unsubscribe from the app state machine.
+  "
+  (let [initial-context {:config config
+                         :history []
+                         :menu :nil}
+        template {:state {:current-state :idle
+                          :context initial-context}
+                  :states states
+                  :log "modal"}
+        unsubscribe (apps.subscribe om.proxy-app-action)]
+    (set fsm (statemachine.new template))
+    (tset fsm :dispatch fsm.signal) ; DELETEME: TEMP: Monkey patch dispatch to show dispatchers haven't changed
+    (fsm.subscribe modal-effect)
+    (start-logger fsm)
+    (fn cleanup []
+      (unsubscribe))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Exports
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+{:init           init
+ :activate-modal om.activate-modal}