Merge pull request #513 from stasm/fix-special-chars-start

* Port parser reference tests

projectfluent/fluent#313

* Don't drop to newline when patterns start with special chars

Author: stasm

fluent-bundle/test/fixtures_reference/special_chars.json

@@ -0,0 +1,19 @@
+{
+    "body": [
+        {
+            "id": "bracket-inline",
+            "value": "[Value]",
+            "attributes": {}
+        },
+        {
+            "id": "dot-inline",
+            "value": ".Value",
+            "attributes": {}
+        },
+        {
+            "id": "star-inline",
+            "value": "*Value",
+            "attributes": {}
+        }
+    ]
+}

fluent-syntax/src/serializer.ts

@@ -1,6 +1,6 @@
 import * as AST from "./ast.js";
 
-function indent(content: string): string {
+function indentExceptFirstLine(content: string): string {
   return content.split("\n").join("\n    ");
 }
 
@@ -13,6 +13,29 @@ function isSelectExpr(elem: AST.PatternElement): boolean {
     && elem.expression instanceof AST.SelectExpression;
 }
 
+function shouldStartOnNewLine(pattern: AST.Pattern): boolean {
+  const isMultiline =
+    pattern.elements.some(isSelectExpr) ||
+    pattern.elements.some(includesNewLine);
+
+  if (isMultiline) {
+    const firstElement = pattern.elements[0];
+    if (firstElement instanceof AST.TextElement) {
+      const firstChar = firstElement.value[0];
+      // Due to the indentation requirement these text characters may not appear
+      // as the first character on a new line.
+      if (firstChar === "[" || firstChar === "." || firstChar === "*") {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+
 // Bit masks representing the state of the serializer.
 export const HAS_ENTRIES = 1;
 
@@ -136,22 +159,19 @@ function serializeTerm(term: AST.Term): string {
 
 
 function serializeAttribute(attribute: AST.Attribute): string {
-  const value = indent(serializePattern(attribute.value));
+  const value = indentExceptFirstLine(serializePattern(attribute.value));
   return `\n    .${attribute.id.name} =${value}`;
 }
 
 
 function serializePattern(pattern: AST.Pattern): string {
   const content = pattern.elements.map(serializeElement).join("");
-  const startOnNewLine =
-    pattern.elements.some(isSelectExpr) ||
-    pattern.elements.some(includesNewLine);
 
-  if (startOnNewLine) {
-    return `\n    ${indent(content)}`;
+  if (shouldStartOnNewLine(pattern)) {
+    return `\n    ${indentExceptFirstLine(content)}`;
   }
 
-  return ` ${content}`;
+  return ` ${indentExceptFirstLine(content)}`;
 }
 
 
@@ -228,7 +248,7 @@ export function serializeExpression(expr: AST.Expression): string {
 
 function serializeVariant(variant: AST.Variant): string {
   const key = serializeVariantKey(variant.key);
-  const value = indent(serializePattern(variant.value));
+  const value = indentExceptFirstLine(serializePattern(variant.value));
 
   if (variant.default) {
     return `\n   *[${key}]${value}`;

fluent-syntax/test/fixtures_reference/special_chars.ftl

@@ -0,0 +1,14 @@
+## OK
+
+bracket-inline = [Value]
+dot-inline = .Value
+star-inline = *Value
+
+## ERRORS
+
+bracket-newline =
+    [Value]
+dot-newline =
+    .Value
+star-newline =
+    *Value

fluent-syntax/test/fixtures_reference/special_chars.json

@@ -0,0 +1,82 @@
+{
+    "type": "Resource",
+    "body": [
+        {
+            "type": "GroupComment",
+            "content": "OK"
+        },
+        {
+            "type": "Message",
+            "id": {
+                "type": "Identifier",
+                "name": "bracket-inline"
+            },
+            "value": {
+                "type": "Pattern",
+                "elements": [
+                    {
+                        "type": "TextElement",
+                        "value": "[Value]"
+                    }
+                ]
+            },
+            "attributes": [],
+            "comment": null
+        },
+        {
+            "type": "Message",
+            "id": {
+                "type": "Identifier",
+                "name": "dot-inline"
+            },
+            "value": {
+                "type": "Pattern",
+                "elements": [
+                    {
+                        "type": "TextElement",
+                        "value": ".Value"
+                    }
+                ]
+            },
+            "attributes": [],
+            "comment": null
+        },
+        {
+            "type": "Message",
+            "id": {
+                "type": "Identifier",
+                "name": "star-inline"
+            },
+            "value": {
+                "type": "Pattern",
+                "elements": [
+                    {
+                        "type": "TextElement",
+                        "value": "*Value"
+                    }
+                ]
+            },
+            "attributes": [],
+            "comment": null
+        },
+        {
+            "type": "GroupComment",
+            "content": "ERRORS"
+        },
+        {
+            "type": "Junk",
+            "annotations": [],
+            "content": "bracket-newline =\n    [Value]\n"
+        },
+        {
+            "type": "Junk",
+            "annotations": [],
+            "content": "dot-newline =\n    .Value\n"
+        },
+        {
+            "type": "Junk",
+            "annotations": [],
+            "content": "star-newline =\n    *Value\n"
+        }
+    ]
+}

fluent-syntax/test/serializer_test.js

@@ -188,6 +188,30 @@ suite("Serialize resource", function() {
     assert.strictEqual(pretty(input), input);
   });
 
+  test("multiline starting inline", function() {
+    const input = ftl`
+      foo = Foo
+          Bar
+
+      `;
+    const output = ftl`
+      foo =
+          Foo
+          Bar
+
+      `;
+    assert.strictEqual(pretty(input), output);
+  });
+
+  test("multiline starting inline with a special char", function() {
+    const input = ftl`
+      foo = *Foo
+          Bar
+
+      `;
+    assert.strictEqual(pretty(input), input);
+  });
+
   test("multiline with placeable", function() {
     const input = ftl`
       foo =
@@ -338,6 +362,17 @@ suite("Serialize resource", function() {
     assert.strictEqual(pretty(input), output);
   });
 
+  test("select expression in inline value starting with a special char", function() {
+    const input = ftl`
+      foo = .Foo { $sel ->
+             *[a] A
+              [b] B
+          }
+
+      `;
+    assert.strictEqual(pretty(input), input);
+  });
+
   test("select expression in multiline value", function() {
     const input = ftl`
       foo =