add EQFDispatcher

Author: radix

effect/test_testing.py

@@ -17,6 +17,7 @@
     ESError,
     ESFunc,
     EQDispatcher,
+    EQFDispatcher,
     fail_effect,
     resolve_effect,
     resolve_stubs)
@@ -255,11 +256,23 @@ class EQDispatcherTests(TestCase):
     def test_no_intent(self):
         """When the dispatcher can't match the intent, it returns None."""
         d = EQDispatcher({})
-        self.assertIs(d("foo"), None)
+        self.assertIs(d('foo'), None)
 
     def test_perform(self):
         """When an intent matches, performing it returns the canned result."""
-        d = EQDispatcher({"hello": "there"})
-        self.assertEqual(
-            sync_perform(d, Effect("hello")),
-            "there")
+        d = EQDispatcher({'hello': 'there'})
+        self.assertEqual(sync_perform(d, Effect('hello')), 'there')
+
+
+class EQFDispatcherTests(TestCase):
+    """Tests for :obj:`EQFDispatcher`."""
+
+    def test_no_intent(self):
+        """When the dispatcher can't match the intent, it returns None."""
+        d = EQFDispatcher({})
+        self.assertIs(d('foo'), None)
+
+    def test_perform(self):
+        """When an intent matches, performing it returns the canned result."""
+        d = EQFDispatcher({'hello': lambda i: (i, 'there')})
+        self.assertEqual(sync_perform(d, Effect('hello')), ('hello', 'there'))

effect/testing.py

@@ -178,7 +178,7 @@ class EQDispatcher(object):
     e.g.::
 
         >>> sync_perform(EQDispatcher({MyIntent(1, 2): 'the-result'}),
-                         Effect(MyIntent(1, 2)))
+        ...              Effect(MyIntent(1, 2)))
         'the-result'
 
     assuming MyIntent supports ``__eq__`` by value.
@@ -194,3 +194,35 @@ def __call__(self, intent):
         for k, v in self.mapping.items():
             if k == intent:
                 return sync_performer(lambda d, i: v)
+
+
+class EQFDispatcher(object):
+    """
+    A dispatcher that looks up intents by equality and performs them by
+    invoking a provided function.
+
+    Users provide a mapping of intents to functions, where the intents are
+    matched against the intents being performed with a simple equality check
+    (not a type check!).
+
+    e.g.::
+
+        >>> sync_perform(
+        ...     EQFDispatcher({
+        ...         MyIntent(1, 2): lambda i: 'the-result'}),
+        ...     Effect(MyIntent(1, 2)))
+        'the-result'
+
+    assuming MyIntent supports ``__eq__`` by value.
+    """
+    def __init__(self, mapping):
+        """
+        :param mapping: Mapping of intents to results.
+        """
+        self.mapping = mapping
+
+    def __call__(self, intent):
+        # Avoid hashing, because a lot of intents aren't hashable.
+        for k, v in self.mapping.items():
+            if k == intent:
+                return sync_performer(lambda d, i: v(i))