BaseNode.equals support, and other ast goodness from python-fluent

fluent-syntax/src/ast.js

@@ -5,8 +5,86 @@
  * 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;
+        }
+        // Sort elements of order-agnostic fields to ensure the
+        // comparison is order-agnostic as well. Annotations should be
+        // here too but they don't have sorting keys.
+        if (["attributes", "variants"].indexOf(fieldName) >= 0) {
+          thisVal.sort(sorting_key_compare);
+          otherVal.sort(sorting_key_compare);
+        }
+        for (let i = 0, ii = thisVal.length; i < ii; ++i) {
+          if (!scalars_equal(thisVal[i], otherVal[i], ignoredFields)) {
+            return false;
+          }
+        }
+      } else if (!scalars_equal(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);
+    for (const prop of Object.keys(this)) {
+      clone[prop] = visit(this[prop]);
+    }
+    return clone;
+  }
+}
+
+function scalars_equal(thisVal, otherVal, ignoredFields) {
+  if (thisVal instanceof BaseNode) {
+    return thisVal.equals(otherVal, ignoredFields);
+  }
+  return thisVal === otherVal;
+}
+
+function sorting_key_compare(left, right) {
+  if (left.sorting_key < right.sorting_key) {
+    return -1;
+  }
+  if (left.sorting_key === right.sorting_key) {
+    return 0;
+  }
+  return 1;
 }
 
 /*
@@ -188,6 +266,10 @@ export class Attribute extends SyntaxNode {
     this.id = id;
     this.value = value;
   }
+
+  get sorting_key() {
+    return this.id.name;
+  }
 }
 
 export class Variant extends SyntaxNode {
@@ -198,6 +280,13 @@ export class Variant extends SyntaxNode {
     this.value = value;
     this.default = def;
   }
+
+  get sorting_key() {
+    if (this.key instanceof NumberLiteral) {
+      return this.key.value;
+    }
+    return this.key.name;
+  }
 }
 
 export class NamedArgument extends SyntaxNode {

fluent-syntax/src/index.js

@@ -3,6 +3,7 @@ import FluentSerializer from "./serializer";
 
 export * from "./ast";
 export { FluentParser, FluentSerializer };
+export * from "./visitor";
 
 export function parse(source, opts) {
   const parser = new FluentParser(opts);

fluent-syntax/src/visitor.js

@@ -0,0 +1,60 @@
+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 nodename = node.type;
+    const visit = this[`visit_${nodename}`] || this.generic_visit;
+    visit.call(this, node);
+  }
+
+  generic_visit(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 nodename = node.type;
+    const visit = this[`visit_${nodename}`] || this.generic_visit;
+    return visit.call(this, node);
+  }
+
+  generic_visit(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,77 @@
+"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.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("Variants", function() {
+      const thisRes = this.parser.parse(ftl`
+          msg = { $val ->
+              [few] things
+              [1] one
+             *[other] default
+            }
+      `);
+      const otherRes = this.parser.parse(ftl`
+          # a comment
+          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(thisNode.equals(otherNode, ['span', 'comment']), true);
+      assert.strictEqual(thisNode.value.equals(otherNode.value), true);
+      assert.strictEqual(thisNode.value.equals(otherNode.value, []), false);
+      assert.strictEqual(thisRes.equals(thisRes.clone(), []), true);
+      assert.notStrictEqual(thisRes, thisRes.clone());
+  });
+  test("Attributes without order", 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), true);
+  });
+});

fluent-syntax/test/visitor_test.js

@@ -0,0 +1,118 @@
+"use strict";
+
+import assert from "assert";
+import { ftl } from "./util";
+import { FluentParser, Visitor, Transformer } from "../src";
+
+suite("Visitor", function() {
+  setup(function() {
+    const parser = new FluentParser();
+    this.resource = parser.parse(ftl`
+        one = Message
+        # Comment
+        two = Messages
+        three = Messages with
+            .an = Attribute
+    `);
+  });
+  test("Mock Visitor", function() {
+    class MockVisitor extends Visitor {
+      constructor() {
+        super();
+        this.calls = {};
+        this.pattern_calls = 0;
+      }
+      generic_visit(node) {
+        const nodename = node.type;
+        if (nodename in this.calls) {
+          this.calls[nodename]++;
+        } else {
+          this.calls[nodename] = 1;
+        }
+        super.generic_visit(node);
+      }
+      visit_Pattern(node) {
+        this.pattern_calls++;
+      }
+    }
+    const mv = new MockVisitor();
+    mv.visit(this.resource);
+    assert.strictEqual(mv.pattern_calls, 4);
+    assert.deepStrictEqual(
+      mv.calls,
+      {
+        'Resource': 1,
+        'Comment': 1,
+        'Message': 3,
+        'Identifier': 4,
+        'Attribute': 1,
+        'Span': 10,
+      }
+    )
+  });
+  test("WordCount", function() {
+    class VisitorCounter extends Visitor {
+      constructor() {
+        super();
+        this.word_count = 0;
+      }
+      generic_visit(node) {
+        switch (node.type) {
+          case 'Span':
+          case 'Annotation':            
+            break;
+          default:
+            super.generic_visit(node);
+        }
+      }
+      visit_TextElement(node) {
+        this.word_count += node.value.split(/\s+/).length;
+      }
+    }
+    const vc = new VisitorCounter();
+    vc.visit(this.resource);
+    assert.strictEqual(vc.word_count, 5);
+  })
+});
+
+suite("Transformer", function() {
+  setup(function() {
+    const parser = new FluentParser();
+    this.resource = parser.parse(ftl`
+        one = Message
+        # Comment
+        two = Messages
+        three = Messages with
+            .an = Attribute
+    `);
+  });
+  test("ReplaceTransformer", function() {
+    class ReplaceTransformer extends Transformer {
+      constructor(before, after) {
+        super();
+        this.before = before;
+        this.after = after;
+      }
+      generic_visit(node) {
+        switch (node.type) {
+          case 'Span':
+          case 'Annotation':
+            return node;
+            break;
+          default:
+            return super.generic_visit(node);
+        }
+      }
+      visit_TextElement(node) {
+        node.value = node.value.replace(this.before, this.after);
+        return node;
+      }
+    }
+    const resource = this.resource.clone()
+    const transformed = new ReplaceTransformer('Message', 'Term').visit(resource);
+    assert.notStrictEqual(resource, this.resource);
+    assert.strictEqual(resource, transformed);
+    assert.strictEqual(this.resource.equals(transformed), false);
+    assert.strictEqual(transformed.body[1].value.elements[0].value, 'Terms');
+  });
+});