Factor out facet-handling, allowing non-faceted Handler and faceted During

syndicate/during.py

@@ -6,10 +6,10 @@ def _ignore(*args, **kwargs):
 def _default_sync(turn, peer):
     turn.send(peer, True)
 
-class During(actor.Entity):
-    def __init__(self, on_add=None, on_msg=None, on_sync=None, name=None, inert_ok=False):
-        self.facets = {}
-        self._on_add = on_add or _ignore
+class Handler(actor.Entity):
+    def __init__(self, on_add=None, on_msg=None, on_sync=None, name=None, inert_ok=True):
+        self.retraction_handlers = {}
+        self._on_add = self._wrap_add_handler(on_add) or _ignore
         self._on_msg = on_msg or _ignore
         self._on_sync = on_sync or _default_sync
         self.name = name
@@ -24,16 +24,18 @@ class During(actor.Entity):
     def _wrap(self, v):
         return v if self.flatten_arg and isinstance(v, tuple) else (v,)
 
+    def _wrap_add_handler(self, handler):
+        return handler
+
     def on_publish(self, turn, v, handle):
-        facet = turn.facet(lambda turn: self._on_add(turn, *self._wrap(v)))
-        if self.inert_ok:
-            facet.prevent_inert_check()
-        self.facets[handle] = facet
+        retraction_handler = self._on_add(turn, *self._wrap(v))
+        if retraction_handler is not None:
+            self.retraction_handlers[handle] = retraction_handler
 
     def on_retract(self, turn, handle):
-        facet = self.facets.pop(handle, None)
-        if facet is not None:
-            turn.stop(facet)
+        retraction_handler = self.retraction_handlers.pop(handle, None)
+        if retraction_handler is not None:
+            retraction_handler(turn)
 
     def on_message(self, turn, v):
         self._on_msg(turn, *self._wrap(v))
@@ -43,7 +45,7 @@ class During(actor.Entity):
 
     # decorator
     def add_handler(self, on_add):
-        self._on_add = on_add
+        self._on_add = self._wrap_add_handler(on_add)
         return self
 
     # decorator
@@ -55,3 +57,14 @@ class During(actor.Entity):
     def sync_handler(self, on_sync):
         self._on_sync = on_sync
         return self
+
+class During(Handler):
+    def _wrap_add_handler(self, handler):
+        def facet_handler(turn, *args):
+            @turn.facet
+            def facet(turn):
+                if self.inert_ok:
+                    turn.prevent_inert_check()
+                handler(turn, *args)
+            return lambda turn: turn.stop(facet)
+        return facet_handler