refactor lookup into bundle, change dirty, and make named arguments work

Author: Pike

fluent.runtime/fluent/runtime/__init__.py

@@ -56,16 +56,19 @@ def has_message(self, message_id):
             return False
         return message_id in self._messages_and_terms
 
+    def lookup(self, full_id):
+        if full_id not in self._compiled:
+            message = self._messages_and_terms[full_id]
+            self._compiled[full_id] = self._compiler(message.value)
+        return self._compiled[full_id]
+
     def format(self, message_id, args=None):
         if message_id.startswith(TERM_SIGIL):
             raise LookupError(message_id)
         if args is None:
             args = {}
-        if message_id not in self._compiled:
-            message = self._messages_and_terms[message_id]
-            self._compiled[message_id] = self._compiler(message.value)
-        resolve = self._compiled[message_id]
         errors = []
+        resolve = self.lookup(message_id)
         env = ResolverEnvironment(context=self,
                                   current=CurrentEnvironment(args=args),
                                   errors=errors)

fluent.runtime/fluent/runtime/resolver.py

@@ -9,7 +9,7 @@
 
 from fluent.syntax import ast as FTL
 from .errors import FluentCyclicReferenceError, FluentFormatError, FluentReferenceError
-from .types import FluentDateType, FluentNone, FluentNumber, fluent_date, fluent_number
+from .types import FluentType, FluentDateType, FluentNone, FluentNumber, fluent_date, fluent_number
 from .utils import numeric_to_native, reference_to_id, unknown_reference_error_obj
 
 try:
@@ -54,7 +54,6 @@ class CurrentEnvironment(object):
 class ResolverEnvironment(object):
     context = attr.ib()
     errors = attr.ib()
-    dirty = attr.ib(factory=set)
     part_count = attr.ib(default=0)
     current = attr.ib(factory=CurrentEnvironment)
 
@@ -141,11 +140,16 @@ def __call__(self, env):
             return FluentNone()
         self.dirty = True
         retval = ''.join(
-            element(env) for element in self.elements
+            self.resolve(element(env), env) for element in self.elements
         )
         self.dirty = False
         return retval
 
+    def resolve(self, fluentish, env):
+        if isinstance(fluentish, FluentType):
+            return fluentish.format(env.context._babel_locale)
+        return fluentish
+
 
 class TextElement(FTL.TextElement, Literal):
     def __call__(self, env):
@@ -189,17 +193,16 @@ def lookup_reference(ref, env):
     AST node, or FluentNone if not found, including fallback logic
     """
     ref_id = reference_to_id(ref)
-
     try:
-        return env.context._compiler(env.context._messages_and_terms[ref_id])
+        return env.context.lookup(ref_id)
     except LookupError:
         env.errors.append(unknown_reference_error_obj(ref_id))
 
         if isinstance(ref, AttributeExpression):
             # Fallback
             parent_id = reference_to_id(ref.ref)
             try:
-                return env.context._compiler(env.context._messages_and_terms[parent_id])
+                return env.context.lookup(parent_id)
             except LookupError:
                 # Don't add error here, because we already added error for the
                 # actual thing we were looking for.
@@ -330,10 +333,10 @@ def __call__(self, env):
 
         # TODO What to do if message is not a VariantList?
         # Need test at least.
-        assert isinstance(message.value, VariantList)
+        assert isinstance(message, VariantList)
 
         variant_name = self.key.name
-        return message.value.select_from_variant_list(env, variant_name)
+        return message.select_from_variant_list(env, variant_name)
 
 
 class CallExpression(FTL.CallExpression, BaseResolver):
@@ -365,6 +368,11 @@ def __call__(self, env):
             return FluentNoneResolver(function_name + "()")
 
 
+class NamedArgument(FTL.NamedArgument, BaseResolver):
+    def __call__(self, env):
+      return self.value(env)
+
+
 @handle.register(FluentNumber)
 def handle_fluent_number(number, env):
     return number.format(env.context._babel_locale)