Add the ignored_fields kwarg to BaseNode.equals (#16)

Author: stasm

CHANGELOG.md

@@ -7,7 +7,9 @@
     Nodes are deeply compared on a field by field basis. If possible, False is
     returned early. When comparing attributes, tags and variants in
     SelectExpressions, the order doesn't matter. By default, spans are not
-    taken into account.
+    taken into account.  Other fields may also be ignored if necessary:
+
+        message1.equals(message2, ignored_fields=['comment', 'span'])
 
 ## fluent 0.4.0 (June 13th, 2017)
 

fluent/syntax/ast.py

@@ -27,14 +27,14 @@ def from_json(value):
         return value
 
 
-def scalars_equal(node1, node2, with_spans=False):
+def scalars_equal(node1, node2, ignored_fields):
     """Compare two nodes which are not lists."""
 
     if type(node1) != type(node2):
         return False
 
     if isinstance(node1, BaseNode):
-        return node1.equals(node2, with_spans)
+        return node1.equals(node2, ignored_fields)
 
     return node1 == node2
 
@@ -73,7 +73,7 @@ def visit(value):
 
         return fun(node)
 
-    def equals(self, other, with_spans=False):
+    def equals(self, other, ignored_fields=['span']):
         """Compare two nodes.
 
         Nodes are deeply compared on a field by field basis. If possible, False
@@ -85,9 +85,10 @@ def equals(self, other, with_spans=False):
         self_keys = set(vars(self).keys())
         other_keys = set(vars(other).keys())
 
-        if not with_spans:
-            self_keys.discard('span')
-            other_keys.discard('span')
+        if ignored_fields:
+            for key in ignored_fields:
+                self_keys.discard(key)
+                other_keys.discard(key)
 
         if self_keys != other_keys:
             return False
@@ -117,10 +118,10 @@ def equals(self, other, with_spans=False):
                     field2 = sorted(field2, key=sorting)
 
                 for elem1, elem2 in zip(field1, field2):
-                    if not scalars_equal(elem1, elem2, with_spans):
+                    if not scalars_equal(elem1, elem2, ignored_fields):
                         return False
 
-            elif not scalars_equal(field1, field2, with_spans):
+            elif not scalars_equal(field1, field2, ignored_fields):
                 return False
 
         return True

tests/syntax/test_equals.py

@@ -203,7 +203,7 @@ def test_equals_with_spans(self):
         ]
 
         for a, b in messages:
-            self.assertTrue(a.equals(b, with_spans=True))
+            self.assertTrue(a.equals(b, ignored_fields=None))
 
     def test_parser_without_spans_equals_with_spans(self):
         parser = FluentParser(with_spans=False)
@@ -221,7 +221,7 @@ def test_parser_without_spans_equals_with_spans(self):
         ]
 
         for a, b in messages:
-            self.assertTrue(a.equals(b, with_spans=True))
+            self.assertTrue(a.equals(b, ignored_fields=None))
 
     def test_differ_with_spans(self):
         parser = FluentParser()
@@ -237,4 +237,42 @@ def test_differ_with_spans(self):
         ]
 
         for a, b in messages:
-            self.assertFalse(a.equals(b, with_spans=True))
+            self.assertFalse(a.equals(b, ignored_fields=None))
+
+
+class TestIgnoredFields(unittest.TestCase):
+    def setUp(self):
+        self.parser = FluentParser()
+
+    def parse_ftl_entry(self, string):
+        return self.parser.parse_entry(dedent_ftl(string))
+
+    def test_ignore_value(self):
+        a = self.parse_ftl_entry("foo = Foo")
+        b = self.parse_ftl_entry("foo = Bar")
+
+        self.assertTrue(a.equals(b, ignored_fields=['value']))
+
+    def test_ignore_value_span(self):
+        a = self.parse_ftl_entry("foo = Foo")
+        b = self.parse_ftl_entry("foo = Foobar")
+
+        self.assertTrue(a.equals(b, ignored_fields=['span', 'value']))
+        self.assertFalse(a.equals(b, ignored_fields=['value']))
+
+    def test_ignore_comments(self):
+        a = self.parse_ftl_entry("""\
+            // Comment A
+            foo = Foo
+        """)
+        b = self.parse_ftl_entry("""\
+            // Comment B
+            foo = Foo
+        """)
+        c = self.parse_ftl_entry("""\
+            // Comment CC
+            foo = Foo
+        """)
+
+        self.assertTrue(a.equals(b, ignored_fields=['comment']))
+        self.assertFalse(a.equals(c, ignored_fields=['comment']))