Rename private messages to terms

Author: stasm

fluent/syntax/ast.py

@@ -176,6 +176,15 @@ def __init__(self, id, value=None, attributes=None,
         self.attributes = attributes or []
         self.comment = comment
 
+class Term(Entry):
+    def __init__(self, id, value, attributes=None,
+                 comment=None, **kwargs):
+        super(Term, self).__init__(**kwargs)
+        self.id = id
+        self.value = value
+        self.attributes = attributes or []
+        self.comment = comment
+
 class Pattern(SyntaxNode):
     def __init__(self, elements, **kwargs):
         super(Pattern, self).__init__(**kwargs)

fluent/syntax/errors.py

@@ -43,9 +43,9 @@ def get_error_message(code, args):
     if code == 'E0017':
         return 'Variants cannot be used as selectors'
     if code == 'E0018':
-        return 'Attributes of public messages cannot be used as selectors'
+        return 'Attributes of messages cannot be used as selectors'
     if code == 'E0019':
-        return 'Attributes of private messages cannot be used as placeables'
+        return 'Attributes of terms cannot be used as placeables'
     if code == 'E0020':
         return 'Unterminated string expression'
     return code

fluent/syntax/ftlstream.py

@@ -88,7 +88,7 @@ def is_char_id_start(self, ch=None):
         return (cc >= 97 and cc <= 122) or \
                (cc >= 65 and cc <= 90)
 
-    def is_message_id_start(self):
+    def is_entry_id_start(self):
         if self.current_is('-'):
             self.peek()
 
@@ -240,15 +240,15 @@ def skip_to_next_entry_start(self):
                 self.next()
 
                 if self.ch is None or \
-                   self.is_message_id_start() or \
+                   self.is_entry_id_start() or \
                    self.current_is('#') or \
                    (self.current_is('/') and self.peek_char_is('/')) or \
                    (self.current_is('[') and self.peek_char_is('[')):
                     break
             self.next()
 
-    def take_id_start(self, allow_private):
-        if allow_private and self.current_is('-'):
+    def take_id_start(self, allow_term):
+        if allow_term and self.current_is('-'):
             self.next()
             return '-'
 
@@ -257,7 +257,7 @@ def take_id_start(self, allow_private):
             self.next()
             return ret
 
-        allowed_range = 'a-zA-Z-' if allow_private else 'a-zA-Z'
+        allowed_range = 'a-zA-Z-' if allow_term else 'a-zA-Z'
         raise ParseError('E0004', allowed_range)
 
     def take_id_char(self):

fluent/syntax/parser.py

@@ -106,7 +106,7 @@ def get_entry(self, ps):
                 return ast.GroupComment(comment.content)
             return None
 
-        if ps.is_message_id_start() \
+        if ps.is_entry_id_start() \
            and (comment is None or isinstance(comment, ast.Comment)):
             return self.get_message(ps, comment)
 
@@ -200,7 +200,7 @@ def skip_section(self, ps):
 
     @with_span
     def get_message(self, ps, comment):
-        id = self.get_private_identifier(ps)
+        id = self.get_entry_identifier(ps)
 
         ps.skip_inline_ws()
 
@@ -221,14 +221,17 @@ def get_message(self, ps, comment):
         if pattern is None and attrs is None:
             raise ParseError('E0005', id.name)
 
+        if id.name.startswith('-'):
+            return ast.Term(id, pattern, attrs, comment)
+
         return ast.Message(id, pattern, attrs, comment)
 
     @with_span
     def get_attribute(self, ps):
         ps.expect_indent()
         ps.expect_char('.')
 
-        key = self.get_public_identifier(ps)
+        key = self.get_identifier(ps)
 
         ps.skip_inline_ws()
         ps.expect_char('=')
@@ -251,18 +254,14 @@ def get_attributes(self, ps):
                 break
         return attrs
 
-    @with_span
-    def get_private_identifier(self, ps):
+    def get_entry_identifier(self, ps):
         return self.get_identifier(ps, True)
 
     @with_span
-    def get_public_identifier(self, ps):
-        return self.get_identifier(ps, False)
-
-    def get_identifier(self, ps, allow_private):
+    def get_identifier(self, ps, allow_term=False):
         name = ''
 
-        name += ps.take_id_start(allow_private)
+        name += ps.take_id_start(allow_term)
 
         ch = ps.take_id_char()
         while ch:
@@ -501,7 +500,7 @@ def get_selector_expression(self, ps):
 
         if (ch == '.'):
             ps.next()
-            attr = self.get_public_identifier(ps)
+            attr = self.get_identifier(ps)
             return ast.AttributeExpression(literal.id, attr)
 
         if (ch == '['):
@@ -603,10 +602,10 @@ def get_literal(self, ps):
 
         if ch == '$':
             ps.next()
-            name = self.get_public_identifier(ps)
+            name = self.get_identifier(ps)
             return ast.ExternalArgument(name)
-        elif ps.is_message_id_start():
-            name = self.get_private_identifier(ps)
+        elif ps.is_entry_id_start():
+            name = self.get_entry_identifier(ps)
             return ast.MessageReference(name)
         elif ps.is_number_start():
             return self.get_number(ps)

fluent/syntax/serializer.py

@@ -39,6 +39,8 @@ def serialize(self, resource):
     def serialize_entry(self, entry, state=0):
         if isinstance(entry, ast.Message):
             return serialize_message(entry)
+        if isinstance(entry, ast.Term):
+            return serialize_message(entry)
         if isinstance(entry, ast.Comment):
             if state & self.HAS_ENTRIES:
                 return "\n{}\n\n".format(serialize_comment(entry))

tests/syntax/fixtures_behavior/private_message.ftl renamed to tests/syntax/fixtures_behavior/term.ftl

@@ -2,7 +2,7 @@
   "type": "Resource",
   "body": [
     {
-      "type": "Message",
+      "type": "Term",
       "annotations": [],
       "id": {
         "type": "Identifier",

tests/syntax/fixtures_structure/private_message.ftl renamed to tests/syntax/fixtures_structure/term.ftl

@@ -31,6 +31,12 @@ def test_simple_message(self):
         """
         self.assertEqual(self.pretty_ftl(input), dedent_ftl(input))
 
+    def test_simple_term(self):
+        input = """\
+            -foo = Foo
+        """
+        self.assertEqual(self.pretty_ftl(input), dedent_ftl(input))
+
     def test_two_simple_messages(self):
         input = """\
             foo = Foo
@@ -52,6 +58,12 @@ def test_message_reference(self):
         """
         self.assertEqual(self.pretty_ftl(input), dedent_ftl(input))
 
+    def test_term_reference(self):
+        input = """\
+            foo = Foo { -bar }
+        """
+        self.assertEqual(self.pretty_ftl(input), dedent_ftl(input))
+
     def test_external_argument(self):
         input = """\
             foo = Foo { $bar }
@@ -72,7 +84,7 @@ def test_string_element(self):
 
     def test_variant_expression(self):
         input = """\
-            foo = Foo { bar[baz] }
+            foo = Foo { -bar[baz] }
         """
         self.assertEqual(self.pretty_ftl(input), dedent_ftl(input))