Uplift tests from fluent and fluent.js

* Uplift tests for selector expression validation, fixes #122

* Uplift billion laughs from fluent.js, abort early

This ports projectfluent/fluent.js#395,
which returns with an empty `FluentNone`, and does so early by
raising an exception.

Author: Pike

fluent.runtime/fluent/runtime/__init__.py

@@ -81,7 +81,12 @@ def format(self, message_id, args=None):
         env = ResolverEnvironment(context=self,
                                   current=CurrentEnvironment(args=fluent_args),
                                   errors=errors)
-        return [resolve(env), errors]
+        try:
+            result = resolve(env)
+        except ValueError as e:
+            errors.append(e)
+            result = '{???}'
+        return [result, errors]
 
     def _get_babel_locale(self):
         for l in self.locales:

fluent.runtime/fluent/runtime/resolver.py

@@ -111,15 +111,13 @@ def __call__(self, env):
         if self in env.active_patterns:
             env.errors.append(FluentCyclicReferenceError("Cyclic reference"))
             return FluentNone()
-        if env.part_count > self.MAX_PARTS:
-            return ""
         env.active_patterns.add(self)
         elements = self.elements
         remaining_parts = self.MAX_PARTS - env.part_count
         if len(self.elements) > remaining_parts:
-            elements = elements[:remaining_parts + 1]
-            env.errors.append(ValueError("Too many parts in message (> {0}), "
-                                         "aborting.".format(self.MAX_PARTS)))
+            env.active_patterns.remove(self)
+            raise ValueError("Too many parts in message (> {0}), "
+                             "aborting.".format(self.MAX_PARTS))
         retval = ''.join(
             resolve(element(env), env) for element in elements
         )
@@ -133,7 +131,10 @@ def resolve(fluentish, env):
         return fluentish.format(env.context._babel_locale)
     if isinstance(fluentish, six.string_types):
         if len(fluentish) > MAX_PART_LENGTH:
-            return fluentish[:MAX_PART_LENGTH]
+            raise ValueError(
+                "Too many characters in placeable "
+                "({}, max allowed is {})".format(len(fluentish), Pattern.MAX_PARTS)
+            )
     return fluentish
 
 

fluent.runtime/tests/test_bomb.py

@@ -32,12 +32,14 @@ def setUp(self):
 
     def test_max_length_protection(self):
         val, errs = self.ctx.format('lolz')
-        self.assertEqual(val, ('0123456789' * 1000)[0:2500])
+        self.assertEqual(val, '{???}')
         self.assertNotEqual(len(errs), 0)
+        self.assertIn('Too many characters', str(errs[-1]))
 
     def test_max_expansions_protection(self):
         # Without protection, emptylolz will take a really long time to
         # evaluate, although it generates an empty message.
         val, errs = self.ctx.format('emptylolz')
-        self.assertEqual(val, '')
+        self.assertEqual(val, '{???}')
         self.assertEqual(len(errs), 1)
+        self.assertIn('Too many parts', str(errs[-1]))

fluent.syntax/fluent/syntax/errors.py

@@ -65,4 +65,6 @@ def get_error_message(code, args):
         return 'Unbalanced closing brace in TextElement.'
     if code == 'E0028':
         return 'Expected an inline expression'
+    if code == 'E0029':
+        return 'Expected simple expression as selector'
     return code

fluent.syntax/fluent/syntax/parser.py

@@ -508,11 +508,20 @@ def get_expression(self, ps):
                 else:
                     raise ParseError('E0018')
 
-            if (
+            elif (
                 isinstance(selector, ast.TermReference)
-                and selector.attribute is None
             ):
-                raise ParseError('E0017')
+                if selector.attribute is None:
+                    raise ParseError('E0017')
+            elif not (
+                isinstance(selector, (
+                    ast.StringLiteral,
+                    ast.NumberLiteral,
+                    ast.VariableReference,
+                    ast.FunctionReference,
+                ))
+            ):
+                raise ParseError('E0029')
 
             ps.next()
             ps.next()

fluent.syntax/tests/syntax/fixtures_reference/select_expressions.ftl

@@ -21,6 +21,20 @@ invalid-selector-term-variant =
        *[key] value
     }
 
+# ERROR Nested expressions are not valid selectors
+invalid-selector-select-expression =
+    { { 3 } ->
+        *[key] default
+    }
+
+# ERROR Select expressions are not valid selectors
+invalid-selector-nested-expression =
+    { { $sel ->
+        *[key] value
+        } ->
+        *[key] default
+    }
+
 empty-variant =
     { $sel ->
        *[key] {""}

fluent.syntax/tests/syntax/fixtures_reference/select_expressions.json

@@ -145,6 +145,24 @@
             "annotations": [],
             "content": "invalid-selector-term-variant =\n    { -term(case: \"nominative\") ->\n       *[key] value\n    }\n\n"
         },
+        {
+            "type": "Comment",
+            "content": "ERROR Nested expressions are not valid selectors"
+        },
+        {
+            "type": "Junk",
+            "annotations": [],
+            "content": "invalid-selector-select-expression =\n    { { 3 } ->\n        *[key] default\n    }\n\n"
+        },
+        {
+            "type": "Comment",
+            "content": "ERROR Select expressions are not valid selectors"
+        },
+        {
+            "type": "Junk",
+            "annotations": [],
+            "content": "invalid-selector-nested-expression =\n    { { $sel ->\n        *[key] value\n        } ->\n        *[key] default\n    }\n\n"
+        },
         {
             "type": "Message",
             "id": {