compare-xml 0.66 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb6c3fb3e704a49642e05b7c2ff26442ad63a77aa22c4a2dc461ffce22c5dc59
-  data.tar.gz: 8fa4604c0f7216f077fa48807a68c4b222fefca2dd6beedfc0d745cb3f5074ee
+  metadata.gz: '044582cb43241dc59a65422b8c36a2cc96d1a3120f9648c0950b7ef9fe125be5'
+  data.tar.gz: 3a33391e6f5a67f305546173a43725a64bd6ed4df12135434453da9bc3982e98
 SHA512:
-  metadata.gz: 7be5a2a949660aff92a2d4fea1fa6820a960ceb7b177479ee6a7b3464cc0f9b12ce7a81f08fe4567243a658987ab48c34362cf09b9a2f11767724d669cc0f142
-  data.tar.gz: 7d17c1fd43511146021eadc83037cf27d7c259fad86658ecba24f6c021ec4095b984d1e5cb9becaa1cd2e78b4338db95f0b437e00ab60aed0f54f6733087dde9
+  metadata.gz: 0f3a32d528e4298a96ce59238f7ed556fa110ea7a4d715b651e1e578887f6bde9c6852928d0971c114e6ca9fb77dca8c4e6ca53c9580143cc5d89785ca14d942
+  data.tar.gz: fc8371bdce1193d15d42092c24b9b44d2d9c51a685331102ba69fd9290cafdd6faf588feab68871b1c7659c42ed1f1656718b97b72fbf0702bde153e3a2caf30

data/README.md

@@ -1,8 +1,13 @@
 # CompareXML
 
