Allow CONCAT(*elements) and CONCAT(elements=[…]) (#45)

CONCAT used to override FTL.BaseNode.traverse and FTL.BaseNode.to_json because
of its use of the *elements varargs in __init__.

Overriding to_json isn't required because the base mathod already supports
lists.

For traverse, we allow CONCAT to be constructed with both the *elements
varargs (useful when writing migration specs) and with the elements=[…] keyword
arg (used by traverse because elements is an attribute of CONCAT instances).

Author: stasm

fluent/migrate/transforms.py

@@ -277,43 +277,16 @@ def createVariant(zipped_enum):
 
 
 class CONCAT(Transform):
-    """Concatenate elements of many patterns."""
+    """Create a new Pattern from Patterns, PatternElements and Expressions."""
 
-    def __init__(self, *patterns):
-        self.patterns = list(patterns)
+    def __init__(self, *elements, **kwargs):
+        # We want to support both passing elements as *elements in the
+        # migration specs and as elements=[]. The latter is used by
+        # FTL.BaseNode.traverse when it recreates the traversed node using its
+        # attributes as kwargs.
+        self.elements = list(kwargs.get('elements', elements))
 
     def __call__(self, ctx):
-        elements = self.flatten_elements(self.patterns)
+        elements = self.flatten_elements(self.elements)
         elements = self.prune_text_elements(elements)
         return FTL.Pattern(elements)
-
-    def traverse(self, fun):
-        def visit(value):
-            if isinstance(value, FTL.BaseNode):
-                return value.traverse(fun)
-            if isinstance(value, list):
-                return fun(map(visit, value))
-            else:
-                return fun(value)
-
-        node = self.__class__(
-            *[
-                visit(value) for value in self.patterns
-            ]
-        )
-
-        return fun(node)
-
-    def to_json(self):
-        def to_json(value):
-            if isinstance(value, FTL.BaseNode):
-                return value.to_json()
-            else:
-                return value
-
-        return {
-            'type': self.__class__.__name__,
-            'patterns': [
-                to_json(value) for value in self.patterns
-            ]
-        }

fluent/syntax/ast.py

@@ -66,12 +66,10 @@ def visit(value):
             else:
                 return fun(value)
 
+        # Use all attributes found on the node as kwargs to the constructor.
+        kwargs = vars(self).items()
         node = self.__class__(
-            **{
-                name: visit(value)
-                for name, value in vars(self).items()
-            }
-        )
+            **{name: visit(value) for name, value in kwargs})
 
         return fun(node)
 

tests/migrate/test_concat.py

@@ -157,7 +157,7 @@ def setUp(self):
             <!ENTITY channel.description.end    " channel.">
         ''')
 
-    def test_concat_replace(self):
+    def test_concat_placeable(self):
         msg = FTL.Message(
             FTL.Identifier('channel-desc'),
             value=CONCAT(
@@ -174,6 +174,23 @@ def test_concat_replace(self):
             ''')
         )
 
+    def test_concat_expression(self):
+        msg = FTL.Message(
+            FTL.Identifier('channel-desc'),
+            value=CONCAT(
+                COPY('test.properties', 'channel.description.start'),
+                EXTERNAL_ARGUMENT('channelname'),
+                COPY('test.properties', 'channel.description.end'),
+            )
+        )
+
+        self.assertEqual(
+            evaluate(self, msg).to_json(),
+            ftl_message_to_json('''
+                channel-desc = You are on the { $channelname } channel.
+            ''')
+        )
+
 
 @unittest.skipUnless(DTDParser, 'compare-locales required')
 class TestConcatReplace(MockContext):

tests/migrate/test_util.py

@@ -27,11 +27,11 @@ def test_copy_concat(self):
         result = node.traverse(lambda x: x)
 
         self.assertEqual(
-            result.value.patterns[0].key,
+            result.value.elements[0].key,
             'key1'
         )
         self.assertEqual(
-            result.value.patterns[1].key,
+            result.value.elements[1].key,
             'key2'
         )