Unify stackSenders and stackReceivers.

Author: habnabit

parsley.py

@@ -122,41 +122,24 @@ def makeProtocol(source, senderFactory, receiverFactory, bindings=None,
         ParserProtocol, grammar, senderFactory, receiverFactory, bindings)
 
 
-def stackSenders(*wrappers):
+def stack(*wrappers):
     """
-    Stack some senders for ease of wrapping.
+    Stack some senders or receivers for ease of wrapping.
 
-    ``stackSenders(x, y, z)`` will return a sender factory which will, when
-    called with a transport, return ``x(y(z(transport)))``.
+    ``stack(x, y, z)`` will return a factory usable as a sender or receiver
+    factory which will, when called with a transport or sender, return
+    ``x(y(z(transport-or-sender)))``.
     """
     if not wrappers:
         raise TypeError('at least one argument is required')
-    def senderFactory(transport):
-        ret = wrappers[-1](transport)
+    def factory(arg):
+        ret = wrappers[-1](arg)
         for wrapper in wrappers[-2::-1]:
             ret = wrapper(ret)
         return ret
-    return senderFactory
-
-
-def stackReceivers(*wrappers):
-    """
-    Stack some receivers for ease of wrapping.
-
-    ``stackReceivers(x, y, z)`` will return a receiver factory which, when
-    called with a sender and parser, will return ``z(y(x(sender, parser)))``.
-    """
-    if not wrappers:
-        raise TypeError('at least one argument is required')
-    def receiverFactory(sender, parser):
-        ret = wrappers[-1](sender, parser)
-        for wrapper in wrappers[-2::-1]:
-            ret = wrapper(ret)
-        return ret
-    return receiverFactory
-
+    return factory
 
 __all__ = [
     'makeGrammar', 'wrapGrammar', 'unwrapGrammar', 'term', 'quasiterm',
-    'makeProtocol', 'stackSenders', 'stackReceivers',
+    'makeProtocol', 'stack',
 ]

test_parsley.py

@@ -12,68 +12,34 @@ def nullFactory(*args):
     return args
 
 
-class StackSendersTestCase(unittest.TestCase):
+class StackTestCase(unittest.TestCase):
     def test_onlyBase(self):
-        "stackSenders can be called with no wrappers."
-        fac = parsley.stackSenders(nullFactory)
+        "stack can be called with no wrappers."
+        fac = parsley.stack(nullFactory)
         self.assertEqual(fac('a'), ('a',))
 
     def test_oneWrapper(self):
-        "stackSenders can be called with one wrapper."
-        fac = parsley.stackSenders(wrapperFactory(0), nullFactory)
+        "stack can be called with one wrapper."
+        fac = parsley.stack(wrapperFactory(0), nullFactory)
         self.assertEqual(fac('a'), (0, ('a',)))
 
     def test_tenWrappers(self):
-        "stackSenders can be called with ten wrappers."
+        "stack can be called with ten wrappers."
         args = []
         result = 'a',
         for x in xrange(10):
             args.append(wrapperFactory(x))
             result = 9 - x, result
         args.append(nullFactory)
-        fac = parsley.stackSenders(*args)
+        fac = parsley.stack(*args)
         self.assertEqual(fac('a'), result)
 
     def test_failsWithNoBaseSender(self):
-        "stackSenders does require at least the base sender factory."
-        self.assertRaises(TypeError, parsley.stackSenders)
+        "stack does require at least the base factory."
+        self.assertRaises(TypeError, parsley.stack)
 
     def test_senderFactoriesTakeOneArgument(self):
-        "The callable returned by stackSenders takes exactly one argument."
-        fac = parsley.stackSenders(nullFactory)
+        "The callable returned by stack takes exactly one argument."
+        fac = parsley.stack(nullFactory)
         self.assertRaises(TypeError, fac)
         self.assertRaises(TypeError, fac, 'a', 'b')
-
-
-class StackReceiversTestCase(unittest.TestCase):
-    def test_onlyBase(self):
-        "stackReceivers can be called with no wrappers."
-        fac = parsley.stackReceivers(nullFactory)
-        self.assertEqual(fac('a', 'b'), ('a', 'b'))
-
-    def test_oneWrapper(self):
-        "stackReceivers can be called with one wrapper."
-        fac = parsley.stackReceivers(wrapperFactory(0), nullFactory)
-        self.assertEqual(fac('a', 'b'), (0, ('a', 'b')))
-
-    def test_tenWrappers(self):
-        "stackReceivers can be called with ten wrappers."
-        args = []
-        result = 'a', 'b'
-        for x in xrange(10):
-            args.append(wrapperFactory(x))
-            result = 9 - x, result
-        args.append(nullFactory)
-        fac = parsley.stackReceivers(*args)
-        self.assertEqual(fac('a', 'b'), result)
-
-    def test_failsWithNoBaseReceiver(self):
-        "stackReceivers does require at least the base receiver factory."
-        self.assertRaises(TypeError, parsley.stackReceivers)
-
-    def test_receiverFactoriesTakeTwoArguments(self):
-        "The callable returned by stackReceivers takes exactly two arguments."
-        fac = parsley.stackReceivers(nullFactory)
-        self.assertRaises(TypeError, fac)
-        self.assertRaises(TypeError, fac, 'a')
-        self.assertRaises(TypeError, fac, 'a', 'b', 'c')