BaseNode.equals support, wip, needs more tests

This is basically a port of
https://github.com/projectfluent/python-fluent/blob/90301381e9b4d56b317bd6f15adf38936569f023/fluent/syntax/ast.py#L76-L120

fluent-syntax/src/ast.js

@@ -7,6 +7,50 @@
  */
 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;
+  }
 }
 
 /*
@@ -18,6 +62,23 @@ class SyntaxNode extends BaseNode {
   }
 }
 
+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;
+}
+
 export class Resource extends SyntaxNode {
   constructor(body = []) {
     super();
@@ -166,6 +227,10 @@ export class Attribute extends SyntaxNode {
     this.id = id;
     this.value = value;
   }
+
+  get sorting_key() {
+    return this.id.name;
+  }
 }
 
 export class Variant extends SyntaxNode {
@@ -176,6 +241,13 @@ export class Variant extends SyntaxNode {
     this.value = value;
     this.default = def;
   }
+
+  get sorting_key() {
+    if (this.key instanceof NumberExpression) {
+      return this.key.value;
+    }
+    return this.key.name;
+  }
 }
 
 export class NamedArgument extends SyntaxNode {

fluent-syntax/test/ast_test.js

@@ -0,0 +1,30 @@
+"use strict";
+
+import assert from "assert";
+import * as AST from "../src/ast";
+
+suite("BaseNode.equals", function() {
+  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.Function("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);
+  });
+});