(fluent-syntax) Export serializeExpression, serializeVariantKey (#350)

Author: stasm

fluent-syntax/src/index.js

@@ -1,8 +1,9 @@
-import FluentParser from "./parser";
-import FluentSerializer from "./serializer";
+import {FluentParser} from "./parser";
+import {FluentSerializer} from "./serializer";
 
 export * from "./ast";
-export { FluentParser, FluentSerializer };
+export * from "./parser";
+export * from "./serializer";
 export * from "./visitor";
 
 export function parse(source, opts) {

fluent-syntax/src/parser.js

@@ -30,7 +30,8 @@ function withSpan(fn) {
 }
 
 
-export default class FluentParser {
+export
+class FluentParser {
   constructor({
     withSpans = true,
   } = {}) {

fluent-syntax/src/serializer.js

@@ -13,10 +13,12 @@ function isSelectExpr(elem) {
     && elem.expression.type === "SelectExpression";
 }
 
+export
 // Bit masks representing the state of the serializer.
-export const HAS_ENTRIES = 1;
+const HAS_ENTRIES = 1;
 
-export default class FluentSerializer {
+export
+class FluentSerializer {
   constructor({ withJunk = false } = {}) {
     this.withJunk = withJunk;
   }
@@ -68,10 +70,6 @@ export default class FluentSerializer {
         throw new Error(`Unknown entry type: ${entry.type}`);
     }
   }
-
-  serializeExpression(expr) {
-    return serializeExpression(expr);
-  }
 }
 
 
@@ -208,6 +206,7 @@ function serializePlaceable(placeable) {
 }
 
 
+export
 function serializeExpression(expr) {
   switch (expr.type) {
     case "StringLiteral":
@@ -281,11 +280,14 @@ function serializeNamedArgument(arg) {
 }
 
 
+export
 function serializeVariantKey(key) {
   switch (key.type) {
     case "Identifier":
       return key.name;
+    case "NumberLiteral":
+      return key.value;
     default:
-      return serializeExpression(key);
+      throw new Error(`Unknown variant key type: ${key.type}`);
   }
 }

fluent-syntax/test/serializer_test.js

@@ -1,7 +1,9 @@
 import assert from "assert";
 import { ftl } from "./util";
 
-import { FluentParser, FluentSerializer } from "../src";
+import {
+  FluentParser, FluentSerializer, serializeExpression, serializeVariantKey
+} from "../src";
 
 
 suite("Serialize resource", function() {
@@ -486,29 +488,25 @@ suite("Serialize resource", function() {
   });
 });
 
-suite("Serialize expression", function() {
+suite("serializeExpression", function() {
   let pretty;
 
   setup(function() {
     const parser = new FluentParser();
-    const serializer = new FluentSerializer({
-      withJunk: false
-    });
 
     pretty = function pretty(text) {
       const {value: {elements: [placeable]}} = parser.parseEntry(text);
-      return serializer.serializeExpression(placeable.expression);
+      return serializeExpression(placeable.expression);
     }
   });
 
   test("invalid expression", function() {
-    const serializer = new FluentSerializer();
     assert.throws(
-      () => serializer.serializeExpression(null),
+      () => serializeExpression(null),
       /Cannot read property 'type'/
     );
     assert.throws(
-      () => serializer.serializeExpression({}),
+      () => serializeExpression({}),
       /Unknown expression type/
     );
   });
@@ -632,3 +630,54 @@ suite("Serialize padding around comments", function() {
     assert.equal(pretty(input), input);
   });
 });
+
+suite("serializeVariantKey", function() {
+  let prettyVariantKey;
+
+  setup(function() {
+    let parser = new FluentParser();
+
+    prettyVariantKey = function(text, index) {
+      let pattern = parser.parseEntry(text).value;
+      let variants = pattern.elements[0].expression.variants;
+      return serializeVariantKey(variants[index].key);
+    }
+  });
+
+  test("invalid expression", function() {
+    assert.throws(
+      () => serializeVariantKey(null),
+      /Cannot read property 'type'/
+    );
+    assert.throws(
+      () => serializeVariantKey({}),
+      /Unknown variant key type/
+    );
+  });
+
+  test("identifiers", function() {
+    const input = ftl`
+      foo = { $num ->
+          [one] One
+         *[other] Other
+      }
+    `;
+    assert.equal(prettyVariantKey(input, 0), "one");
+    assert.equal(prettyVariantKey(input, 1), "other");
+  });
+
+  test("number literals", function() {
+    const input = ftl`
+      foo = { $num ->
+          [-123456789] Minus a lot
+          [0] Zero
+         *[3.14] Pi
+          [007] James
+      }
+    `;
+    assert.equal(prettyVariantKey(input, 0), "-123456789");
+    assert.equal(prettyVariantKey(input, 1), "0");
+    assert.equal(prettyVariantKey(input, 2), "3.14");
+    assert.equal(prettyVariantKey(input, 3), "007");
+  });
+});