`, etc).
**Usage Example:** `CompareXML.equivalent?(doc1, doc2, {ignore_attr_content: ['button']})`
**Example:** With `ignore_attr_content: ['button']` the following HTML strings are considered equal:
Link
Link
**Example:** With `ignore_attr_content: ['menu']` the following HTML strings are considered equal:
Link
----------
-
`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).
**Usage Example:** `CompareXML.equivalent?(doc1, doc2, {ignore_attrs: ['a[rel="nofollow"]', 'input[type="hidden"']})`
**Example:** With `ignore_attrs: ['a[rel="nofollow"]', 'a[target]']` the following HTML strings are considered equal:
Link
Link
**Example:** With `ignore_attrs: ['a[href^="http"]', 'a[class*="button"]']` the following HTML strings are considered equal:
Link
Link
----------
- `ignore_comments: {true|false}` default: **`true`**
When `true`, ignores comments, such as ``.
**Usage Example:** `CompareXML.equivalent?(doc1, doc2, {ignore_comments: true})`
**Example:** When `true` the following HTML strings are considered equal:
**Example:** When `true` the following HTML strings are considered equal:
Link
Link
----------
-
`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).
**Usage Example:** `CompareXML.equivalent?(doc1, doc2, {ignore_nodes: ['script', 'object']})`
**Example:** With `ignore_nodes: ['a[rel="nofollow"]', 'a[target]']` the following HTML strings are considered equal:
Link 1
Link 2
**Example:** With `ignore_nodes: ['b', 'i']` the following HTML strings are considered equal:
Warning: Link
Message: Link
----------
-
`ignore_text_nodes: {true|false}` default: **`false`**
When `true`, ignores all text content. Text content is anything that is included between an opening and a closing tag, e.g. `
THIS IS TEXT CONTENT`.
**Usage Example:** `CompareXML.equivalent?(doc1, doc2, {ignore_text_nodes: true})`
**Example:** When `true` the following HTML strings are considered equal:
SOME TEXT CONTENT
DIFFERENT TEXT CONTENT
**Example:** When `true` the following HTML strings are considered equal:
Message:
----------
-
`verbose: {true|false}` default: **`false`**
When `true`, instead of returning a boolean value `CompareXML.equivalent?` returns an array of all errors encountered when performing a comparison.
> **Warning:** When `true`, the comparison takes longer! Not only because more processing is required to produce meaningful differences, but also because in this mode, comparison does **NOT** stop when a first difference is encountered, because the goal is to capture as many differences as possible.
**Usage Example:** `CompareXML.equivalent?(doc1, doc2, {verbose: true})`
**Example:** When `true` given the following HTML strings:
`CompareXML.equivalent?(doc1, doc2, {verbose: true})` will produce an array shown below.
```ruby
[
{
node1: '
TITLE',
node2: '
ANOTHER TITLE',
diff1: 'TITLE',
diff2: 'ANOTHER TITLE',
},
{
node1: '
SOME HEADING
',
node2: '
SOME HEADING
',
diff1: nil,
diff2: 'id="main"',
},
{
node1: '
Link',
node2: '
Link',
diff1: '"rel="icon"',
diff2: '"rel="button"',
},
{
node1: '
Author Name',
node2: nil,
diff1: '
Author Name',
diff2: nil,
},
{
node1: '',
node1: '',
diff1: 'p',
diff2: 'div',
}
]
```
The structure of each hash inside the array is:
node1: [Nokogiri::XML::Node] left node that contains the difference
node2: [Nokogiri::XML::Node] right node that contains the difference
diff1: [Nokogiri::XML::Node|String] left difference
diff1: [Nokogiri::XML::Node|String] right difference
**Node location** of `html:body:p(4)` means that the element in question is `
`, its hierarchical ancestors are `html > body`, and it is the **4th** `
` tag. That is, it could be found in
onetwothreeTARGET
> **Note:** `p(4)` means that it is the fourth tag of type `
`, but there could be many other tags of other types between `p(3)` and `p(4)`.
**Node content** displays the discrepancy in content (which could be the name of the tag, attributes, text content, comments, etc)
**Error code** is a numeric value that indicates the type of a discrepancy. CompareXML implements the following error codes
```ruby
EQUIVALENT = 1 # nodes are equal (for internal use only)
MISSING_ATTRIBUTE = 2 # attribute is missing its counterpart
MISSING_NODE = 3 # node is missing its counterpart
UNEQUAL_ATTRIBUTES = 4 # attributes are not equal
UNEQUAL_COMMENTS = 5 # comment contents are not equal
UNEQUAL_DOCUMENTS = 6 # document types are not equal
UNEQUAL_ELEMENTS = 7 # nodes have the same type but are not equal
UNEQUAL_NODES_TYPES = 8 # nodes do not have the same type
UNEQUAL_TEXT_CONTENTS = 9 # text contents are not equal
```
Here is an example of how these could be used:
```ruby
case error_code
when CompareXML::UNEQUAL_ATTRIBUTES
'!='
when CompareXML::MISSING_ATTRIBUTE
'?'
end
```
## Contributing
1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request
## Credits
This gem was inspired by [Michael B. Klein](https://github.com/mbklein)'s gem [`equivalent-xml`](https://github.com/mbklein/equivalent-xml) - another excellent tool for XML comparison.
## License
The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).