-[![Gem Version](https://badge.fury.io/rb/compare-xml.svg)](https://rubygems.org/gems/compare-xml)
+[![Gem Version](https://img.shields.io/gem/v/compare-xml.svg)](https://rubygems.org/gems/compare-xml)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Lint Status](https://github.com/vkononov/compare-xml/actions/workflows/lint.yml/badge.svg)](https://github.com/vkononov/compare-xml/actions/workflows/lint.yml)
+[![Test Status](https://github.com/vkononov/compare-xml/actions/workflows/test.yml/badge.svg)](https://github.com/vkononov/compare-xml/actions/workflows/test.yml)
 
-CompareXML is a fast, lightweight and feature-rich tool that will solve your XML/HTML comparison or diffing needs. its purpose is to compare two instances of `Nokogiri::XML::Node` or `Nokogiri::XML::NodeSet` for equality or equivalency.
+CompareXML is a fast, lightweight and feature-rich tool that will solve your XML/HTML comparison or diffing needs. Its purpose is to compare two instances of `Nokogiri::XML::Node` or `Nokogiri::XML::NodeSet` for equality or equivalency.
+
+[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/yellow_img.png)](https://www.buymeacoffee.com/vkononov)
 
 **Features**
 
@@ -63,7 +68,7 @@ require 'compare-xml'
 CompareXML has a variety of options that can be invoked as an optional argument, e.g.:
 
 ```ruby
-CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true, ...})
+CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true})
 ```
 
 - `collapse_whitespace: {true|false}` default: **`true`**     [show examples ⇨](#collapse_whitespace)
@@ -78,8 +83,8 @@ CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true, .
 - `ignore_attrs: [css_selector1, css_selector1, ...]` default: **`[]`**     [show examples ⇨](#ignore_attrs)
     - when provided, ignores specific *attributes* using [CSS selectors](http://www.w3schools.com/cssref/css_selectors.asp)
 
-- `ignore_attrs_by_name: [string1, string2, ...]` default: **`[]`**     [show examples ⇨](#ignore_attrs_by_name)
-    - when provided, ignores specific *attributes* using [String]
+- `ignore_attrs_by_name: [matcher1, matcher2, ...]` default: **`[]`**     [show examples ⇨](#ignore_attrs_by_name)
+    - when provided, ignores *attributes* whose name matches a `String` (exact) or `Regexp` (pattern)
 
 - `ignore_comments: {true|false}` default: **`true`**     [show examples ⇨](#ignore_comments)
     - when `true`, ignores comments, such as `<!-- comment -->`
@@ -99,6 +104,9 @@ CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true, .
 - `force_children {true|false}` default **`false`**&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[show examples ⇨](#force_children)
     - when `true`, the subnodes of a node are checked independently of the status of the parent node
 
+- `align_children {true|false}` default **`false`**&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[show examples ⇨](#align_children)
+    - when `true` (in `verbose` mode), aligns child nodes so insertions and removals are reported as additions/removals instead of changes
+
 
 ## Options in Depth
 
@@ -196,17 +204,27 @@ CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true, .
 
 ----------
 
-- <a id="ignore_attrs_by_name"></a>`ignore_attrs_by_name: [string1, string2, ...]` default: **`false`**
+- <a id="ignore_attrs_by_name"></a>`ignore_attrs_by_name: [matcher1, matcher2, ...]` default: **`[]`**
 
-    When provided, ignores all **attributes** which name is specified in the string array.
+    When provided, ignores all **attributes** whose name matches one of the given matchers. A `String` matches the attribute name exactly, while a `Regexp` matches it as a pattern.
 
-     **Usage Example:** `CompareXML.equivalent?(doc1, doc2, {ignore_attrs_by_name: ['target'])`
+     **Usage Example:** `CompareXML.equivalent?(doc1, doc2, {ignore_attrs_by_name: ['target', /^data-/]})`
 
     **Example:** With `ignore_attrs_by_name: ['target', 'rel']` the following HTML strings are considered equal:
 
         <a href="/admin" class="button" target="_blank">Link</a>
         <a href="/admin" class="button" target="_self" rel="nofollow">Link</a>
 
+    **Example:** With `ignore_attrs_by_name: [/^data-/]` the following HTML strings are considered equal:
+
+        <div data-id="1" data-role="row">Link</div>
+        <div data-id="2" data-role="cell">Link</div>
+
+    An ignored attribute does not need to be present on both elements. With `ignore_attrs_by_name: ['class']` the following HTML strings are considered equal:
+
+        <div class="foo"></div>
+        <div></div>
+
 ----------
 
 
@@ -280,42 +298,42 @@ CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true, .
 
     **Example:** When `true` given the following HTML strings:
 
-    ![diffing](https://github.com/vkononov/compare-xml/raw/master/img/diffing.png)
+    ![diffing](https://github.com/vkononov/compare-xml/raw/main/img/diffing.png)
 
     `CompareXML.equivalent?(doc1, doc2, {verbose: true})` will produce an array shown below.
 
     ```ruby
     [
-        {
-            node1: '<title>TITLE</title>',
-            node2: '<title>ANOTHER TITLE</title>',
-            diff1: 'TITLE',
-            diff2: 'ANOTHER TITLE',
-        },
-        {
-            node1: '<h1>SOME HEADING</h1>',
-            node2: '<h1 id="main">SOME HEADING</h1>',
-            diff1: nil,
-            diff2: 'id="main"',
-        },
-        {
-            node1: '<a href="/admin" rel="icon">Link</a>',
-            node2: '<a rel="button" href="/admin">Link</a>',
-            diff1: '"rel="icon"',
-            diff2: '"rel="button"',
-        },
-        {
-            node1: '<cite>Author Name</cite>',
-            node2: nil,
-            diff1: '<cite>Author Name</cite>',
-            diff2: nil,
-        },
-        {
-            node1: '<p class="footer">FOOTER</p>',
-            node2: '<div class="footer">FOOTER</div>',
-            diff1: 'p',
-            diff2: 'div',
-        }
+      {
+        node1: '<title>TITLE</title>',
+        node2: '<title>ANOTHER TITLE</title>',
+        diff1: 'TITLE',
+        diff2: 'ANOTHER TITLE'
+      },
+      {
+        node1: '<h1>SOME HEADING</h1>',
+        node2: '<h1 id="main">SOME HEADING</h1>',
+        diff1: nil,
+        diff2: 'id="main"'
+      },
+      {
+        node1: '<a href="/admin" rel="icon">Link</a>',
+        node2: '<a rel="button" href="/admin">Link</a>',
+        diff1: '"rel="icon"',
+        diff2: '"rel="button"'
+      },
+      {
+        node1: '<cite>Author Name</cite>',
+        node2: nil,
+        diff1: '<cite>Author Name</cite>',
+        diff2: nil
+      },
+      {
+        node1: '<p class="footer">FOOTER</p>',
+        node2: '<div class="footer">FOOTER</div>',
+        diff1: 'p',
+        diff2: 'div'
+      }
     ]
     ```
 
@@ -345,7 +363,22 @@ CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true, .
 
     When provided, compares all **subnodes** of any node.
 
-    **Usage Example:** `CompareXML.equivalent?(doc1, doc2, {ignore_children: true})`
+    **Usage Example:** `CompareXML.equivalent?(doc1, doc2, {force_children: true})`
+
+----------
+
+- <a id="align_children"></a>`align_children: {true|false}` default: **`false`**
+
+    Only takes effect in `verbose` mode. When `true`, sibling nodes are aligned before comparison so that an inserted or removed node is reported as an addition or removal (with one side `nil`) rather than causing the remaining siblings to be reported as a series of changes. Identical subtrees are matched as anchors, and the unmatched nodes between them are compared in order.
+
+    **Usage Example:** `CompareXML.equivalent?(doc1, doc2, {verbose: true, align_children: true})`
+
+    **Example:** Given a left document with three children and a right document with only the third:
+
+        <properties><a/><b/><c/></properties>
+        <properties><c/></properties>
+
+    With `align_children: true`, `<a>` and `<b>` are reported as removals (`node2` is `nil`); without it, they collapse into a single positional change.
 
 ----------
 
@@ -367,4 +400,4 @@ This gem was inspired by [Michael B. Klein](https://github.com/mbklein)'s gem [`
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/compare-xml/version.rb

@@ -1,3 +1,3 @@
 module CompareXML
-  VERSION = '0.66'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/lib/compare-xml.rb

@@ -16,6 +16,10 @@ module CompareXML
     # when false, children of elements are not compared if the root is different
     force_children: false,
 
+    # when true (verbose mode only), child nodes are aligned before being compared so that
+    # inserted or removed nodes are reported as additions/removals instead of as changes
+    align_children: false,
+
     # when true, children of elements are never compared
     # when false, children of elements are compared if root is different or see force_children
     ignore_children: false,
@@ -72,16 +76,16 @@ module CompareXML
     #   @param [Nokogiri::XML::Element] n1 left node element
     #   @param [Nokogiri::XML::Element] n2 right node element
     #   @param [Hash] opts user-overridden options
-    #   @param [Hash] childopts user-overridden options used for the child nodes
-    #   @param [Bool] diffchildren use different options for the child nodes
+    #   @param [Hash] child_opts user-overridden options used for the child nodes
+    #   @param [Bool] diff_children use different options for the child nodes
     #
     #   @return true if equal, [Array] differences otherwise
     #
-    def equivalent?(n1, n2, opts = {}, childopts = {}, diffchildren = false)
+    def equivalent?(n1, n2, opts = {}, child_opts = {}, diff_children = false)
       opts = DEFAULTS_OPTS.merge(opts)
-      childopts = DEFAULTS_OPTS.merge(childopts)
+      child_opts = DEFAULTS_OPTS.merge(child_opts)
       differences = []
-      result = diffchildren ? compareNodes(n1, n2, opts, differences, childopts, diffchildren) : compareNodes(n1, n2, opts, differences)
+      result = diff_children ? compare_nodes(n1, n2, opts, differences, child_opts, diff_children: diff_children) : compare_nodes(n1, n2, opts, differences)
       opts[:verbose] ? differences : result == EQUIVALENT
     end
 
@@ -91,42 +95,41 @@ module CompareXML
     # Compares two nodes for equivalence. The nodes could be any subclass
     # of Nokogiri::XML::Node including node sets and document fragments.
     #
-    #   @param [Nokogiri::XML::Node] n1 left node
-    #   @param [Nokogiri::XML::Node] n2 right node
+    #   @param [Nokogiri::XML::Element] n1 left node
+    #   @param [Nokogiri::XML::Element] n2 right node
     #   @param [Hash] opts user-overridden options
     #   @param [Array] differences inequivalence messages
-    #   @param [Hash] childopts user-overridden options used for the child nodes
-    #   @param [Bool] diffchildren use different options for the child nodes
-    #   @param [int] status comparison status code (EQUIVALENT by default)
+    #   @param [Hash] child_opts user-overridden options used for the child nodes
+    #   @param [Bool] diff_children use different options for the child nodes
     #
     #   @return type of equivalence (from equivalence constants)
     #
-    def compareNodes(n1, n2, opts, differences, childopts = {}, diffchildren = false, status = EQUIVALENT)
-      if n1.class == n2.class
+    def compare_nodes(n1, n2, opts, differences, child_opts = {}, diff_children: false)
+      if n1.instance_of?(n2.class)
         case n1
         when Nokogiri::XML::Comment
-          status = compareCommentNodes(n1, n2, opts, differences)
+          status = compare_comment_nodes(n1, n2, opts, differences)
         when Nokogiri::HTML::Document
-          status = diffchildren ? compareDocumentNodes(n1, n2, opts, differences, childopts, diffchildren) : compareDocumentNodes(n1, n2, opts, differences)
+          status = diff_children ? compare_document_nodes(n1, n2, opts, differences, child_opts, diff_children: diff_children) : compare_document_nodes(n1, n2, opts, differences)
         when Nokogiri::XML::Element
-          status = diffchildren ? compareElementNodes(n1, n2, opts, differences, childopts, diffchildren) : compareElementNodes(n1, n2, opts, differences)
+          status = diff_children ? compare_element_nodes(n1, n2, opts, differences, child_opts, diff_children: diff_children) : compare_element_nodes(n1, n2, opts, differences)
         when Nokogiri::XML::Text
-          status = compareTextNodes(n1, n2, opts, differences)
+          status = compare_text_nodes(n1, n2, opts, differences)
         else
           raise 'Comparison only allowed between objects of type Nokogiri::XML::Node and Nokogiri::XML::NodeSet.' unless n1.is_a?(Nokogiri::XML::Node) || n1.is_a?(Nokogiri::XML::NodeSet)
-          status = compareChildren(n1.children, n2.children, opts, differences)
+          status = compare_children(n1.children, n2.children, opts, differences)
         end
       elsif n1.nil? || n2.nil?
         status = MISSING_NODE
-        addDifference(n1, n2, n1, n2, opts, differences)
+        add_difference(n1, n2, n1, n2, opts, differences)
       else
         status = UNEQUAL_NODES_TYPES
         if n1.is_a? Nokogiri::XML::Text
-          addDifference(n1.parent, n2, n1, n2, opts, differences)
+          add_difference(n1.parent, n2, n1, n2, opts, differences)
         elsif n2.is_a? Nokogiri::XML::Text
-          addDifference(n1, n2.parent, n1, n2, opts, differences)
+          add_difference(n1, n2.parent, n1, n2, opts, differences)
         else
-          addDifference(n1, n2, n1, n2, opts, differences)
+          add_difference(n1, n2, n1, n2, opts, differences)
         end
       end
       status
@@ -135,16 +138,16 @@ module CompareXML
     ##
     # Compares two nodes of type Nokogiri::HTML::Comment.
     #
-    #   @param [Nokogiri::XML::Comment] n1 left comment
-    #   @param [Nokogiri::XML::Comment] n2 right comment
+    #   @param [Nokogiri::XML::Element] n1 left comment
+    #   @param [Nokogiri::XML::Element] n2 right comment
     #   @param [Hash] opts user-overridden options
     #   @param [Array] differences inequivalence messages
     #   @param [int] status comparison status code (EQUIVALENT by default)
     #
     #   @return type of equivalence (from equivalence constants)
     #
-    def compareCommentNodes(n1, n2, opts, differences, status = EQUIVALENT)
-      return true if opts[:ignore_comments]
+    def compare_comment_nodes(n1, n2, opts, differences, status: EQUIVALENT)
+      return status if opts[:ignore_comments]
       t1 = n1.content
       t2 = n2.content
       if opts[:collapse_whitespace]
@@ -153,7 +156,7 @@ module CompareXML
       end
       unless t1 == t2
         status = UNEQUAL_COMMENTS
-        addDifference(n1.parent, n2.parent, t1, t2, opts, differences)
+        add_difference(n1.parent, n2.parent, t1, t2, opts, differences)
       end
       status
     end
@@ -161,22 +164,21 @@ module CompareXML
     ##
     # Compares two nodes of type Nokogiri::HTML::Document.
     #
-    #   @param [Nokogiri::XML::Document] n1 left document
-    #   @param [Nokogiri::XML::Document] n2 right document
+    #   @param [Nokogiri::XML::Element] n1 left document
+    #   @param [Nokogiri::XML::Element] n2 right document
     #   @param [Hash] opts user-overridden options
     #   @param [Array] differences inequivalence messages
-    #   @param [Hash] childopts user-overridden options used for the child nodes
-    #   @param [Bool] diffchildren use different options for the child nodes
-    #   @param [int] status comparison status code (EQUIVALENT by default)
+    #   @param [Hash] child_opts user-overridden options used for the child nodes
+    #   @param [Bool] diff_children use different options for the child nodes
     #
     #   @return type of equivalence (from equivalence constants)
     #
-    def compareDocumentNodes(n1, n2, opts, differences, childopts = {}, diffchildren = false, status = EQUIVALENT)
+    def compare_document_nodes(n1, n2, opts, differences, child_opts = {}, diff_children: false)
       if n1.name == n2.name
-        status = diffchildren ? compareChildren(n1.children, n2.children, childopts, differences, diffchildren) : compareChildren(n1.children, n2.children, opts, differences)
+        status = diff_children ? compare_children(n1.children, n2.children, child_opts, differences, diff_children: diff_children) : compare_children(n1.children, n2.children, opts, differences)
       else
         status = UNEQUAL_DOCUMENTS
-        addDifference(n1, n2, n1, n2, opts, differences)
+        add_difference(n1, n2, n1, n2, opts, differences)
       end
       status
     end
@@ -188,21 +190,23 @@ module CompareXML
     #   @param [Nokogiri::XML::NodeSet] n2_set right set of Nokogiri::XML::Node elements
     #   @param [Hash] opts user-overridden options
     #   @param [Array] differences inequivalence messages
-    #   @param [Bool] diffchildren use different options for the child nodes
+    #   @param [Bool] diff_children use different options for the child nodes
     #   @param [int] status comparison status code (EQUIVALENT by default)
     #
     #   @return type of equivalence (from equivalence constants)
     #
-    def compareChildren(n1_set, n2_set, opts, differences, diffchildren = false, status = EQUIVALENT)
-      i = 0; j = 0
-      return if opts[:ignore_children]
+    def compare_children(n1_set, n2_set, opts, differences, diff_children: false, status: EQUIVALENT)
+      return status if opts[:ignore_children]
+      return compare_aligned_children(n1_set, n2_set, opts, differences, diff_children: diff_children, status: status) if opts[:verbose] && opts[:align_children]
+      i = 0
+      j = 0
       while i < n1_set.length || j < n2_set.length
-        if !n1_set[i].nil? && nodeExcluded?(n1_set[i], opts)
+        if !n1_set[i].nil? && node_excluded?(n1_set[i], opts)
           i += 1 # increment counter if left node is excluded
-        elsif !n2_set[j].nil? && nodeExcluded?(n2_set[j], opts)
+        elsif !n2_set[j].nil? && node_excluded?(n2_set[j], opts)
           j += 1 # increment counter if right node is excluded
         else
-          result = diffchildren ? compareNodes(n1_set[i], n2_set[j], opts, differences, opts, diffchildren) : compareNodes(n1_set[i], n2_set[j], opts, differences)
+          result = diff_children ? compare_nodes(n1_set[i], n2_set[j], opts, differences, opts, diff_children: diff_children) : compare_nodes(n1_set[i], n2_set[j], opts, differences)
           status = result unless result == EQUIVALENT
 
           # return false so that this subtree could halt comparison on error
@@ -213,10 +217,116 @@ module CompareXML
           break unless status == EQUIVALENT || opts[:verbose]
 
           # increment both counters when both nodes have been compared
-          i += 1; j += 1
+          i += 1
+          j += 1
+        end
+      end
+      status
+    end
+
+    ##
+    # Compares two sets of child nodes by first aligning them, so that inserted or
+    # removed nodes are reported as additions/removals rather than as changes.
+    # Identical subtrees are matched as anchors (via a longest common subsequence
+    # of their fingerprints); the unmatched nodes between anchors are compared
+    # positionally, and any leftovers become additions or removals.
+    #
+    def compare_aligned_children(n1_set, n2_set, opts, differences, diff_children: false, status: EQUIVALENT)
+      left = n1_set.reject { |n| node_excluded?(n, opts) }
+      right = n2_set.reject { |n| node_excluded?(n, opts) }
+      cache = {}.compare_by_identity
+      fingerprints_left = left.map { |n| node_fingerprint(n, opts, cache) }
+      fingerprints_right = right.map { |n| node_fingerprint(n, opts, cache) }
+
+      prev_i = 0
+      prev_j = 0
+      anchors = longest_common_subsequence(fingerprints_left, fingerprints_right)
+      (anchors + [[left.length, right.length]]).each do |anchor_i, anchor_j|
+        result = compare_child_gap(left[prev_i...anchor_i], right[prev_j...anchor_j], opts, differences, diff_children)
+        status = result unless result == EQUIVALENT
+        prev_i = anchor_i + 1
+        prev_j = anchor_j + 1
+      end
+      status
+    end
+
+    ##
+    # Compares a run of unmatched left and right nodes that lies between two anchors.
+    # Overlapping nodes are compared positionally; remaining left nodes are reported
+    # as removals and remaining right nodes as additions.
+    #
+    def compare_child_gap(left, right, opts, differences, diff_children, status: EQUIVALENT)
+      common = [left.length, right.length].min
+      common.times do |k|
+        result = diff_children ? compare_nodes(left[k], right[k], opts, differences, opts, diff_children: diff_children) : compare_nodes(left[k], right[k], opts, differences)
+        status = result unless result == EQUIVALENT
+      end
+      left.drop(common).each do |n|
+        status = MISSING_NODE
+        add_difference(n, nil, n, nil, opts, differences)
+      end
+      right.drop(common).each do |n|
+        status = MISSING_NODE
+        add_difference(nil, n, nil, n, opts, differences)
+      end
+      status
+    end
+
+    ##
+    # Builds a canonical, option-aware string for a node so that two nodes with equal
+    # fingerprints are guaranteed to be equivalent under the current options. Used to
+    # anchor identical subtrees during alignment. Results are memoized per comparison.
+    #
+    def node_fingerprint(node, opts, cache)
+      cache[node] ||= build_node_fingerprint(node, opts, cache)
+    end
+
+    def build_node_fingerprint(node, opts, cache)
+      case node
+      when Nokogiri::XML::Comment
+        "C:#{opts[:collapse_whitespace] ? collapse(node.content) : node.content}"
+      when Nokogiri::XML::Text
+        "T:#{opts[:collapse_whitespace] ? collapse(node.content) : node.content}"
+      when Nokogiri::XML::Element
+        attrs = node.attribute_nodes
+        attrs = attrs.sort_by(&:name) if opts[:ignore_attr_order]
+        attr_str = attrs.map { |a| "#{a.name}=#{a.value}" }.join(' ')
+        children = node.children.reject { |c| node_excluded?(c, opts) }
+        child_str = children.map { |c| node_fingerprint(c, opts, cache) }.join
+        "E:#{node.name}[#{attr_str}](#{child_str})"
+      else
+        "O:#{node.class}:#{node}"
+      end
+    end
+
+    ##
+    # Returns the index pairs of a longest common subsequence of the two arrays.
+    #
+    def longest_common_subsequence(a, b)
+      m = a.length
+      n = b.length
+      lengths = Array.new(m + 1) { Array.new(n + 1, 0) }
+      (m - 1).downto(0) do |i|
+        (n - 1).downto(0) do |j|
+          lengths[i][j] = a[i] == b[j] ? lengths[i + 1][j + 1] + 1 : [lengths[i + 1][j], lengths[i][j + 1]].max
+        end
+      end
+
+      pairs = []
+      i = 0
+      j = 0
+      while i < m && j < n
+        if a[i] == b[j]
+          pairs << [i, j]
+          i += 1
+          j += 1
+        elsif lengths[i + 1][j] >= lengths[i][j + 1]
+          i += 1
+        else
+          j += 1
         end
-        status
       end
+      pairs
     end
 
     ##
@@ -228,21 +338,22 @@ module CompareXML
     #   @param [Nokogiri::XML::Element] n2 right node element
     #   @param [Hash] opts user-overridden options
     #   @param [Array] differences inequivalence messages
-    #   @param [Hash] childopts user-overridden options used for the child nodes
-    #   @param [Bool] diffchildren use different options for the child nodes
+    #   @param [Hash] child_opts user-overridden options used for the child nodes
+    #   @param [Bool] diff_children use different options for the child nodes
     #   @param [int] status comparison status code (EQUIVALENT by default)
     #
     #   @return type of equivalence (from equivalence constants)
     #
-    def compareElementNodes(n1, n2, opts, differences, childopts = {}, diffchildren = false, status = EQUIVALENT)
+    def compare_element_nodes(n1, n2, opts, differences, child_opts = {}, diff_children: false, status: EQUIVALENT)
       if n1.name == n2.name
-        result = compareAttributeSets(n1, n2, n1.attribute_nodes, n2.attribute_nodes, opts, differences)
+        result = compare_attribute_sets(n1, n2, n1.attribute_nodes, n2.attribute_nodes, opts, differences)
         return result unless result == EQUIVALENT || opts[:force_children] == true
-        result = diffchildren ? compareChildren(n1.children, n2.children, childopts, differences, diffchildren) : compareChildren(n1.children, n2.children, opts, differences)
+        status = result unless result == EQUIVALENT
+        result = diff_children ? compare_children(n1.children, n2.children, child_opts, differences, diff_children: diff_children) : compare_children(n1.children, n2.children, opts, differences)
         status = result unless result == EQUIVALENT
       else
         status = UNEQUAL_ELEMENTS
-        addDifference(n1, n2, n1.name, n2.name, opts, differences)
+        add_difference(n1, n2, n1.name, n2.name, opts, differences)
       end
       status
     end
@@ -250,16 +361,16 @@ module CompareXML
     ##
     # Compares two nodes of type Nokogiri::XML::Text.
     #
-    #   @param [Nokogiri::XML::Text] n1 left text node
-    #   @param [Nokogiri::XML::Text] n2 right text node
+    #   @param [Nokogiri::XML::Element] n1 left text node
+    #   @param [Nokogiri::XML::Element] n2 right text node
     #   @param [Hash] opts user-overridden options
     #   @param [Array] differences inequivalence messages
     #   @param [int] status comparison status code (EQUIVALENT by default)
     #
     #   @return type of equivalence (from equivalence constants)
     #
-    def compareTextNodes(n1, n2, opts, differences, status = EQUIVALENT)
-      return true if opts[:ignore_text_nodes]
+    def compare_text_nodes(n1, n2, opts, differences, status = EQUIVALENT)
+      return status if opts[:ignore_text_nodes]
       t1 = n1.content
       t2 = n2.content
       if opts[:collapse_whitespace]
@@ -268,7 +379,7 @@ module CompareXML
       end
       unless t1 == t2
         status = UNEQUAL_TEXT_CONTENTS
-        addDifference(n1.parent, n2.parent, t1, t2, opts, differences)
+        add_difference(n1.parent, n2.parent, t1, t2, opts, differences)
       end
       status
     end
@@ -285,12 +396,14 @@ module CompareXML
     #
     #   @return type of equivalence (from equivalence constants)
     #
-    def compareAttributeSets(n1, n2, a1_set, a2_set, opts, differences)
+    def compare_attribute_sets(n1, n2, a1_set, a2_set, opts, differences)
+      a1_set = a1_set.reject { |a| attribute_excluded?(a, opts) }
+      a2_set = a2_set.reject { |a| attribute_excluded?(a, opts) }
       return false unless a1_set.length == a2_set.length || opts[:verbose]
       if opts[:ignore_attr_order]
-        compareSortedAttributeSets(n1, n2, a1_set, a2_set, opts, differences)
+        compare_sorted_attribute_sets(n1, n2, a1_set, a2_set, opts, differences)
       else
-        compareUnsortedAttributeSets(n1, n2, a1_set, a2_set, opts, differences)
+        compare_unsorted_attribute_sets(n1, n2, a1_set, a2_set, opts, differences)
       end
     end
 
@@ -309,7 +422,7 @@ module CompareXML
     #
     #   @return type of equivalence (from equivalence constants)
     #
-    def compareSortedAttributeSets(n1, n2, a1_set, a2_set, opts, differences, status = EQUIVALENT)
+    def compare_sorted_attribute_sets(n1, n2, a1_set, a2_set, opts, differences, status = EQUIVALENT)
       a1_set = a1_set.sort_by(&:name)
       a2_set = a2_set.sort_by(&:name)
       i = j = 0
@@ -317,15 +430,21 @@ module CompareXML
       while i < a1_set.length || j < a2_set.length
 
         if a1_set[i].nil?
-          result = compareAttributes(n1, n2, nil, a2_set[j], opts, differences); j += 1
+          result = compare_attributes(n1, n2, nil, a2_set[j], opts, differences)
+          j += 1
         elsif a2_set[j].nil?
-          result = compareAttributes(n1, n2, a1_set[i], nil, opts, differences); i += 1
+          result = compare_attributes(n1, n2, a1_set[i], nil, opts, differences)
+          i += 1
         elsif a1_set[i].name < a2_set[j].name
-          result = compareAttributes(n1, n2, a1_set[i], nil, opts, differences); i += 1
+          result = compare_attributes(n1, n2, a1_set[i], nil, opts, differences)
+          i += 1
         elsif a1_set[i].name > a2_set[j].name
-          result = compareAttributes(n1, n2, nil, a2_set[j], opts, differences); j += 1
+          result = compare_attributes(n1, n2, nil, a2_set[j], opts, differences)
+          j += 1
         else
-          result = compareAttributes(n1, n2, a1_set[i], a2_set[j], opts, differences); i += 1; j += 1
+          result = compare_attributes(n1, n2, a1_set[i], a2_set[j], opts, differences)
+          i += 1
+          j += 1
         end
 
         status = result unless result == EQUIVALENT
@@ -350,11 +469,11 @@ module CompareXML
     #
     #   @return type of equivalence (from equivalence constants)
     #
-    def compareUnsortedAttributeSets(n1, n2, a1_set, a2_set, opts, differences, status = EQUIVALENT)
+    def compare_unsorted_attribute_sets(n1, n2, a1_set, a2_set, opts, differences, status = EQUIVALENT)
       [a1_set.length, a2_set.length].max.times do |i|
-        result = compareAttributes(n1, n2, a1_set[i], a2_set[i], opts, differences)
+        result = compare_attributes(n1, n2, a1_set[i], a2_set[i], opts, differences)
         status = result unless result == EQUIVALENT
-        break unless status == EQUIVALENT
+        break unless status == EQUIVALENT || opts[:verbose]
       end
       status
     end
@@ -362,34 +481,31 @@ module CompareXML
     ##
     # Compares two attributes by name and value.
     #
-    #   @param [Nokogiri::XML::Element] n1 left node element
-    #   @param [Nokogiri::XML::Element] n2 right node element
-    #   @param [Nokogiri::XML::Attr] a1 left attribute
-    #   @param [Nokogiri::XML::Attr] a2 right attribute
+    #   @param [Nokogiri::XML::Element|NilClass] n1 left node element
+    #   @param [Nokogiri::XML::Element|NilClass] n2 right node element
+    #   @param [Nokogiri::XML::Attr|NilClass] a1 left attribute
+    #   @param [Nokogiri::XML::Attr|NilClass] a2 right attribute
     #   @param [Hash] opts user-overridden options
     #   @param [Array] differences inequivalence messages
     #   @param [int] status comparison status code (EQUIVALENT by default)
     #
     #   @return type of equivalence (from equivalence constants)
     #
-    def compareAttributes(n1, n2, a1, a2, opts, differences, status = EQUIVALENT)
+    def compare_attributes(n1, n2, a1, a2, opts, differences, status = EQUIVALENT)
       if a1.nil?
         status = MISSING_ATTRIBUTE
-        addDifference(n1, n2, nil, "#{a2.name}=\"#{a2.value}\"", opts, differences)
+        add_difference(n1, n2, nil, "#{a2.name}=\"#{a2.value}\"", opts, differences)
       elsif a2.nil?
         status = MISSING_ATTRIBUTE
-        addDifference(n1, n2, "#{a1.name}=\"#{a1.value}\"", nil, opts, differences)
+        add_difference(n1, n2, "#{a1.name}=\"#{a1.value}\"", nil, opts, differences)
       elsif a1.name == a2.name
-        return status if attrNameExcluded?(a1.name, a2.name, opts)
-        return status if attrsExcluded?(a1, a2, opts)
-        return status if attrContentExcluded?(a1, a2, opts)
         if a1.value != a2.value
           status = UNEQUAL_ATTRIBUTES
-          addDifference(n1, n2, "#{a1.name}=\"#{a1.value}\"", "#{a2.name}=\"#{a2.value}\"", opts, differences)
+          add_difference(n1, n2, "#{a1.name}=\"#{a1.value}\"", "#{a2.name}=\"#{a2.value}\"", opts, differences)
         end
       else
         status = UNEQUAL_ATTRIBUTES
-        addDifference(n1, n2, "#{a1.name}=\"#{a1.value}\"", "#{a2.name}=\"#{a2.value}\"", opts, differences)
+        add_difference(n1, n2, "#{a1.name}=\"#{a1.value}\"", "#{a2.name}=\"#{a2.value}\"", opts, differences)
       end
       status
     end
@@ -408,7 +524,7 @@ module CompareXML
     #
     #   @return true if excluded, false otherwise
     #
-    def nodeExcluded?(n, opts)
+    def node_excluded?(n, opts)
       return true if n.is_a?(Nokogiri::XML::DTD)
       return true if n.is_a?(Nokogiri::XML::Comment) && opts[:ignore_comments]
       return true if n.is_a?(Nokogiri::XML::Text) && (opts[:ignore_text_nodes] || collapse(n.content).empty?)
@@ -417,84 +533,40 @@ module CompareXML
     end
 
     ##
-    # Checks whether two given attributes should be excluded, based on a user-specified css rule.
-    # If true, only the specified attributes are ignored; all remaining attributes are still compared.
-    # The CSS rule is used to locate the node that contains the attributes to be excluded.
-    # The CSS rule MUST contain the name of the attribute to be ignored.
-    #
-    #   @param [Nokogiri::XML::Attr] a1 left attribute
-    #   @param [Nokogiri::XML::Attr] a2 right attribute
-    #   @param [Hash] opts user-overridden options
+    # Determines whether a single attribute should be excluded from comparison, based on
+    # the +ignore_attrs_by_name+, +ignore_attr_content+ and +ignore_attrs+ options. The
+    # check is one-sided, so an attribute is dropped even when its counterpart is missing
+    # on the other element.
     #
-    #   @return true if excluded, false otherwise
+    # Name matchers are compared with +===+: a String matches the attribute name exactly,
+    # while a Regexp matches it as a pattern.
     #
-    def attrsExcluded?(a1, a2, opts)
-      opts[:ignore_attrs].each do |css|
-        if css.include?(a1.name) && css.include?(a2.name)
-          return true if a1.parent.xpath('../*').css(css).include?(a1.parent) && a2.parent.xpath('../*').css(css).include?(a2.parent)
-        end
-      end
-      false
-    end
-
-    ##
-    # Checks whether two given attributes should be excluded, based on their content.
-    # Checks whether both attributes contain content that should be excluded, and
-    # returns true only if an excluded string is contained in both attribute values.
-    #
-    #   @param [Nokogiri::XML::Attr] a1 left attribute
-    #   @param [Nokogiri::XML::Attr] a2 right attribute
+    #   @param [Nokogiri::XML::Attr] attr the attribute being tested
     #   @param [Hash] opts user-overridden options
     #
     #   @return true if excluded, false otherwise
     #
-    def attrContentExcluded?(a1, a2, opts)
-      a1_excluded = false
-      a2_excluded = false
-      opts[:ignore_attr_content].each do |content|
-        a1_excluded ||= a1.value.include?(content)
-        a2_excluded ||= a2.value.include?(content)
-        return true if a1_excluded && a2_excluded
-      end
-      false
-    end
+    def attribute_excluded?(attr, opts)
+      return true if opts[:ignore_attrs_by_name].any? { |matcher| matcher === attr.name }
+      return true if opts[:ignore_attr_content].any? { |content| attr.value.include?(content) }
 
-    ##
-    # Checks whether two given attributes should be excluded, based on their content.
-    # Checks whether both attributes contain content that should be excluded, and
-    # returns true only if an excluded string is contained in both attribute values.
-    #
-    #   @param [Nokogiri::XML::Attr] a1 left attribute
-    #   @param [Nokogiri::XML::Attr] a2 right attribute
-    #   @param [Hash] opts user-overridden options
-    #
-    #   @return true if excluded, false otherwise
-    #
-    def attrNameExcluded?(a1, a2, opts)
-      a1_excluded = false
-      a2_excluded = false
-      opts[:ignore_attrs_by_name].each do |name|
-        a1_excluded ||= a1.to_s.include?(name)
-        a2_excluded ||= a2.to_s.include?(name)
-        return true if a1_excluded && a2_excluded
-      end
-      false
+      opts[:ignore_attrs].any? { |css| css.include?(attr.name) && attr.parent.xpath('../*').css(css).include?(attr.parent) }
     end
 
     ##
     # Strips the whitespace (from beginning and end) and collapses it,
     # i.e. multiple spaces, new lines and tabs are all collapsed to a single space.
     #
-    #   @param [Nokogiri::XML::Node] node1 left node
-    #   @param [Nokogiri::XML::Node] node2 right node
-    #   @param [String] diff1 left diffing value
-    #   @param [String] diff2 right diffing value
+    #   @param [Nokogiri::XML::Element|NilClass] node1 left node
+    #   @param [Nokogiri::XML::Element|NilClass] node2 right node
+    #   @param [String|NilClass] diff1 left diffing value
+    #   @param [String|NilClass] diff2 right diffing value
     #   @param [Hash] opts user-overridden options
     #   @param [Array] differences inequivalence messages
     #
     #   @return collapsed string
     #
-    def addDifference(node1, node2, diff1, diff2, opts, differences)
+    def add_difference(node1, node2, diff1, diff2, opts, differences)
       differences << { node1: node1, node2: node2, diff1: diff1, diff2: diff2 } if opts[:verbose]
     end
 

metadata

@@ -1,55 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: compare-xml
 version: !ruby/object:Gem::Version
-  version: '0.66'
+  version: 1.0.0
 platform: ruby
 authors:
 - Vadim Kononov
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-04-24 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.6'
 description: CompareXML is a fast, lightweight and feature-rich tool that will solve
   your XML/HTML comparison or diffing needs. its purpose is to compare two instances
   of Nokogiri::XML::Node or Nokogiri::XML::NodeSet for equality or equivalency.
 email:
-- vadim@poetic.com
+- vadim@konoson.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rubocop.yml"
-- Gemfile
 - LICENSE.txt
 - README.md
-- Rakefile
-- bin/console
-- bin/setup
-- compare-xml.gemspec
-- img/diffing.png
 - lib/compare-xml.rb
 - lib/compare-xml/version.rb
 homepage: https://github.com/vkononov/compare-xml
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/vkononov/compare-xml
+  source_code_uri: https://github.com/vkononov/compare-xml
+  changelog_uri: https://github.com/vkononov/compare-xml/releases
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -57,16 +51,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
-signing_key: 
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A customizable tool that compares two instances of Nokogiri::XML::Node for
   equality or equivalency.

data/.gitignore

@@ -1,13 +0,0 @@
-*.DS_Store
-*thumbs.db
-/*.gem
-/.bundle/
-/.idea/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/Gemfile.lock
-/pkg/
-/spec/reports/
-/tmp/

data/.rubocop.yml

@@ -1,45 +0,0 @@
-AllCops:
-#  Exclude:
-#    - config/routes.rb
-#    - db/migrate/*
-#    - db/schema.rb
-  TargetRubyVersion: 2.5
-
-Metrics/AbcSize:
-  Enabled: false
-
-Metrics/CyclomaticComplexity:
-  Enabled: false
-
-Metrics/LineLength:
-  Enabled: false
-
-Metrics/MethodLength:
-  Enabled: false
-
-Metrics/ModuleLength:
-  Enabled: false
-
-Metrics/ParameterLists:
-  Enabled: false
-
-Metrics/PerceivedComplexity:
-  Enabled: false
-
-Naming/FileName:
-  Enabled: false
-
-Naming/MethodName:
-  Enabled: false
-
-Naming/UncommunicativeMethodParamName:
-  Enabled: false
-
-Style/Documentation:
-  Enabled: false
-
-Style/FrozenStringLiteralComment:
-  Enabled: false
-
-Style/Semicolon:
-  Enabled: false

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in compare-xml-xml.gemspec
-gemspec

data/Rakefile

@@ -1,2 +0,0 @@
-require 'bundler/gem_tasks'
-task default: :spec

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'bundler/setup'
-require 'compare-xml/xml'
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require 'pry'
-# Pry.start
-
-require 'irb'
-IRB.start

data/bin/setup

@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install
-
-# Do any other automated setup that you need to do here

data/compare-xml.gemspec

@@ -1,22 +0,0 @@
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'compare-xml/version'
-
-Gem::Specification.new do |spec|
-  spec.name          = 'compare-xml'
-  spec.version       = CompareXML::VERSION
-  spec.authors       = ['Vadim Kononov']
-  spec.email         = ['vadim@poetic.com']
-
-  spec.summary       = 'A customizable tool that compares two instances of Nokogiri::XML::Node for equality or equivalency.'
-  spec.description   = 'CompareXML is a fast, lightweight and feature-rich tool that will solve your XML/HTML comparison or diffing needs. its purpose is to compare two instances of Nokogiri::XML::Node or Nokogiri::XML::NodeSet for equality or equivalency.'
-  spec.homepage      = 'https://github.com/vkononov/compare-xml'
-  spec.license       = 'MIT'
-
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  spec.add_runtime_dependency 'nokogiri', '~> 1.8'
-end