compare-xml 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '044582cb43241dc59a65422b8c36a2cc96d1a3120f9648c0950b7ef9fe125be5'
-  data.tar.gz: 3a33391e6f5a67f305546173a43725a64bd6ed4df12135434453da9bc3982e98
+  metadata.gz: ed20155c59d477002fe69c2883e0a8d3b3b9507aa042f95d41cb3693b044e56d
+  data.tar.gz: 99c9374d3ac9bd98fe3e4b1fbad74b7bb4e1bea0f55ee475b41f401d8a60123e
 SHA512:
-  metadata.gz: 0f3a32d528e4298a96ce59238f7ed556fa110ea7a4d715b651e1e578887f6bde9c6852928d0971c114e6ca9fb77dca8c4e6ca53c9580143cc5d89785ca14d942
-  data.tar.gz: fc8371bdce1193d15d42092c24b9b44d2d9c51a685331102ba69fd9290cafdd6faf588feab68871b1c7659c42ed1f1656718b97b72fbf0702bde153e3a2caf30
+  metadata.gz: ba79f1cd40d906b02752a50cdc37f7c82200077a7f1e7c9e5f530e046c67ad445a4830d87082715c9f96405363c116deb5cbc9d1df276906dc52dcd1098565d9
+  data.tar.gz: 9b25dfa936e79f2e15137ceece697f7f909344b628b79e51450598660989ca0b7604b6e44272fcbb4a19676ebd6eb719939e8b1c4b4a6d424edf57aac2786067

data/README.md

@@ -1,13 +1,14 @@
 # CompareXML
 
