BaseNode.equals

API and tests inspired by
https://github.com/projectfluent/python-fluent/blob/0509340a9d81a2bde2fa97fe9178fa433c6d45e0/fluent.syntax/fluent/syntax/ast.py#L156-L200

Author: Pike

fluent-syntax/src/ast.js

@@ -7,6 +7,67 @@
  */
 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;
+  }
+}
+
+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 +249,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 +263,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/test/ast_test.js

@@ -0,0 +1,73 @@
+"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);
+  });
+  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);
+  });
+  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);
+  });
+});