Merge pull request #24 from washort/parser-protocol

Add Twisted protocol interoperability to ometa and parsley

Author: washort

examples/protocol/netstring_reversal.py

@@ -0,0 +1,38 @@
+from twisted.internet.defer import Deferred
+from twisted.internet.endpoints import TCP4ServerEndpoint
+from twisted.internet.protocol import ServerFactory
+from twisted.internet.task import react
+
+from parsley import makeProtocol
+from netstrings import grammar, NetstringSender
+
+
+class NetstringReverserReceiver(object):
+    def __init__(self, sender, parser):
+        self.sender = sender
+
+    def connectionMade(self):
+        pass
+
+    def connectionLost(self, reason):
+        pass
+
+    def netstringReceived(self, string):
+        self.sender.sendNetstring(string[::-1])
+
+
+NetstringReverser = makeProtocol(
+    grammar, NetstringSender, NetstringReverserReceiver)
+
+
+class NetstringReverserFactory(ServerFactory):
+    protocol = NetstringReverser
+
+
+def main(reactor):
+    server = TCP4ServerEndpoint(reactor, 1234)
+    d = server.listen(NetstringReverserFactory())
+    d.addCallback(lambda p: Deferred())
+    return d
+
+react(main, [])

examples/protocol/netstrings.py

@@ -0,0 +1,18 @@
+grammar = """
+
+digit = anything:x ?(x.isdigit())
+nonzeroDigit = anything:x ?(x != '0' and x.isdigit())
+digits = <'0' | nonzeroDigit digit*>:i -> int(i)
+
+netstring = digits:length ':' <anything{length}>:string ',' -> string
+
+initial = netstring:string -> receiver.netstringReceived(string)
+
+"""
+
+class NetstringSender(object):
+    def __init__(self, transport):
+        self.transport = transport
+
+    def sendNetstring(self, string):
+        self.transport.write('%d:%s,' % (len(string), string))

examples/protocol/test_netstrings.py

@@ -0,0 +1,118 @@
+from twisted.test.proto_helpers import StringTransport
+
+import parsley
+import pytest
+import netstrings
+
+netstringGrammar = parsley.makeGrammar(netstrings.grammar, {})
+
+def stringParserFromRule(rule):
+    def parseString(s):
+        return getattr(netstringGrammar(s), rule)()
+    return parseString
+
+def test_digits_parsing():
+    parse = stringParserFromRule('digits')
+
+    assert parse('0') == 0
+    assert parse('1') == 1
+    assert parse('1234567890') == 1234567890
+    with pytest.raises(parsley.ParseError):
+        parse('01')
+    with pytest.raises(parsley.ParseError):
+        parse('0001')
+
+def test_netstring_parsing():
+    parse = stringParserFromRule('netstring')
+
+    assert parse('0:,') == ''
+    assert parse('1:x,') == 'x'
+    assert parse('10:abcdefghij,') == 'abcdefghij'
+
+
+def build_testing_sender():
+    transport = StringTransport()
+    sender = netstrings.NetstringSender(transport)
+    return sender, transport
+
+def test_sending_empty_netstring():
+    sender, transport = build_testing_sender()
+    sender.sendNetstring('')
+    assert transport.value() == '0:,'
+
+def test_sending_one_netstring():
+    sender, transport = build_testing_sender()
+    sender.sendNetstring('foobar')
+    assert transport.value() == '6:foobar,'
+
+def test_sending_two_netstrings():
+    sender, transport = build_testing_sender()
+    sender.sendNetstring('spam')
+    sender.sendNetstring('egggs')
+    assert transport.value() == '4:spam,5:egggs,'
+
+
+class FakeReceiver(object):
+    def __init__(self, sender, parser):
+        self.sender = sender
+        self.parser = parser
+        self.netstrings = []
+        self.connected = False
+        self.lossReason = None
+
+    def netstringReceived(self, s):
+        self.netstrings.append(s)
+
+    def connectionMade(self):
+        self.connected = True
+
+    def connectionLost(self, reason):
+        self.lossReason = reason
+
+TestingNetstringProtocol = parsley.makeProtocol(
+    netstrings.grammar, netstrings.NetstringSender, FakeReceiver)
+
+def build_testing_protocol():
+    protocol = TestingNetstringProtocol()
+    transport = StringTransport()
+    protocol.makeConnection(transport)
+    return protocol, transport
+
+def test_receiving_empty_netstring():
+    protocol, transport = build_testing_protocol()
+    protocol.dataReceived('0:,')
+    assert protocol.receiver.netstrings == ['']
+
+def test_receiving_one_netstring_by_byte():
+    protocol, transport = build_testing_protocol()
+    for c in '4:spam,':
+        protocol.dataReceived(c)
+    assert protocol.receiver.netstrings == ['spam']
+
+def test_receiving_two_netstrings_by_byte():
+    protocol, transport = build_testing_protocol()
+    for c in '4:spam,4:eggs,':
+        protocol.dataReceived(c)
+    assert protocol.receiver.netstrings == ['spam', 'eggs']
+
+def test_receiving_two_netstrings_in_chunks():
+    protocol, transport = build_testing_protocol()
+    for c in ['4:', 'spa', 'm,4', ':eg', 'gs,']:
+        protocol.dataReceived(c)
+    assert protocol.receiver.netstrings == ['spam', 'eggs']
+
+def test_receiving_two_netstrings_at_once():
+    protocol, transport = build_testing_protocol()
+    protocol.dataReceived('4:spam,4:eggs,')
+    assert protocol.receiver.netstrings == ['spam', 'eggs']
+
+def test_establishing_connection():
+    assert not FakeReceiver(None, None).connected
+    protocol, transport = build_testing_protocol()
+    assert protocol.receiver.connected
+
+def test_losing_connection():
+    protocol, transport = build_testing_protocol()
+    reason = object()
+    protocol.connectionLost(reason)
+    assert protocol.receiver.lossReason == reason

ometa/protocol.py

@@ -0,0 +1,56 @@
+from twisted.internet.protocol import Protocol
+from twisted.python.failure import Failure
+
+from ometa.interp import TrampolinedGrammarInterpreter, _feed_me
+
+class ParserProtocol(Protocol):
+    currentRule = 'initial'
+
+    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.connectionMade()
+        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
+
+    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()
+
+    def connectionLost(self, reason):
+        if self.disconnecting:
+            return
+        self.receiver.connectionLost(reason)
+        self.disconnecting = True