Make ParserProtocol use TrampolinedParser.

Author: habnabit

ometa/protocol.py

@@ -1,53 +1,34 @@
 from twisted.internet.protocol import Protocol
 from twisted.python.failure import Failure
 
-from ometa.interp import TrampolinedGrammarInterpreter, _feed_me
+from ometa.tube import TrampolinedParser
 
-class ParserProtocol(Protocol):
-    currentRule = 'initial'
 
+class ParserProtocol(Protocol):
     def __init__(self, grammar, senderFactory, receiverFactory, bindings):
         self.grammar = grammar
         self.bindings = dict(bindings)
         self.senderFactory = senderFactory
         self.receiverFactory = receiverFactory
         self.disconnecting = False
 
-    def setNextRule(self, rule):
-        self.currentRule = rule
-
     def connectionMade(self):
         self.sender = self.senderFactory(self.transport)
-        self.bindings['receiver'] = self.receiver = self.receiverFactory(
-            self.sender, self)
+        self.receiver = self.receiverFactory(self.sender)
         self.receiver.prepareParsing()
-        self._setupInterp()
-
-    def _setupInterp(self):
-        self._interp = TrampolinedGrammarInterpreter(
-            self.grammar, self.currentRule, callback=self._parsedRule,
-            globals=self.bindings)
-
-    def _parsedRule(self, nextRule, position):
-        if nextRule is not None:
-            self.currentRule = nextRule
+        self.parser = TrampolinedParser(
+            self.grammar, self.receiver, self.bindings)
 
     def dataReceived(self, data):
         if self.disconnecting:
             return
 
-        while data:
-            try:
-                status = self._interp.receive(data)
-            except Exception:
-                self.connectionLost(Failure())
-                self.transport.abortConnection()
-                return
-            else:
-                if status is _feed_me:
-                    return
-            data = ''.join(self._interp.input.data[self._interp.input.position:])
-            self._setupInterp()
+        try:
+            self.parser.receive(data)
+        except Exception:
+            self.connectionLost(Failure())
+            self.transport.abortConnection()
+            return
 
     def connectionLost(self, reason):
         if self.disconnecting:

ometa/test/test_protocol.py

@@ -34,9 +34,10 @@ class SomeException(Exception):
 
 
 class ReceiverFactory(object):
-    def __init__(self, sender, parser):
+    currentRule = 'initial'
+
+    def __init__(self, sender):
         self.sender = sender
-        self.parser = parser
         self.calls = []
         self.returnMap = {}
         self.connected = False
@@ -47,7 +48,8 @@ def prepareParsing(self):
 
     def __call__(self, v):
         self.calls.append(v)
-        return self.returnMap.get(v)
+        if v in self.returnMap:
+            self.currentRule = self.returnMap[v]
 
     def raiseSomething(self):
         raise SomeException()
@@ -77,12 +79,6 @@ def test_transportPassed(self):
         self.protocol.makeConnection(transport)
         self.assertEqual(transport, self.protocol.sender.transport)
 
-    def test_parserPassed(self):
-        """The protocol is passed to the receiver."""
-        transport = object()
-        self.protocol.makeConnection(transport)
-        self.assertEqual(self.protocol, self.protocol.receiver.parser)
-
     def test_senderPassed(self):
         """The sender is passed to the receiver."""
         self.protocol.makeConnection(None)
@@ -133,29 +129,17 @@ def test_ruleSwitchingWithChunks(self):
         self.protocol.dataReceived('baa')
         self.assertEqual(self.protocol.receiver.calls, ['a', 'b', 'a'])
 
-    def test_ruleSwitchingViaReceiver(self):
+    def test_rulesCannotBeSwitchedDuringParsing(self):
         """
-        The receiver is able to set the the next rule to be parsed with the
-        parser passed to it.
+        One can set a new rule during parsing, but it won't change the rule
+        currently being parsed.
         """
         self.protocol.makeConnection(None)
         self.protocol.dataReceived('aa')
         self.assertEqual(self.protocol.receiver.calls, ['a'])
         self.protocol.dataReceived('a')
         self.assertEqual(self.protocol.receiver.calls, ['a'])
-        self.protocol.receiver.parser.setNextRule('someB')
-        self.protocol.dataReceived('abb')
-        self.assertEqual(self.protocol.receiver.calls, ['a', 'a', 'b'])
-
-    def test_ruleSwitchingViaReceiverGetsOverridden(self):
-        """Returning a new rule takes priority over calling setNextRule."""
-        self.protocol.makeConnection(None)
-        self.protocol.dataReceived('aa')
-        self.assertEqual(self.protocol.receiver.calls, ['a'])
-        self.protocol.dataReceived('a')
-        self.assertEqual(self.protocol.receiver.calls, ['a'])
-        self.protocol.receiver.parser.setNextRule('someB')
-        self.protocol.receiver.returnMap['a'] = 'someC'
+        self.protocol.receiver.currentRule = 'someC'
         self.protocol.dataReceived('acc')
         self.assertEqual(self.protocol.receiver.calls, ['a', 'a', 'c'])