Refactor resolver into a tree of callable objects, or partially evaluated (#95)

Author: Pike

fluent.runtime/fluent/runtime/__init__.py

@@ -8,8 +8,9 @@
 from fluent.syntax.ast import Message, Term
 
 from .builtins import BUILTINS
-from .resolver import resolve
-from .utils import ATTRIBUTE_SEPARATOR, TERM_SIGIL, add_message_and_attrs_to_store, ast_to_id
+from .prepare import Compiler
+from .resolver import ResolverEnvironment, CurrentEnvironment
+from .utils import ATTRIBUTE_SEPARATOR, TERM_SIGIL, ast_to_id, native_to_fluent
 
 
 class FluentBundle(object):
@@ -33,6 +34,8 @@ def __init__(self, locales, functions=None, use_isolating=True):
         self._functions = _functions
         self._use_isolating = use_isolating
         self._messages_and_terms = {}
+        self._compiled = {}
+        self._compiler = Compiler(use_isolating=use_isolating)
         self._babel_locale = self._get_babel_locale()
         self._plural_form = babel.plural.to_python(self._babel_locale.plural_form)
 
@@ -44,22 +47,41 @@ def add_messages(self, source):
             if isinstance(item, (Message, Term)):
                 full_id = ast_to_id(item)
                 if full_id not in self._messages_and_terms:
-                    # We add attributes to the store to enable faster looker
-                    # later, and more direct code in some instances.
-                    add_message_and_attrs_to_store(self._messages_and_terms, full_id, item)
+                    self._messages_and_terms[full_id] = item
 
     def has_message(self, message_id):
         if message_id.startswith(TERM_SIGIL) or ATTRIBUTE_SEPARATOR in message_id:
             return False
         return message_id in self._messages_and_terms
 
+    def lookup(self, full_id):
+        if full_id not in self._compiled:
+            entry_id = full_id.split(ATTRIBUTE_SEPARATOR, 1)[0]
+            entry = self._messages_and_terms[entry_id]
+            compiled = self._compiler(entry)
+            if compiled.value is not None:
+                self._compiled[entry_id] = compiled.value
+            for attr in compiled.attributes:
+                self._compiled[ATTRIBUTE_SEPARATOR.join([entry_id, attr.id.name])] = attr.value
+        return self._compiled[full_id]
+
     def format(self, message_id, args=None):
         if message_id.startswith(TERM_SIGIL):
             raise LookupError(message_id)
-        message = self._messages_and_terms[message_id]
-        if args is None:
-            args = {}
-        return resolve(self, message, args)
+        if args is not None:
+            fluent_args = {
+                argname: native_to_fluent(argvalue)
+                for argname, argvalue in args.items()
+            }
+        else:
+            fluent_args = {}
+
+        errors = []
+        resolve = self.lookup(message_id)
+        env = ResolverEnvironment(context=self,
+                                  current=CurrentEnvironment(args=fluent_args),
+                                  errors=errors)
+        return [resolve(env), errors]
 
     def _get_babel_locale(self):
         for l in self.locales:

fluent.runtime/fluent/runtime/prepare.py

@@ -0,0 +1,53 @@
+from __future__ import absolute_import, unicode_literals
+from fluent.syntax import ast as FTL
+from . import resolver
+
+
+class Compiler(object):
+    def __init__(self, use_isolating=False):
+        self.use_isolating = use_isolating
+
+    def __call__(self, item):
+        if isinstance(item, FTL.BaseNode):
+            return self.compile(item)
+        if isinstance(item, (tuple, list)):
+            return [self(elem) for elem in item]
+        return item
+
+    def compile(self, node):
+        nodename = type(node).__name__
+        if not hasattr(resolver, nodename):
+            return node
+        kwargs = vars(node).copy()
+        for propname, propvalue in kwargs.items():
+            kwargs[propname] = self(propvalue)
+        handler = getattr(self, 'compile_' + nodename, self.compile_generic)
+        return handler(nodename, **kwargs)
+
+    def compile_generic(self, nodename, **kwargs):
+        return getattr(resolver, nodename)(**kwargs)
+
+    def compile_Placeable(self, _, expression, **kwargs):
+        if self.use_isolating:
+            return resolver.IsolatingPlaceable(expression=expression, **kwargs)
+        if isinstance(expression, resolver.Literal):
+            return expression
+        return resolver.Placeable(expression=expression, **kwargs)
+
+    def compile_Pattern(self, _, elements, **kwargs):
+        if (
+            len(elements) == 1 and
+            isinstance(elements[0], resolver.IsolatingPlaceable)
+        ):
+            # Don't isolate isolated placeables
+            return elements[0].expression
+        if any(
+            not isinstance(child, resolver.Literal)
+            for child in elements
+        ):
+            return resolver.Pattern(elements=elements, **kwargs)
+        if len(elements) == 1:
+            return elements[0]
+        return resolver.TextElement(
+            ''.join(child(None) for child in elements)
+        )

fluent.runtime/fluent/runtime/resolver.py

@@ -81,7 +81,7 @@ class NumberFormatOptions(object):
     maximumSignificantDigits = attr.ib(default=None)
 
 
-class FluentNumber(object):
+class FluentNumber(FluentType):
 
     default_number_format_options = NumberFormatOptions()
 
@@ -276,7 +276,7 @@ class DateFormatOptions(object):
 _SUPPORTED_DATETIME_OPTIONS = ['dateStyle', 'timeStyle', 'timeZone']
 
 
-class FluentDateType(object):
+class FluentDateType(FluentType):
     # We need to match signature of `__init__` and `__new__` due to the way
     # some Python implementation (e.g. PyPy) implement some methods.
     # So we leave those alone, and implement another `_init_options`

fluent.runtime/fluent/runtime/types.py

@@ -1,5 +1,11 @@
+from __future__ import absolute_import, unicode_literals
+
+from datetime import date, datetime
+from decimal import Decimal
+
 from fluent.syntax.ast import AttributeExpression, Term, TermReference
 
+from .types import FluentInt, FluentFloat, FluentDecimal, FluentDate, FluentDateTime
 from .errors import FluentReferenceError
 
 TERM_SIGIL = '-'
@@ -15,26 +21,22 @@ def ast_to_id(ast):
     return ast.id.name
 
 
-def add_message_and_attrs_to_store(store, ref_id, item, is_parent=True):
-    store[ref_id] = item
-    if is_parent:
-        for attr in item.attributes:
-            add_message_and_attrs_to_store(store,
-                                           _make_attr_id(ref_id, attr.id.name),
-                                           attr,
-                                           is_parent=False)
-
-
-def numeric_to_native(val):
+def native_to_fluent(val):
     """
-    Given a numeric string (as defined by fluent spec),
-    return an int or float
+    Convert a python type to a Fluent Type.
     """
-    # val matches this EBNF:
-    #  '-'? [0-9]+ ('.' [0-9]+)?
-    if '.' in val:
-        return float(val)
-    return int(val)
+    if isinstance(val, int):
+        return FluentInt(val)
+    if isinstance(val, float):
+        return FluentFloat(val)
+    if isinstance(val, Decimal):
+        return FluentDecimal(val)
+
+    if isinstance(val, datetime):
+        return FluentDateTime.from_date_time(val)
+    if isinstance(val, date):
+        return FluentDate.from_date(val)
+    return val
 
 
 def reference_to_id(ref):

fluent.runtime/fluent/runtime/utils.py

@@ -2,12 +2,6 @@
 from setuptools import setup
 import sys
 
-if sys.version_info < (3, 4):
-    extra_requires = ['singledispatch>=3.4']
-else:
-    # functools.singledispatch is in stdlib from Python 3.4 onwards.
-    extra_requires = []
-
 setup(name='fluent.runtime',
       version='0.1',
       description='Localization library for expressive translations.',
@@ -26,11 +20,11 @@
       ],
       packages=['fluent', 'fluent.runtime'],
       install_requires=[
-          'fluent.syntax>=0.10,<=0.11',
+          'fluent.syntax>=0.12,<=0.13',
           'attrs',
           'babel',
           'pytz',
-      ] + extra_requires,
+      ],
       tests_require=['six'],
       test_suite='tests'
       )

fluent.runtime/setup.py

@@ -39,5 +39,5 @@ 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)

fluent.runtime/tests/test_bomb.py

@@ -6,10 +6,8 @@ skipsdist=True
 setenv =
     PYTHONPATH = {toxinidir}
 deps =
-     fluent.syntax>=0.10,<=0.11
+     fluent.syntax>=0.12,<=0.13
      six
      attrs
      Babel
-     py27: singledispatch
-     pypy: singledispatch
 commands = ./runtests.py