add possibility to unregister subscription/event handlers

src/re_frame/core.cljs

@@ -13,12 +13,14 @@
 (def router-loop scaffold/router-loop)
 (def set-loggers! scaffold/set-loggers!)
 (def register-sub scaffold/register-sub)
+(def unregister-sub scaffold/unregister-sub)
 (def clear-sub-handlers! scaffold/clear-sub-handlers!)
 (def subscribe scaffold/subscribe)
 (def clear-event-handlers! scaffold/clear-event-handlers!)
 (def dispatch scaffold/dispatch)
 (def dispatch-sync scaffold/dispatch-sync)
 (def register-handler scaffold/register-handler)
+(def unregister-handler scaffold/unregister-handler)
 
 ;(def pure scaffold/pure)
 (def debug scaffold/debug)

src/re_frame/frame.cljs

@@ -15,9 +15,9 @@ by the process doing actual transduction. See scaffold's transduce-by-resetting-
   (let [{:keys [handlers loggers db-selector]} frame]
     (fn [reducing-fn]
       (fn
-        ([] (reducing-fn))                                  ; transduction initialization, see [1]
+        ([] (reducing-fn))                                  ; transduction init, see [1]
         ([result] (reducing-fn result))                     ; transduction completion, see [1]
-        ([state event]
+        ([state event]                                      ; transduction step, see [1]
          (let [event-id (get-event-id event)
                handler-fn (event-id handlers)]
            (if (nil? handler-fn)
@@ -48,7 +48,7 @@ by the process doing actual transduction. See scaffold's transduce-by-resetting-
     (-write writer ">")))
 
 (defn make-frame
-  "Constructs independent frame instance."
+  "Constructs an independent frame instance."
   ([] (make-frame nil))
   ([handlers] (make-frame handlers nil))
   ([handlers subscriptions] (make-frame handlers subscriptions deref))
@@ -72,32 +72,50 @@ by the process doing actual transduction. See scaffold's transduce-by-resetting-
       (handler-fn subscription-spec))))
 
 (defn register-subscription-handler
-  "Registers a handler function for an id."
+  "Registers a subscription handler function for an id."
   [frame subscription-id handler-fn]
   (let [existing-subscriptions (get frame :subscriptions)]
     (if (contains? existing-subscriptions subscription-id)
       (let [warn (get-in frame [:loggers :warn])]
-        (warn "re-frame: overwriting subscription-handler for: " subscription-id))))
+        (warn "re-frame: overwriting subscription handler for: " subscription-id))))
   (assoc-in frame [:subscriptions subscription-id] handler-fn))
 
+(defn unregister-subscription-handler
+  "Unregisters subscription handler function previously registered via register-subscription-handler."
+  [frame subscription-id]
+  (let [existing-subscriptions (get frame :subscriptions)]
+    (if-not (contains? existing-subscriptions subscription-id)
+      (let [warn (get-in frame [:loggers :warn])]
+        (warn "re-frame: unregistering subscription handler \"" subscription-id "\" which does not exist."))))
+  (update frame :subscriptions dissoc subscription-id))
+
 (defn clear-subscription-handlers
   "Unregisters all subscription handlers."
   [frame]
-  (assoc frame :subscriptions {}))
+  (assoc frame :subscriptions nil))
 
 (defn register-event-handler
   "Register a handler for an event."
   ([frame event-id handler-fn]
    (let [existing-handlers (get frame :handlers)]
      (if (contains? existing-handlers event-id)
        (let [warn (get-in frame [:loggers :warn])]
-         (warn "re-frame: overwriting an event-handler for: " event-id)))
+         (warn "re-frame: overwriting an event handler for: " event-id)))
      (assoc-in frame [:handlers event-id] handler-fn))))
 
