Merge remote-tracking branch 'upstream/master' into rule_argument

Author: introom

.coveragerc

@@ -0,0 +1,9 @@
+[run]
+source =
+    ometa
+    parsley.py
+    examples/parsley_json.py
+    examples/protocol/netstrings.py
+omit =
+    ometa/_generated/*
+    *test*.py

.travis.yml

@@ -0,0 +1,13 @@
+language: python
+python:
+  - "2.6"
+  - "2.7"
+
+install:
+  - "pip install pytest Twisted coveralls . --use-mirrors"
+script:
+  - "coverage run $(which trial) test_parsley"
+  - "coverage run -a $(which trial) ometa"
+  - "coverage run -a $(which py.test) examples"
+after_success:
+  - "coveralls"

ometa/test/test_builder.py

@@ -325,7 +325,7 @@ def test_markAsTree(self):
         x = t.Rule("foo", t.List(
                 t.Exactly("x")))
         g = t.Grammar("TestGrammar", True, [x])
-        self.assertIn("\n        tree = True\n", writePython(g, ""))
+        self.assert_("\n        tree = True\n" in writePython(g, ""))
 
 
     def test_rule(self):

ometa/test/test_runtime.py

@@ -1,4 +1,4 @@
-import unittest
+from twisted.trial import unittest
 from ometa.runtime import OMetaBase, ParseError, expected, eof
 
 class RuntimeTests(unittest.TestCase):
@@ -53,10 +53,9 @@ def test_exactlyFail(self):
 
         data = "foo"
         o = OMetaBase(data)
-        with self.assertRaises(ParseError) as e:
-            o.rule_exactly("g")
-        self.assertEquals(e.exception[1], expected(None, "g"))
-        self.assertEquals(e.exception[0], 0)
+        exc = self.assertRaises(ParseError, o.rule_exactly, "g")
+        self.assertEquals(exc[1], expected(None, "g"))
+        self.assertEquals(exc[0], 0)
 
 
 
@@ -83,10 +82,9 @@ def test_tokenFailed(self):
         """
         data = "foozle"
         o = OMetaBase(data)
-        with self.assertRaises(ParseError) as e:
-            o.rule_token("fog")
-        self.assertEqual(e.exception[0], 2)
-        self.assertEqual(e.exception[1], expected("token", "fog"))
+        exc = self.assertRaises(ParseError, o.rule_token, "fog")
+        self.assertEqual(exc[0], 2)
+        self.assertEqual(exc[1], expected("token", "fog"))
 
 
     def test_many(self):
@@ -135,12 +133,15 @@ def test_orSimpleFailure(self):
         data = "foozle"
         o = OMetaBase(data)
 
-        with self.assertRaises(ParseError) as e:
-            o._or([lambda: o.token("fog"),
-                   lambda: o.token("foozik"),
-                   lambda: o.token("woozle")])
-        self.assertEqual(e.exception[0], 4)
-        self.assertEqual(e.exception[1], expected("token",  "foozik"))
+        exc = self.assertRaises(
+            ParseError, o._or, [
+                lambda: o.token("fog"),
+                lambda: o.token("foozik"),
+                lambda: o.token("woozle")
+            ]
+        )
+        self.assertEqual(exc[0], 4)
+        self.assertEqual(exc[1], expected("token",  "foozik"))
 
 
     def test_orFalseSuccess(self):
@@ -183,10 +184,9 @@ def test_notError(self):
 
         data = "xy"
         o = OMetaBase(data)
-        with self.assertRaises(ParseError) as e:
-            o._not(lambda: o.exactly("x"))
-        self.assertEqual(e.exception[0], 1)
-        self.assertEqual(e.exception[1], None)
+        exc = self.assertRaises(ParseError, o._not, lambda: o.exactly("x"))
+        self.assertEqual(exc[0], 1)
+        self.assertEqual(exc[1], None)
 
 
     def test_spaces(self):
@@ -216,9 +216,9 @@ def test_predFailure(self):
         """
 
         o = OMetaBase("")
-        with self.assertRaises(ParseError) as e:
-            o.pred(lambda: (False, ParseError(o.input, 0, None)))
-        self.assertEqual(e.exception, ParseError(o.input, 0, None))
+        exc = self.assertRaises(
+            ParseError, o.pred, lambda: (False, ParseError(o.input, 0, None)))
+        self.assertEqual(exc, ParseError(o.input, 0, None))
 
 
     def test_end(self):
@@ -227,9 +227,8 @@ def test_end(self):
         if input is left.
         """
         o = OMetaBase("abc")
-        with self.assertRaises(ParseError) as e:
-            o.rule_end()
-        self.assertEqual(e.exception, ParseError(o.input, 1, None))
+        exc = self.assertRaises(ParseError, o.rule_end)
+        self.assertEqual(exc, ParseError(o.input, 1, None))
         o.many(o.rule_anything)
         self.assertEqual(o.rule_end(), (True, ParseError("abc", 3, None)))
 
@@ -242,9 +241,9 @@ def test_label(self):
         data = "ooops"
         label = 'CustomLabel'
         o = OMetaBase(data)
-        with self.assertRaises(ParseError) as e:
-            o.label(lambda: o.rule_exactly('x'), label)
-        self.assertEqual(e.exception,
+        exc = self.assertRaises(
+            ParseError, o.label, lambda: o.rule_exactly('x'), label)
+        self.assertEqual(exc,
                          ParseError(o.input, 0, expected(label)).withMessage([("Custom Exception:", label, None)]))
 
     def test_letter(self):
@@ -254,9 +253,8 @@ def test_letter(self):
         o = OMetaBase("a1")
         v, e = o.rule_letter()
         self.assertEqual((v, e), ("a", ParseError(o.input, 0, None)))
-        with self.assertRaises(ParseError) as e:
-            o.rule_letter()
-        self.assertEqual(e.exception, ParseError(o.input, 1,
+        exc = self.assertRaises(ParseError, o.rule_letter)
+        self.assertEqual(exc, ParseError(o.input, 1,
                                                  expected("letter")))
 
 
@@ -269,9 +267,8 @@ def test_letterOrDigit(self):
         self.assertEqual((v, e), ("a", ParseError(None, 0, None)))
         v, e = o.rule_letterOrDigit()
         self.assertEqual((v, e), ("1", ParseError(None, 1, None)))
-        with self.assertRaises(ParseError) as e:
-            o.rule_letterOrDigit()
-        self.assertEqual(e.exception,
+        exc = self.assertRaises(ParseError, o.rule_letterOrDigit)
+        self.assertEqual(exc,
                          ParseError(o.input, 2, expected("letter or digit")))
 
 
@@ -282,9 +279,8 @@ def test_digit(self):
         o = OMetaBase("1a")
         v, e = o.rule_digit()
         self.assertEqual((v, e), ("1", ParseError("1a", 0, None)))
-        with self.assertRaises(ParseError) as e:
-            o.rule_digit()
-        self.assertEqual(e.exception, ParseError(o.input, 1, expected("digit")))
+        exc = self.assertRaises(ParseError, o.rule_digit)
+        self.assertEqual(exc, ParseError(o.input, 1, expected("digit")))