Merge branch 'master' into zeronine

Author: stasm

fluent-gecko/src/fluent_syntax.js

@@ -1,11 +1,15 @@
-/* eslint no-unused-vars: 0 */
+/* eslint object-shorthand: "off",
+          no-unused-vars: "off",
+          no-redeclare: "off",
+          comma-dangle: "off",
+          no-labels: "off" */
 
 import FluentParser from "../../fluent-syntax/src/parser";
 import FluentSerializer from "../../fluent-syntax/src/serializer";
 import * as ast from "../../fluent-syntax/src/ast";
 
-let EXPORTED_SYMBOLS = [
+this.EXPORTED_SYMBOLS = [
   "FluentParser",
   "FluentSerializer",
-  ...Object.keys(ast)
+  ...Object.keys(ast),
 ];

fluent-gecko/xpcom_config.js

@@ -6,9 +6,10 @@ export default Object.assign({}, bundleConfig, {
   context: 'this',
   output: {
     format: 'es',
-    banner: `/* vim: set ts=2 et sw=2 tw=80 filetype=javascript: */
+    banner: `\
+/* vim: set ts=2 et sw=2 tw=80 filetype=javascript: */
 
-/* Copyright 2017 Mozilla Foundation and others
+/* Copyright 2019 Mozilla Foundation and others
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,7 +22,9 @@ export default Object.assign({}, bundleConfig, {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */\n\n`,
+ */
+
+`,
   },
   plugins: [
     nodeResolve(),

fluent-syntax/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## fluent-syntax 0.11.0 (March 25, 2019)
+
+  - Add `BaseNode.equals` and `BaseNode.clone`. (#172)
+
+    The new `BaseNode` methods can be used to compare two nodes and to create
+    a deep copy of an AST node.
+
+  - Add `Visitor` and `Transformer`. (#172)
+
+    Add two new exports: `Visitor` for read-only iteration over AST trees,
+    and `Transformer` for in-place mutation of AST trees.
+
+  - Export `serializeExpression` and `serializeVariantKey`. (#350)
+
+    The `FluentSerializer.serializeExpression` method has been removed in
+    favor of a module-wide stateless function `serializeExpression`.
+
+
 ## fluent-syntax 0.10.0 (December 13, 2018)
 
 This release of `fluent-syntax` brings support for version 0.8 of the

fluent-syntax/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fluent-syntax",
   "description": "AST and parser for Fluent",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "homepage": "http://projectfluent.org",
   "author": "Mozilla <[email protected]>",
   "license": "Apache-2.0",

fluent-syntax/src/ast.js

@@ -5,8 +5,69 @@
  * Annotation.
  *
  */
-class BaseNode {
+export class BaseNode {
   constructor() {}
+
+  equals(other, ignoredFields = ["span"]) {
+    const thisKeys = new Set(Object.keys(this));
+    const otherKeys = new Set(Object.keys(other));
+    if (ignoredFields) {
+      for (const fieldName of ignoredFields) {
+        thisKeys.delete(fieldName);
+        otherKeys.delete(fieldName);
+      }
+    }
+    if (thisKeys.size !== otherKeys.size) {
+      return false;
+    }
+    for (const fieldName of thisKeys) {
+      if (!otherKeys.has(fieldName)) {
+        return false;
+      }
+      const thisVal = this[fieldName];
+      const otherVal = other[fieldName];
+      if (typeof thisVal !== typeof otherVal) {
+        return false;
+      }
+      if (thisVal instanceof Array) {
+        if (thisVal.length !== otherVal.length) {
+          return false;
+        }
+        for (let i = 0; i < thisVal.length; ++i) {
+          if (!scalarsEqual(thisVal[i], otherVal[i], ignoredFields)) {
+            return false;
+          }
+        }
+      } else if (!scalarsEqual(thisVal, otherVal, ignoredFields)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  clone() {
+    function visit(value) {
+      if (value instanceof BaseNode) {
+        return value.clone();
+      }
+      if (Array.isArray(value)) {
+        return value.map(visit);
+      }
+      return value;
+    }
+    const clone = Object.create(this.constructor.prototype);
+    for (const prop of Object.keys(this)) {
+      clone[prop] = visit(this[prop]);
+    }
+    return clone;
+  }
+}
+
+function scalarsEqual(thisVal, otherVal, ignoredFields) {
+  if (thisVal instanceof BaseNode) {
+    return thisVal.equals(otherVal, ignoredFields);
+  }
+  return thisVal === otherVal;
 }
 
 /*

fluent-syntax/src/index.js

@@ -1,8 +1,10 @@
-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) {
   const parser = new FluentParser(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);
-  }
 }
 
 
@@ -177,6 +175,7 @@ function serializePlaceable(placeable) {
 }
 
 
+export
 function serializeExpression(expr) {
   switch (expr.type) {
     case "StringLiteral":
@@ -247,11 +246,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/src/visitor.js

@@ -0,0 +1,58 @@
+import { BaseNode } from "./ast";
+
+/*
+ * Abstract Visitor pattern
+ */
+export class Visitor {
+  visit(node) {
+    if (Array.isArray(node)) {
+      node.forEach(child => this.visit(child));
+      return;
+    }
+    if (!(node instanceof BaseNode)) {
+      return;
+    }
+    const visit = this[`visit${node.type}`] || this.genericVisit;
+    visit.call(this, node);
+  }
+
+  genericVisit(node) {
+    for (const propname of Object.keys(node)) {
+      this.visit(node[propname]);
+    }
+  }
+}
+
+/*
+ * Abstract Transformer pattern
+ */
+export class Transformer extends Visitor {
+  visit(node) {
+    if (!(node instanceof BaseNode)) {
+      return node;
+    }
+    const visit = this[`visit${node.type}`] || this.genericVisit;
+    return visit.call(this, node);
+  }
+
+  genericVisit(node) {
+    for (const propname of Object.keys(node)) {
+      const propvalue = node[propname];
+      if (Array.isArray(propvalue)) {
+        const newvals = propvalue
+          .map(child => this.visit(child))
+          .filter(newchild => newchild !== undefined);
+        node[propname] = newvals;
+      }
+      if (propvalue instanceof BaseNode) {
+        const new_val = this.visit(propvalue);
+        if (new_val === undefined) {
+          delete node[propname];
+        } else {
+          node[propname] = new_val;
+        }
+      }
+    }
+    return node;
+  }
+}

fluent-syntax/test/ast_test.js

@@ -0,0 +1,74 @@
+"use strict";
+
+import assert from "assert";
+import { ftl } from "./util";
+import { FluentParser } from "../src";
+import * as AST from "../src/ast";
+
+suite("BaseNode.equals", function() {
+  setup(function() {
+    this.parser = new FluentParser();
+  });
+  test("Identifier.equals", function() {
+    const thisNode = new AST.Identifier("name");
+    const otherNode = new AST.Identifier("name");
+    assert.ok(thisNode.clone() instanceof AST.Identifier);
+    assert.strictEqual(thisNode.equals(otherNode), true);
+    assert.strictEqual(thisNode.equals(thisNode.clone()), true);
+    assert.notStrictEqual(thisNode, thisNode.clone());
+  });
+  test("Node.type", function() {
+    const thisNode = new AST.Identifier("name");
+    const otherNode = new AST.StringLiteral("name");
+    assert.strictEqual(thisNode.equals(otherNode), false);
+  });
+  test("Array children", function() {
+    const thisNode = new AST.Pattern([
+      new AST.TextElement("one"),
+      new AST.TextElement("two"),
+      new AST.TextElement("three"),
+    ]);
+    let otherNode = new AST.Pattern([
+      new AST.TextElement("one"),
+      new AST.TextElement("two"),
+      new AST.TextElement("three"),
+    ]);
+    assert.strictEqual(thisNode.equals(otherNode), true);
+  });
+  test("Variant order matters", function() {
+      const thisRes = this.parser.parse(ftl`
+          msg = { $val ->
+              [few] things
+              [1] one
+             *[other] default
+            }
+      `);
+      const otherRes = this.parser.parse(ftl`
+          msg = { $val ->
+              [few] things
+             *[other] default
+              [1] one
+            }
+      `);
+      const thisNode = thisRes.body[0];
+      const otherNode = otherRes.body[0];
+      assert.strictEqual(thisNode.equals(otherNode), false);
+      assert.strictEqual(thisRes.equals(thisRes.clone(), []), true);
+      assert.notStrictEqual(thisRes, thisRes.clone());
+  });
+  test("Attribute order matters", function() {
+      const thisRes = this.parser.parse(ftl`
+          msg =
+            .attr1 = one
+            .attr2 = two
+      `);
+      const otherRes = this.parser.parse(ftl`
+          msg =
+            .attr2 = two
+            .attr1 = one
+      `);
+      const thisNode = thisRes.body[0];
+      const otherNode = otherRes.body[0];
+      assert.strictEqual(thisNode.equals(otherNode), false);
+  });
+});