+(defn unregister-event-handler
+  "Unregisters event handler function previously registered via register-event-handler."
+  [frame event-id]
+  (let [existing-handlers (get frame :handlers)]
+    (if (contains? existing-handlers event-id)
+      (let [warn (get-in frame [:loggers :warn])]
+        (warn "re-frame: unregistering event handler \"" event-id "\" which does not exist."))))
+  (update frame :handlers dissoc event-id))
+
 (defn clear-event-handlers
   "Unregisters all event handlers."
   [frame]
-  (assoc frame :handlers {}))
+  (assoc frame :handlers nil))
 
 (defn set-loggers
   "Resets loggers."

src/re_frame/scaffold.cljs

@@ -28,6 +28,9 @@
 (defn register-sub [subscription-id handler-fn]
   (swap! app-frame #(frame/register-subscription-handler % subscription-id handler-fn)))
 
+(defn unregister-sub [subscription-id]
+  (swap! app-frame #(frame/unregister-subscription-handler % subscription-id)))
+
 (defn clear-sub-handlers! []
   (swap! app-frame #(frame/clear-subscription-handlers %)))
 
@@ -106,6 +109,9 @@
      (register-base event-id middleware handler)
      (register-base event-id handler))))
 
+(defn unregister-handler [event-id]
+  (swap! app-frame #(frame/unregister-event-handler % event-id)))
+
 ;; -- The Event Conveyor Belt  --------------------------------------------------------------------
 ;;
 ;; Moves events from "dispatch" to the router loop.

test/re_frame/test/frame.cljs

@@ -38,9 +38,9 @@
                       ([result] result)
                       ([_old-state new-state] new-state))]
     (let [xform (frame/get-frame-transducer frame)]
-      (transduce xform reducing-fn nil [event]))))
+      ((xform reducing-fn) nil event))))
 
-(deftest frame-error-handling
+(deftest frame-errors
   (testing "doing invalid subscription"
     (reset-log-recorder!)
     (let [frame (make-empty-test-frame)]
@@ -66,21 +66,41 @@
       (is (= (process-single-event frame [:non-existing-handler]) nil))
       (is (= (last-error) ["re-frame: no event handler registered for: \"" :non-existing-handler "\". Ignoring."])))))
 
-(deftest frame-warning-handling
+(deftest frame-warnings
   (testing "overwriting subscription handler"
     (reset-log-recorder!)
     (let [frame (make-empty-test-frame)
           frame-with-some-handler (frame/register-subscription-handler frame :some-handler identity)]
       (is (= (last-warn) nil))
       (frame/register-subscription-handler frame-with-some-handler :some-handler (fn []))
-      (is (= (last-warn) ["re-frame: overwriting subscription-handler for: " :some-handler]))))
+      (is (= (last-warn) ["re-frame: overwriting subscription handler for: " :some-handler]))))
   (testing "overwriting event handler"
     (reset-log-recorder!)
     (let [frame (make-empty-test-frame)
           frame-with-some-handler (frame/register-event-handler frame :some-handler identity)]
       (is (= (last-warn) nil))
       (frame/register-event-handler frame-with-some-handler :some-handler (fn []))
-      (is (= (last-warn) ["re-frame: overwriting an event-handler for: " :some-handler])))))
+      (is (= (last-warn) ["re-frame: overwriting an event handler for: " :some-handler]))))
+  (testing "unregistering subscription handler which does not exist"
+    (reset-log-recorder!)
+    (let [frame (make-empty-test-frame)]
+      (is (= (last-warn) nil))
+      (frame/unregister-subscription-handler frame :non-existing-handler)
+      (is (= (last-warn) ["re-frame: unregistering subscription handler \"" :non-existing-handler "\" which does not exist."])))))
+
+(deftest frame-event-handlers
+  (testing "unregister event handler"
+    (let [frame (-> (make-empty-test-frame)
+                  (frame/register-event-handler :some-handler identity))]
+      (is (= (get-in frame [:handlers :some-handler]) identity))
+      (is (= (get-in (frame/unregister-event-handler frame :some-handler) [:handlers :some-handler] ::not-found) ::not-found)))))
+
+(deftest frame-subscription-handlers
+  (testing "unregister subscription handler"
+    (let [frame (-> (make-empty-test-frame)
+                  (frame/register-subscription-handler :some-handler identity))]
+      (is (= (get-in frame [:subscriptions :some-handler]) identity))
+      (is (= (get-in (frame/unregister-subscription-handler frame :some-handler) [:subscriptions :some-handler] ::not-found) ::not-found)))))
 
 (deftest frame-transduction
   (testing "simple transduce"