-[![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)
+[![Gem Version](https://img.shields.io/gem/v/compare-xml.svg?label=Gem&logo=rubygems&logoColor=white)](https://rubygems.org/gems/compare-xml)
+[![Ruby](https://img.shields.io/badge/Ruby-2.4%20to%204.0-CC342D?logo=ruby&logoColor=white)](https://github.com/vkononov/compare-xml/blob/main/.github/workflows/test.yml)
+[![Test Matrix](https://img.shields.io/github/actions/workflow/status/vkononov/compare-xml/test.yml?branch=main&label=Test%20Matrix&logo=github)](https://github.com/vkononov/compare-xml/actions/workflows/test.yml)
+[![Lint](https://img.shields.io/github/actions/workflow/status/vkononov/compare-xml/lint.yml?branch=main&label=Lint&logo=github)](https://github.com/vkononov/compare-xml/actions/workflows/lint.yml)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/license/MIT)
 
 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)
+Supports **Ruby 2.4 → latest**, with the full Ruby matrix tested daily in CI.
 
 **Features**
 
@@ -30,7 +31,9 @@ And then execute:
 
 Or install it yourself as:
 
-    gem install compare-xml
+```sh
+gem install compare-xml
+```
 
 
 
@@ -49,8 +52,8 @@ where `doc1` and `doc2` are instances of `Nokogiri::XML::Node` or `Nokogiri::XML
 Suppose you have two files `1.html` and `2.html` that you would like to compare. You could do it as follows:
 
 ```ruby
-doc1 = Nokogiri::HTML(open('1.html'))
-doc2 = Nokogiri::HTML(open('2.html'))
+doc1 = Nokogiri::HTML(File.read('1.html'))
+doc2 = Nokogiri::HTML(File.read('2.html'))
 puts CompareXML.equivalent?(doc1, doc2)
 ```
 
@@ -81,7 +84,7 @@ CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true})
     - when provided, ignores all attributes that contain substrings `string`, `string2`, etc.
 
 - `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)
+    - when provided, ignores specific *attributes* using [CSS selectors](https://www.w3schools.com/cssref/css_selectors.php)
 
 - `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)
@@ -90,7 +93,7 @@ CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true})
     - when `true`, ignores comments, such as `<!-- comment -->`
 
 - `ignore_nodes: [css_selector1, css_selector1, ...]` default: **`[]`** &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[show examples ⇨](#ignore_nodes)
-    - when provided, ignores specific *nodes* using [CSS selectors](http://www.w3schools.com/cssref/css_selectors.asp)
+    - when provided, ignores specific *nodes* using [CSS selectors](https://www.w3schools.com/cssref/css_selectors.php)
 
 - `ignore_text_nodes: {true|false}` default: **`false`**&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;[show examples ⇨](#ignore_text_nodes)
     - when `true`, ignores all text content within a document
@@ -188,7 +191,7 @@ CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true})
 
 - <a id="ignore_attrs"></a>`ignore_attrs: [css_selector1, css_selector1, ...]` default: **`[]`**
 
-    When provided, ignores all **attributes** that satisfy a particular rule using [CSS selectors](http://www.w3schools.com/cssref/css_selectors.asp).
+    When provided, ignores all **attributes** that satisfy a particular rule using [CSS selectors](https://www.w3schools.com/cssref/css_selectors.php).
 
     **Usage Example:** `CompareXML.equivalent?(doc1, doc2, {ignore_attrs: ['a[rel="nofollow"]', 'input[type="hidden"']})`
 
@@ -250,7 +253,7 @@ CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true})
 
 - <a id="ignore_nodes"></a>`ignore_nodes: [css_selector1, css_selector1, ...]` default: **`[]`**
 
-    When provided, ignores all **nodes** that satisfy a particular rule using [CSS selectors](http://www.w3schools.com/cssref/css_selectors.asp).
+    When provided, ignores all **nodes** that satisfy a particular rule using [CSS selectors](https://www.w3schools.com/cssref/css_selectors.php).
 
     **Usage Example:** `CompareXML.equivalent?(doc1, doc2, {ignore_nodes: ['script', 'object']})`
 
@@ -382,6 +385,31 @@ CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: false, verbose: true})
 
 ----------
 
+## Separate Options for Child Nodes
+
+`CompareXML.equivalent?` accepts two further optional arguments that let child nodes be compared under a different set of options than the root:
+
+```ruby
+CompareXML.equivalent?(doc1, doc2, opts = {}, child_opts = {}, diff_children = false)
+```
+
+- `child_opts` - a second options hash, merged over the defaults the same way as `opts`, applied to child nodes
+- `diff_children` - when `true`, child nodes are compared using `child_opts` instead of `opts`
+
+`child_opts` is ignored unless `diff_children` is `true`.
+
+**Example:** compare the root strictly, but ignore text content within child nodes:
+
+```ruby
+doc1 = Nokogiri::HTML('<html><body><p>Hello</p></body></html>')
+doc2 = Nokogiri::HTML('<html><body><p>Goodbye</p></body></html>')
+
+CompareXML.equivalent?(doc1, doc2) # => false
+CompareXML.equivalent?(doc1, doc2, {}, { ignore_text_nodes: true }, true) # => true
+```
+
+----------
+
 ## Contributing
 
 1. Fork it
@@ -400,4 +428,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](https://opensource.org/license/MIT).

data/lib/compare-xml/version.rb

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

data/lib/compare-xml.rb

@@ -107,6 +107,8 @@ module CompareXML
     def compare_nodes(n1, n2, opts, differences, child_opts = {}, diff_children: false)
       if n1.instance_of?(n2.class)
         case n1
+        when Nokogiri::XML::ProcessingInstruction
+          status = compare_processing_instructions(n1, n2, opts, differences)
         when Nokogiri::XML::Comment
           status = compare_comment_nodes(n1, n2, opts, differences)
         when Nokogiri::HTML::Document
@@ -115,6 +117,8 @@ module CompareXML
           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 = compare_text_nodes(n1, n2, opts, differences)
+        when Nokogiri::XML::NodeSet
+          status = diff_children ? compare_children(n1, n2, child_opts, differences, diff_children: diff_children) : compare_children(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 = compare_children(n1.children, n2.children, opts, differences)
@@ -135,6 +139,13 @@ module CompareXML
       status
     end
 
+    def compare_processing_instructions(n1, n2, opts, differences)
+      return EQUIVALENT if n1.name == n2.name && n1.content == n2.content
+
+      add_difference(n1, n2, n1, n2, opts, differences)
+      UNEQUAL_ELEMENTS
+    end
+
     ##
     # Compares two nodes of type Nokogiri::HTML::Comment.
     #
@@ -273,7 +284,7 @@ module CompareXML
     end
 
     ##
-    # Builds a canonical, option-aware string for a node so that two nodes with equal
+    # Builds a structured, option-aware fingerprint 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.
     #
@@ -283,19 +294,16 @@ module CompareXML
 
     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::Comment, Nokogiri::XML::Text
+        [node.class, 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})"
+        attrs = node.attribute_nodes.reject { |attr| attribute_excluded?(attr, opts) }
+        attrs = attrs.sort_by { |attr| attribute_name(attr) } if opts[:ignore_attr_order]
+        attributes = attrs.map { |attr| [attribute_name(attr), attr.value] }
+        children = opts[:ignore_children] ? [] : node.children.reject { |child| node_excluded?(child, opts) }
+        [node.class, element_name(node), attributes, children.map { |child| node_fingerprint(child, opts, cache) }]
       else
-        "O:#{node.class}:#{node}"
+        [node.class, node.to_s]
       end
     end
 
@@ -345,7 +353,7 @@ module CompareXML
     #   @return type of equivalence (from equivalence constants)
     #
     def compare_element_nodes(n1, n2, opts, differences, child_opts = {}, diff_children: false, status: EQUIVALENT)
-      if n1.name == n2.name
+      if element_name(n1) == element_name(n2)
         result = compare_attribute_sets(n1, n2, n1.attribute_nodes, n2.attribute_nodes, opts, differences)
         return result unless result == EQUIVALENT || opts[:force_children] == true
         status = result unless result == EQUIVALENT
@@ -353,11 +361,24 @@ module CompareXML
         status = result unless result == EQUIVALENT
       else
         status = UNEQUAL_ELEMENTS
-        add_difference(n1, n2, n1.name, n2.name, opts, differences)
+        add_difference(n1, n2, element_name(n1), element_name(n2), opts, differences)
       end
       status
     end
 
+    ##
+    # Returns the element name qualified by its namespace URI, so that elements with
+    # the same local name in different namespaces are not treated as equal.
+    #
+    #   @param [Nokogiri::XML::Element] node the element
+    #
+    #   @return [String] the local name, prefixed with "{uri}" when namespaced
+    #
+    def element_name(node)
+      href = node.namespace&.href
+      href ? "{#{href}}#{node.name}" : node.name
+    end
+
     ##
     # Compares two nodes of type Nokogiri::XML::Text.
     #
@@ -423,8 +444,8 @@ module CompareXML
     #   @return type of equivalence (from equivalence constants)
     #
     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)
+      a1_set = a1_set.sort_by { |attr| attribute_name(attr) }
+      a2_set = a2_set.sort_by { |attr| attribute_name(attr) }
       i = j = 0
 
       while i < a1_set.length || j < a2_set.length
@@ -435,10 +456,10 @@ module CompareXML
         elsif a2_set[j].nil?
           result = compare_attributes(n1, n2, a1_set[i], nil, opts, differences)
           i += 1
-        elsif a1_set[i].name < a2_set[j].name
+        elsif attribute_name(a1_set[i]) < attribute_name(a2_set[j])
           result = compare_attributes(n1, n2, a1_set[i], nil, opts, differences)
           i += 1
-        elsif a1_set[i].name > a2_set[j].name
+        elsif attribute_name(a1_set[i]) > attribute_name(a2_set[j])
           result = compare_attributes(n1, n2, nil, a2_set[j], opts, differences)
           j += 1
         else
@@ -478,6 +499,11 @@ module CompareXML
       status
     end
 
+    def attribute_name(attribute)
+      href = attribute.namespace&.href
+      href ? "{#{href}}#{attribute.name}" : attribute.name
+    end
+
     ##
     # Compares two attributes by name and value.
     #
@@ -494,18 +520,18 @@ module CompareXML
     def compare_attributes(n1, n2, a1, a2, opts, differences, status = EQUIVALENT)
       if a1.nil?
         status = MISSING_ATTRIBUTE
-        add_difference(n1, n2, nil, "#{a2.name}=\"#{a2.value}\"", opts, differences)
+        add_difference(n1, n2, nil, "#{attribute_name(a2)}=\"#{a2.value}\"", opts, differences)
       elsif a2.nil?
         status = MISSING_ATTRIBUTE
-        add_difference(n1, n2, "#{a1.name}=\"#{a1.value}\"", nil, opts, differences)
-      elsif a1.name == a2.name
+        add_difference(n1, n2, "#{attribute_name(a1)}=\"#{a1.value}\"", nil, opts, differences)
+      elsif attribute_name(a1) == attribute_name(a2)
         if a1.value != a2.value
           status = UNEQUAL_ATTRIBUTES
-          add_difference(n1, n2, "#{a1.name}=\"#{a1.value}\"", "#{a2.name}=\"#{a2.value}\"", opts, differences)
+          add_difference(n1, n2, "#{attribute_name(a1)}=\"#{a1.value}\"", "#{attribute_name(a2)}=\"#{a2.value}\"", opts, differences)
         end
       else
         status = UNEQUAL_ATTRIBUTES
-        add_difference(n1, n2, "#{a1.name}=\"#{a1.value}\"", "#{a2.name}=\"#{a2.value}\"", opts, differences)
+        add_difference(n1, n2, "#{attribute_name(a1)}=\"#{a1.value}\"", "#{attribute_name(a2)}=\"#{a2.value}\"", opts, differences)
       end
       status
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: compare-xml
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Vadim Kononov
@@ -23,9 +23,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         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.
+description: Compares Nokogiri XML and HTML documents, nodes and node sets for equality
+  or equivalency. Returns a list of differences and can exclude chosen nodes or attributes.
 email:
 - vadim@konoson.com
 executables: []
@@ -58,8 +57,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.20
 specification_version: 4
-summary: A customizable tool that compares two instances of Nokogiri::XML::Node for
-  equality or equivalency.
+summary: Compare XML and HTML documents or Nokogiri nodes for equality with a diff
 test_files: []