compare-xml 0.5.2 → 0.6
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/README.md +116 -119
- data/lib/compare-xml.rb +149 -125
- data/lib/compare-xml/version.rb +1 -1
- metadata +12 -12
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA1:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 24ddb2d55335e31c8bca6b26447717c51f907db9
|
|
4
|
+
data.tar.gz: 1eeccbd5f186e26e09553c577b8713a4a9eaa3d3
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: 85b1a91be2f641993997dbd9afe0c95a28f359fbe936d89d19afb8cd3e9998b3975ace6fc3e7a1a3b0a0684d6114e8ded56fa90c900673890e92d7d20415b799
|
|
7
|
+
data.tar.gz: e0548edf277dd3967495f03b7d3d3e836d2fa80a56752034f691f953270e71650cb88b5af25338fe99d48bb95c66cf9d545703c7c3fd34b2270c84865ea0824b
|
data/README.md
CHANGED
|
@@ -68,31 +68,59 @@ CompareXML has a variety of options that can be invoked as an optional argument,
|
|
|
68
68
|
CompareXML.equivalent?(doc1, doc2, {ignore_comments: false, verbose: true, ...})
|
|
69
69
|
```
|
|
70
70
|
|
|
71
|
-
- `
|
|
71
|
+
- `collapse_whitespace: {true|false}` default: **`true`** [→ read more ←](#collapse_whitespace)
|
|
72
|
+
- when `true`, trims and collapses whitespace
|
|
73
|
+
|
|
74
|
+
- `ignore_attr_order: {true|false}` default: **`true`** [→ read more ←](#ignore_attr_order)
|
|
72
75
|
- when `true`, ignores attribute order within tags
|
|
73
76
|
|
|
74
|
-
- `
|
|
77
|
+
- `ignore_attr_content: [string1, string2, ...]` default: **`[]`** [→ read more ←](#ignore_attr_content)
|
|
78
|
+
- when provided, ignores all attributes that contain substrings `string`, `string2`, etc.
|
|
79
|
+
|
|
80
|
+
- `ignore_attrs: [css_selector1, css_selector1, ...]` default: **`[]`** [→ read more ←](#ignore_attrs)
|
|
75
81
|
- when provided, ignores specific *attributes* using [CSS selectors](http://www.w3schools.com/cssref/css_selectors.asp)
|
|
76
82
|
|
|
77
|
-
- `ignore_comments: {true|false}` default: **`true`**
|
|
83
|
+
- `ignore_comments: {true|false}` default: **`true`** [...](#ignore_comments)
|
|
78
84
|
- when `true`, ignores comments, such as `<!-- comment -->`
|
|
79
85
|
|
|
80
|
-
- `ignore_nodes:
|
|
86
|
+
- `ignore_nodes: [css_selector1, css_selector1, ...]` default: **`[]`** [→ read more ←](#ignore_nodes)
|
|
81
87
|
- when provided, ignores specific *nodes* using [CSS selectors](http://www.w3schools.com/cssref/css_selectors.asp)
|
|
82
88
|
|
|
83
|
-
- `ignore_text_nodes: {true|false}` default: **`false`**
|
|
89
|
+
- `ignore_text_nodes: {true|false}` default: **`false`** [→ read more ←](#ignore_text_nodes)
|
|
84
90
|
- when `true`, ignores all text content within a document
|
|
85
91
|
|
|
86
|
-
- `
|
|
87
|
-
- when `true`, trims and collapses whitespace
|
|
88
|
-
|
|
89
|
-
- `verbose: {true|false}` default: **`false`**
|
|
92
|
+
- `verbose: {true|false}` default: **`false`** [→ read more ←](#verbose)
|
|
90
93
|
- when `true`, instead of a boolean, `CompareXML.equivalent?` returns an array of discrepancies.
|
|
91
94
|
|
|
92
95
|
|
|
93
96
|
## Options in Depth
|
|
94
97
|
|
|
95
|
-
-
|
|
98
|
+
- <a id="collapse_whitespace"></a>`collapse_whitespace: {true|false}` default: **`true`**
|
|
99
|
+
|
|
100
|
+
When `true`, all text content within the document is trimmed (i.e. space removed from left and right) and whitespace is collapsed (i.e. tabs, new lines, multiple whitespace characters are replaced by a single whitespace).
|
|
101
|
+
|
|
102
|
+
**Usage Example:** `CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: true})`
|
|
103
|
+
|
|
104
|
+
**Example:** When `true` the following HTML strings are considered equal:
|
|
105
|
+
|
|
106
|
+
<a href="/admin"> SOME TEXT CONTENT </a>
|
|
107
|
+
<a href="/index"> SOME TEXT CONTENT </a>
|
|
108
|
+
|
|
109
|
+
**Example:** When `true` the following HTML strings are considered equal:
|
|
110
|
+
|
|
111
|
+
<html>
|
|
112
|
+
<title>
|
|
113
|
+
This is my title
|
|
114
|
+
</title>
|
|
115
|
+
</html>
|
|
116
|
+
|
|
117
|
+
<html><title>This is my title</title></html>
|
|
118
|
+
|
|
119
|
+
|
|
120
|
+
----------
|
|
121
|
+
|
|
122
|
+
|
|
123
|
+
- <a id="ignore_attr_order"></a>`ignore_attr_order: {true|false}` default: **`true`**
|
|
96
124
|
|
|
97
125
|
When `true`, all attributes are sorted before comparison and only attributes of the same type are compared.
|
|
98
126
|
|
|
@@ -120,8 +148,30 @@ CompareXML.equivalent?(doc1, doc2, {ignore_comments: false, verbose: true, ...})
|
|
|
120
148
|
target="_blank" == target="_blank"
|
|
121
149
|
|
|
122
150
|
|
|
151
|
+
----------
|
|
152
|
+
|
|
153
|
+
|
|
154
|
+
- <a id="ignore_attr_content"></a>`ignore_attr_content: [string1, string2, ...]` default: **`[]`**
|
|
155
|
+
|
|
156
|
+
When provided, ignores all **attributes** that contain any of the given substrings. **Note:** types of attributes still have to match (i.e. `<p>` = `<p>`, `<div>` = `<div>`, etc).
|
|
157
|
+
|
|
158
|
+
**Usage Example:** `CompareXML.equivalent?(doc1, doc2, {ignore_attr_content: ['button']})`
|
|
159
|
+
|
|
160
|
+
**Example:** With `ignore_attr_content: ['button']` the following HTML strings are considered equal:
|
|
161
|
+
|
|
162
|
+
<a href="/admin" id="button_1" class="blue button">Link</a>
|
|
163
|
+
<a href="/admin" id="button_2" class="info button">Link</a>
|
|
164
|
+
|
|
165
|
+
**Example:** With `ignore_attr_content: ['menu']` the following HTML strings are considered equal:
|
|
123
166
|
|
|
124
|
-
|
|
167
|
+
<a class="menu left" data-scope="abrth$menu" role="side-menu">Link</a>
|
|
168
|
+
<a class="main menu" data-scope="ergeh$menu" role="main-menu">Link</a>
|
|
169
|
+
|
|
170
|
+
|
|
171
|
+
----------
|
|
172
|
+
|
|
173
|
+
|
|
174
|
+
- <a id="ignore_attrs"></a>`ignore_attrs: [css_selector1, css_selector1, ...]` default: **`[]`**
|
|
125
175
|
|
|
126
176
|
When provided, ignores all **attributes** that satisfy a particular rule using [CSS selectors](http://www.w3schools.com/cssref/css_selectors.asp).
|
|
127
177
|
|
|
@@ -138,8 +188,10 @@ CompareXML.equivalent?(doc1, doc2, {ignore_comments: false, verbose: true, ...})
|
|
|
138
188
|
<a href="https://google.com" class="primary button rounded">Link</a>
|
|
139
189
|
|
|
140
190
|
|
|
191
|
+
----------
|
|
192
|
+
|
|
141
193
|
|
|
142
|
-
-
|
|
194
|
+
- <a id="ignore_comments"></a>`ignore_comments: {true|false}` default: **`true`**
|
|
143
195
|
|
|
144
196
|
When `true`, ignores comments, such as `<!-- This is a comment -->`.
|
|
145
197
|
|
|
@@ -156,8 +208,10 @@ CompareXML.equivalent?(doc1, doc2, {ignore_comments: false, verbose: true, ...})
|
|
|
156
208
|
<a href="/admin">Link</a>
|
|
157
209
|
|
|
158
210
|
|
|
211
|
+
----------
|
|
159
212
|
|
|
160
|
-
|
|
213
|
+
|
|
214
|
+
- <a id="ignore_nodes"></a>`ignore_nodes: [css_selector1, css_selector1, ...]` default: **`[]`**
|
|
161
215
|
|
|
162
216
|
When provided, ignores all **nodes** that satisfy a particular rule using [CSS selectors](http://www.w3schools.com/cssref/css_selectors.asp).
|
|
163
217
|
|
|
@@ -174,8 +228,10 @@ CompareXML.equivalent?(doc1, doc2, {ignore_comments: false, verbose: true, ...})
|
|
|
174
228
|
<a href="/admin"><i class"icon info"></i><b>Message:</b> Link</a>
|
|
175
229
|
|
|
176
230
|
|
|
231
|
+
----------
|
|
232
|
+
|
|
177
233
|
|
|
178
|
-
-
|
|
234
|
+
- <a id="ignore_text_nodes"></a>`ignore_text_nodes: {true|false}` default: **`false`**
|
|
179
235
|
|
|
180
236
|
When `true`, ignores all text content. Text content is anything that is included between an opening and a closing tag, e.g. `<tag>THIS IS TEXT CONTENT</tag>`.
|
|
181
237
|
|
|
@@ -192,127 +248,68 @@ CompareXML.equivalent?(doc1, doc2, {ignore_comments: false, verbose: true, ...})
|
|
|
192
248
|
<i class="icon> </i> <b>Message:</b>
|
|
193
249
|
|
|
194
250
|
|
|
251
|
+
----------
|
|
195
252
|
|
|
196
|
-
- `collapse_whitespace: {true|false}` default: **`true`**
|
|
197
|
-
|
|
198
|
-
When `true`, all text content within the document is trimmed (i.e. space removed from left and right) and whitespace is collapsed (i.e. tabs, new lines, multiple whitespace characters are replaced by a single whitespace).
|
|
199
|
-
|
|
200
|
-
**Usage Example:** `CompareXML.equivalent?(doc1, doc2, {collapse_whitespace: true})`
|
|
201
253
|
|
|
202
|
-
|
|
203
|
-
|
|
204
|
-
<a href="/admin"> SOME TEXT CONTENT </a>
|
|
205
|
-
<a href="/index"> SOME TEXT CONTENT </a>
|
|
206
|
-
|
|
207
|
-
**Example:** When `true` the following HTML strings are considered equal:
|
|
208
|
-
|
|
209
|
-
<html>
|
|
210
|
-
<title>
|
|
211
|
-
This is my title
|
|
212
|
-
</title>
|
|
213
|
-
</html>
|
|
214
|
-
|
|
215
|
-
<html><title>This is my title</title></html>
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
219
|
-
- `verbose: {true|false}` default: **`false`**
|
|
254
|
+
- <a id="verbose"></a>`verbose: {true|false}` default: **`false`**
|
|
220
255
|
|
|
221
256
|
When `true`, instead of returning a boolean value `CompareXML.equivalent?` returns an array of all errors encountered when performing a comparison.
|
|
222
257
|
|
|
223
|
-
> **Warning:** When `true`, the comparison takes longer! Not only because more processing is required to produce meaningful
|
|
258
|
+
> **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.
|
|
224
259
|
|
|
225
260
|
**Usage Example:** `CompareXML.equivalent?(doc1, doc2, {verbose: true})`
|
|
226
261
|
|
|
227
262
|
**Example:** When `true` given the following HTML strings:
|
|
228
263
|
|
|
229
|
-
|
|
230
|
-
<html lang="en">
|
|
231
|
-
<head><title>TITLE</title></head>
|
|
232
|
-
<body>
|
|
233
|
-
<h1>SOME HEADING</h1>
|
|
234
|
-
<div id="content">
|
|
235
|
-
<h2><i class="fa fa-cogs"></i> ANOTHER HEADING</h2>
|
|
236
|
-
<p>Extra content</p>
|
|
237
|
-
</div>
|
|
238
|
-
<div class="window">
|
|
239
|
-
<a href="/admin" rel="icon">Link</a>
|
|
240
|
-
</div>
|
|
241
|
-
<blockquote>Some fancy quote <cite>Author Name</cite></blockquote>
|
|
242
|
-
<p>Some more text</p>
|
|
243
|
-
<p>Yet more text</p>
|
|
244
|
-
<p>Too much text</p>
|
|
245
|
-
<!-- The footer is below -->
|
|
246
|
-
<p class="footer">FOOTER</p>
|
|
247
|
-
</body>
|
|
248
|
-
</html>
|
|
249
|
-
|
|
250
|
-
<!DOCTYPE html>
|
|
251
|
-
<html lang="en">
|
|
252
|
-
<head><title>ANOTHER TITLE</title></head>
|
|
253
|
-
<body>
|
|
254
|
-
<h1 id="main">SOME HEADING</h1>
|
|
255
|
-
<div id="content">
|
|
256
|
-
<h2><i class="fa fa-cogs"></i> ANOTHER HEADING</h2>
|
|
257
|
-
<p>Extra content</p>
|
|
258
|
-
</div>
|
|
259
|
-
<div class="window">
|
|
260
|
-
<a rel="button" href="/admin">Link</a>
|
|
261
|
-
</div>
|
|
262
|
-
<blockquote>Some fancy quote</blockquote>
|
|
263
|
-
<p>Some more text</p>
|
|
264
|
-
<p>Yet more text</p>
|
|
265
|
-
<p>Too much text</p>
|
|
266
|
-
<!-- This is the footer -->
|
|
267
|
-
<div class="footer">FOOTER</div>
|
|
268
|
-
</body>
|
|
269
|
-
</html>
|
|
264
|
+
|
|
270
265
|
|
|
271
266
|
`CompareXML.equivalent?(doc1, doc2, {verbose: true})` will produce an array shown below.
|
|
272
267
|
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
"rel
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
[
|
|
268
|
+
```ruby
|
|
269
|
+
[
|
|
270
|
+
{
|
|
271
|
+
node1: '<title>TITLE</title>',
|
|
272
|
+
node2: '<title>ANOTHER TITLE</title>',
|
|
273
|
+
diff1: 'TITLE',
|
|
274
|
+
diff2: 'ANOTHER TITLE',
|
|
275
|
+
},
|
|
276
|
+
{
|
|
277
|
+
node1: '<h1>SOME HEADING</h1>',
|
|
278
|
+
node2: '<h1 id="main">SOME HEADING</h1>',
|
|
279
|
+
diff1: nil,
|
|
280
|
+
diff2: 'id="main"',
|
|
281
|
+
},
|
|
282
|
+
{
|
|
283
|
+
node1: '<a href="/admin" rel="icon">Link</a>',
|
|
284
|
+
node2: '<a rel="button" href="/admin">Link</a>',
|
|
285
|
+
diff1: '"rel="icon"',
|
|
286
|
+
diff2: '"rel="button"',
|
|
287
|
+
},
|
|
288
|
+
{
|
|
289
|
+
node1: '<cite>Author Name</cite>',
|
|
290
|
+
node2: nil,
|
|
291
|
+
diff1: '<cite>Author Name</cite>',
|
|
292
|
+
diff2: nil,
|
|
293
|
+
},
|
|
294
|
+
{
|
|
295
|
+
node1: '<p class="footer">FOOTER</p>',
|
|
296
|
+
node1: '<div class="footer">FOOTER</div>',
|
|
297
|
+
diff1: 'p',
|
|
298
|
+
diff2: 'div',
|
|
299
|
+
}
|
|
300
|
+
]
|
|
301
|
+
```
|
|
302
|
+
|
|
303
|
+
The structure of each hash inside the array is:
|
|
304
|
+
|
|
305
|
+
node1: [Nokogiri::XML::Node] left node that contains the difference
|
|
306
|
+
node2: [Nokogiri::XML::Node] right node that contains the difference
|
|
307
|
+
diff1: [Nokogiri::XML::Node|String] left difference
|
|
308
|
+
diff1: [Nokogiri::XML::Node|String] right difference
|
|
312
309
|
|
|
313
310
|
**Node location** of `html:body:p(4)` means that the element in question is `<p>`, its hierarchical ancestors are `html > body`, and it is the **4th** `<p>` tag. That is, it could be found in
|
|
314
311
|
|
|
315
|
-
<html><body><p>one</p
|
|
312
|
+
<html><body><p>one</p...p>two</p...p>three</p...p>TARGET</p></body></html>
|
|
316
313
|
|
|
317
314
|
> **Note:** `p(4)` means that it is the fourth tag of type `<p>`, but there could be many other tags of other types between `p(3)` and `p(4)`.
|
|
318
315
|
|
data/lib/compare-xml.rb
CHANGED
|
@@ -5,67 +5,71 @@ module CompareXML
|
|
|
5
5
|
|
|
6
6
|
# default options used by the module; all of these can be overridden
|
|
7
7
|
DEFAULTS_OPTS = {
|
|
8
|
+
# when true, trims and collapses whitespace in text nodes and comments to a single space
|
|
9
|
+
# when false, all whitespace is preserved as it is without any changes
|
|
10
|
+
collapse_whitespace: true,
|
|
11
|
+
|
|
8
12
|
# when true, attribute order is not important (all attributes are sorted before comparison)
|
|
9
13
|
# when false, attributes are compared in order and comparison stops on the first mismatch
|
|
10
14
|
ignore_attr_order: true,
|
|
11
15
|
|
|
16
|
+
# contains an array of user specified strings that is used to ignore any attributes
|
|
17
|
+
# whose content contains a string from this array (e.g. "good automobile" contains "mobile")
|
|
18
|
+
ignore_attr_content: [],
|
|
19
|
+
|
|
12
20
|
# contains an array of user-specified CSS rules used to perform attribute exclusions
|
|
13
21
|
# for this to work, a CSS rule MUST contain the attribute to be excluded,
|
|
14
22
|
# i.e. a[href] will exclude all "href" attributes contained in <a> tags.
|
|
15
|
-
ignore_attrs:
|
|
23
|
+
ignore_attrs: [],
|
|
16
24
|
|
|
17
25
|
# when true ignores XML and HTML comments
|
|
18
26
|
# when false, all comments are compared to their counterparts
|
|
19
27
|
ignore_comments: true,
|
|
20
28
|
|
|
21
29
|
# contains an array of user-specified CSS rules used to perform node exclusions
|
|
22
|
-
ignore_nodes:
|
|
30
|
+
ignore_nodes: [],
|
|
23
31
|
|
|
24
32
|
# when true, ignores all text nodes (although blank text nodes are always ignored)
|
|
25
33
|
# when false, all text nodes are compared to their counterparts (except the empty ones)
|
|
26
34
|
ignore_text_nodes: false,
|
|
27
35
|
|
|
28
|
-
# when true, trims and collapses whitespace in text nodes and comments to a single space
|
|
29
|
-
# when false, all whitespace is preserved as it is without any changes
|
|
30
|
-
collapse_whitespace: true,
|
|
31
|
-
|
|
32
36
|
# when true, provides a list of all error messages encountered in comparisons
|
|
33
37
|
# when false, execution stops when the first error is encountered with no error messages
|
|
34
38
|
verbose: false
|
|
35
39
|
}
|
|
36
40
|
|
|
37
|
-
# used internally only in order to differentiate equivalence for inequivalence
|
|
38
|
-
EQUIVALENT = 1
|
|
39
41
|
|
|
40
|
-
|
|
41
|
-
# these are returned in the errors array to differentiate error types.
|
|
42
|
-
MISSING_ATTRIBUTE = 2 # attribute is missing its counterpart
|
|
43
|
-
MISSING_NODE = 3 # node is missing its counterpart
|
|
44
|
-
UNEQUAL_ATTRIBUTES = 4 # attributes are not equal
|
|
45
|
-
UNEQUAL_COMMENTS = 5 # comment contents are not equal
|
|
46
|
-
UNEQUAL_DOCUMENTS = 6 # document types are not equal
|
|
47
|
-
UNEQUAL_ELEMENTS = 7 # nodes have the same type but are not equal
|
|
48
|
-
UNEQUAL_NODES_TYPES = 8 # nodes do not have the same type
|
|
49
|
-
UNEQUAL_TEXT_CONTENTS = 9 # text contents are not equal
|
|
42
|
+
class << self
|
|
50
43
|
|
|
44
|
+
# used internally only in order to differentiate equivalence for inequivalence
|
|
45
|
+
EQUIVALENT = 1
|
|
51
46
|
|
|
52
|
-
|
|
47
|
+
# a list of all possible inequivalence types for nodes
|
|
48
|
+
# these are returned in the differences array to differentiate error types.
|
|
49
|
+
MISSING_ATTRIBUTE = 2 # attribute is missing its counterpart
|
|
50
|
+
MISSING_NODE = 3 # node is missing its counterpart
|
|
51
|
+
UNEQUAL_ATTRIBUTES = 4 # attributes are not equal
|
|
52
|
+
UNEQUAL_COMMENTS = 5 # comment contents are not equal
|
|
53
|
+
UNEQUAL_DOCUMENTS = 6 # document types are not equal
|
|
54
|
+
UNEQUAL_ELEMENTS = 7 # nodes have the same type but are not equal
|
|
55
|
+
UNEQUAL_NODES_TYPES = 8 # nodes do not have the same type
|
|
56
|
+
UNEQUAL_TEXT_CONTENTS = 9 # text node contents are not equal
|
|
53
57
|
|
|
54
58
|
##
|
|
55
59
|
# Determines whether two XML documents or fragments are equal to each other.
|
|
56
60
|
# The two parameters could be any type of XML documents, or fragments
|
|
57
61
|
# or node sets or even text nodes - any subclass of Nokogiri::XML::Node.
|
|
58
62
|
#
|
|
59
|
-
# @param [Nokogiri::XML::
|
|
60
|
-
# @param [Nokogiri::XML::
|
|
63
|
+
# @param [Nokogiri::XML::Element] n1 left node element
|
|
64
|
+
# @param [Nokogiri::XML::Element] n2 right node element
|
|
61
65
|
# @param [Hash] opts user-overridden options
|
|
62
66
|
#
|
|
63
|
-
# @return true if equal, [Array]
|
|
67
|
+
# @return true if equal, [Array] differences otherwise
|
|
64
68
|
#
|
|
65
69
|
def equivalent?(n1, n2, opts = {})
|
|
66
|
-
opts,
|
|
67
|
-
result = compareNodes(n1, n2, opts,
|
|
68
|
-
opts[:verbose] ?
|
|
70
|
+
opts, differences = DEFAULTS_OPTS.merge(opts), []
|
|
71
|
+
result = compareNodes(n1, n2, opts, differences)
|
|
72
|
+
opts[:verbose] ? differences : result == EQUIVALENT
|
|
69
73
|
end
|
|
70
74
|
|
|
71
75
|
|
|
@@ -75,36 +79,38 @@ module CompareXML
|
|
|
75
79
|
# Compares two nodes for equivalence. The nodes could be any subclass
|
|
76
80
|
# of Nokogiri::XML::Node including node sets and document fragments.
|
|
77
81
|
#
|
|
78
|
-
# @param [Nokogiri::XML::Node] n1 left
|
|
79
|
-
# @param [Nokogiri::XML::Node] n2 right
|
|
82
|
+
# @param [Nokogiri::XML::Node] n1 left node
|
|
83
|
+
# @param [Nokogiri::XML::Node] n2 right node
|
|
80
84
|
# @param [Hash] opts user-overridden options
|
|
81
|
-
# @param [Array]
|
|
85
|
+
# @param [Array] differences inequivalence messages
|
|
86
|
+
# @param [int] status comparison status code (EQUIVALENT by default)
|
|
82
87
|
#
|
|
83
88
|
# @return type of equivalence (from equivalence constants)
|
|
84
89
|
#
|
|
85
|
-
def compareNodes(n1, n2, opts,
|
|
90
|
+
def compareNodes(n1, n2, opts, differences, status = EQUIVALENT)
|
|
86
91
|
if n1.class == n2.class
|
|
87
92
|
case n1
|
|
88
93
|
when Nokogiri::XML::Comment
|
|
89
|
-
compareCommentNodes(n1, n2, opts,
|
|
94
|
+
compareCommentNodes(n1, n2, opts, differences)
|
|
90
95
|
when Nokogiri::HTML::Document
|
|
91
|
-
compareDocumentNodes(n1, n2, opts,
|
|
96
|
+
compareDocumentNodes(n1, n2, opts, differences)
|
|
92
97
|
when Nokogiri::XML::Element
|
|
93
|
-
status = compareElementNodes(n1, n2, opts,
|
|
98
|
+
status = compareElementNodes(n1, n2, opts, differences)
|
|
94
99
|
when Nokogiri::XML::Text
|
|
95
|
-
status = compareTextNodes(n1, n2, opts,
|
|
100
|
+
status = compareTextNodes(n1, n2, opts, differences)
|
|
96
101
|
else
|
|
97
|
-
|
|
102
|
+
if n1.is_a?(Nokogiri::XML::Node) || n1.is_a?(Nokogiri::XML::NodeSet)
|
|
103
|
+
status = compareChildren(n1.children, n2.children, opts, differences)
|
|
104
|
+
else
|
|
105
|
+
raise 'Comparison only allowed between objects of type Nokogiri::XML::Node and Nokogiri::XML::NodeSet.'
|
|
106
|
+
end
|
|
98
107
|
end
|
|
99
|
-
elsif n1.nil?
|
|
100
|
-
status = MISSING_NODE
|
|
101
|
-
errors << [nodePath(n2), nil, status, n2.name, nodePath(n2)] if opts[:verbose]
|
|
102
|
-
elsif n2.nil?
|
|
108
|
+
elsif n1.nil? || n2.nil?
|
|
103
109
|
status = MISSING_NODE
|
|
104
|
-
|
|
110
|
+
addDifference(n1, n2, n1, n2, opts, differences)
|
|
105
111
|
else
|
|
106
112
|
status = UNEQUAL_NODES_TYPES
|
|
107
|
-
|
|
113
|
+
addDifference(n1, n2, n1, n2, opts, differences)
|
|
108
114
|
end
|
|
109
115
|
status
|
|
110
116
|
end
|
|
@@ -113,20 +119,21 @@ module CompareXML
|
|
|
113
119
|
##
|
|
114
120
|
# Compares two nodes of type Nokogiri::HTML::Comment.
|
|
115
121
|
#
|
|
116
|
-
# @param [Nokogiri::XML::Comment] n1 left
|
|
117
|
-
# @param [Nokogiri::XML::Comment] n2 right
|
|
122
|
+
# @param [Nokogiri::XML::Comment] n1 left comment
|
|
123
|
+
# @param [Nokogiri::XML::Comment] n2 right comment
|
|
118
124
|
# @param [Hash] opts user-overridden options
|
|
119
|
-
# @param [Array]
|
|
125
|
+
# @param [Array] differences inequivalence messages
|
|
126
|
+
# @param [int] status comparison status code (EQUIVALENT by default)
|
|
120
127
|
#
|
|
121
128
|
# @return type of equivalence (from equivalence constants)
|
|
122
129
|
#
|
|
123
|
-
def compareCommentNodes(n1, n2, opts,
|
|
130
|
+
def compareCommentNodes(n1, n2, opts, differences, status = EQUIVALENT)
|
|
124
131
|
return true if opts[:ignore_comments]
|
|
125
132
|
t1, t2 = n1.content, n2.content
|
|
126
133
|
t1, t2 = collapse(t1), collapse(t2) if opts[:collapse_whitespace]
|
|
127
134
|
unless t1 == t2
|
|
128
135
|
status = UNEQUAL_COMMENTS
|
|
129
|
-
|
|
136
|
+
addDifference(n1, n2, t1, t2, opts, differences)
|
|
130
137
|
end
|
|
131
138
|
status
|
|
132
139
|
end
|
|
@@ -135,19 +142,20 @@ module CompareXML
|
|
|
135
142
|
##
|
|
136
143
|
# Compares two nodes of type Nokogiri::HTML::Document.
|
|
137
144
|
#
|
|
138
|
-
# @param [Nokogiri::XML::Document] n1 left
|
|
139
|
-
# @param [Nokogiri::XML::Document] n2 right
|
|
145
|
+
# @param [Nokogiri::XML::Document] n1 left document
|
|
146
|
+
# @param [Nokogiri::XML::Document] n2 right document
|
|
140
147
|
# @param [Hash] opts user-overridden options
|
|
141
|
-
# @param [Array]
|
|
148
|
+
# @param [Array] differences inequivalence messages
|
|
149
|
+
# @param [int] status comparison status code (EQUIVALENT by default)
|
|
142
150
|
#
|
|
143
151
|
# @return type of equivalence (from equivalence constants)
|
|
144
152
|
#
|
|
145
|
-
def compareDocumentNodes(n1, n2, opts,
|
|
153
|
+
def compareDocumentNodes(n1, n2, opts, differences, status = EQUIVALENT)
|
|
146
154
|
if n1.name == n2.name
|
|
147
|
-
status = compareChildren(n1.children, n2.children, opts,
|
|
155
|
+
status = compareChildren(n1.children, n2.children, opts, differences)
|
|
148
156
|
else
|
|
149
157
|
status == UNEQUAL_DOCUMENTS
|
|
150
|
-
|
|
158
|
+
addDifference(n1, n2, n1, n2, opts, differences)
|
|
151
159
|
end
|
|
152
160
|
status
|
|
153
161
|
end
|
|
@@ -159,11 +167,12 @@ module CompareXML
|
|
|
159
167
|
# @param [Nokogiri::XML::NodeSet] n1_set left set of Nokogiri::XML::Node elements
|
|
160
168
|
# @param [Nokogiri::XML::NodeSet] n2_set right set of Nokogiri::XML::Node elements
|
|
161
169
|
# @param [Hash] opts user-overridden options
|
|
162
|
-
# @param [Array]
|
|
170
|
+
# @param [Array] differences inequivalence messages
|
|
171
|
+
# @param [int] status comparison status code (EQUIVALENT by default)
|
|
163
172
|
#
|
|
164
173
|
# @return type of equivalence (from equivalence constants)
|
|
165
174
|
#
|
|
166
|
-
def compareChildren(n1_set, n2_set, opts,
|
|
175
|
+
def compareChildren(n1_set, n2_set, opts, differences, status = EQUIVALENT)
|
|
167
176
|
i = 0; j = 0
|
|
168
177
|
while i < n1_set.length || j < n2_set.length
|
|
169
178
|
if !n1_set[i].nil? && nodeExcluded?(n1_set[i], opts)
|
|
@@ -171,7 +180,7 @@ module CompareXML
|
|
|
171
180
|
elsif !n2_set[j].nil? && nodeExcluded?(n2_set[j], opts)
|
|
172
181
|
j += 1 # increment counter if right node is excluded
|
|
173
182
|
else
|
|
174
|
-
result = compareNodes(n1_set[i], n2_set[j], opts,
|
|
183
|
+
result = compareNodes(n1_set[i], n2_set[j], opts, differences)
|
|
175
184
|
status = result unless result == EQUIVALENT
|
|
176
185
|
|
|
177
186
|
# return false so that this subtree could halt comparison on error
|
|
@@ -194,22 +203,23 @@ module CompareXML
|
|
|
194
203
|
# - compares element attributes
|
|
195
204
|
# - recursively compares element children
|
|
196
205
|
#
|
|
197
|
-
# @param [Nokogiri::XML::Element] n1 left
|
|
198
|
-
# @param [Nokogiri::XML::Element] n2 right
|
|
206
|
+
# @param [Nokogiri::XML::Element] n1 left node element
|
|
207
|
+
# @param [Nokogiri::XML::Element] n2 right node element
|
|
199
208
|
# @param [Hash] opts user-overridden options
|
|
200
|
-
# @param [Array]
|
|
209
|
+
# @param [Array] differences inequivalence messages
|
|
210
|
+
# @param [int] status comparison status code (EQUIVALENT by default)
|
|
201
211
|
#
|
|
202
212
|
# @return type of equivalence (from equivalence constants)
|
|
203
213
|
#
|
|
204
|
-
def compareElementNodes(n1, n2, opts,
|
|
214
|
+
def compareElementNodes(n1, n2, opts, differences, status = EQUIVALENT)
|
|
205
215
|
if n1.name == n2.name
|
|
206
|
-
result = compareAttributeSets(n1.attribute_nodes, n2.attribute_nodes, opts,
|
|
207
|
-
|
|
208
|
-
result = compareChildren(n1.children, n2.children, opts,
|
|
216
|
+
result = compareAttributeSets(n1, n2, n1.attribute_nodes, n2.attribute_nodes, opts, differences)
|
|
217
|
+
return result unless result == EQUIVALENT
|
|
218
|
+
result = compareChildren(n1.children, n2.children, opts, differences)
|
|
209
219
|
status = result unless result == EQUIVALENT
|
|
210
220
|
else
|
|
211
221
|
status = UNEQUAL_ELEMENTS
|
|
212
|
-
|
|
222
|
+
addDifference(n1, n2, n1.name, n2.name, opts, differences)
|
|
213
223
|
end
|
|
214
224
|
status
|
|
215
225
|
end
|
|
@@ -218,41 +228,44 @@ module CompareXML
|
|
|
218
228
|
##
|
|
219
229
|
# Compares two nodes of type Nokogiri::XML::Text.
|
|
220
230
|
#
|
|
221
|
-
# @param [Nokogiri::XML::Text] n1 left
|
|
222
|
-
# @param [Nokogiri::XML::Text] n2 right
|
|
231
|
+
# @param [Nokogiri::XML::Text] n1 left text node
|
|
232
|
+
# @param [Nokogiri::XML::Text] n2 right text node
|
|
223
233
|
# @param [Hash] opts user-overridden options
|
|
224
|
-
# @param [Array]
|
|
234
|
+
# @param [Array] differences inequivalence messages
|
|
235
|
+
# @param [int] status comparison status code (EQUIVALENT by default)
|
|
225
236
|
#
|
|
226
237
|
# @return type of equivalence (from equivalence constants)
|
|
227
238
|
#
|
|
228
|
-
def compareTextNodes(n1, n2, opts,
|
|
239
|
+
def compareTextNodes(n1, n2, opts, differences, status = EQUIVALENT)
|
|
229
240
|
return true if opts[:ignore_text_nodes]
|
|
230
241
|
t1, t2 = n1.content, n2.content
|
|
231
242
|
t1, t2 = collapse(t1), collapse(t2) if opts[:collapse_whitespace]
|
|
232
243
|
unless t1 == t2
|
|
233
244
|
status = UNEQUAL_TEXT_CONTENTS
|
|
234
|
-
|
|
245
|
+
addDifference(n1.parent, n2.parent, t1, t2, opts, differences)
|
|
235
246
|
end
|
|
236
247
|
status
|
|
237
248
|
end
|
|
238
249
|
|
|
239
250
|
|
|
240
251
|
##
|
|
241
|
-
# Compares two sets of Nokogiri::XML::
|
|
252
|
+
# Compares two sets of Nokogiri::XML::Element attributes.
|
|
242
253
|
#
|
|
254
|
+
# @param [Nokogiri::XML::Element] n1 left node element
|
|
255
|
+
# @param [Nokogiri::XML::Element] n2 right node element
|
|
243
256
|
# @param [Array] a1_set left attribute set
|
|
244
257
|
# @param [Array] a2_set right attribute set
|
|
245
258
|
# @param [Hash] opts user-overridden options
|
|
246
|
-
# @param [Array]
|
|
259
|
+
# @param [Array] differences inequivalence messages
|
|
247
260
|
#
|
|
248
261
|
# @return type of equivalence (from equivalence constants)
|
|
249
262
|
#
|
|
250
|
-
def compareAttributeSets(a1_set, a2_set, opts,
|
|
263
|
+
def compareAttributeSets(n1, n2, a1_set, a2_set, opts, differences)
|
|
251
264
|
return false unless a1_set.length == a2_set.length || opts[:verbose]
|
|
252
265
|
if opts[:ignore_attr_order]
|
|
253
|
-
compareSortedAttributeSets(a1_set, a2_set, opts,
|
|
266
|
+
compareSortedAttributeSets(n1, n2, a1_set, a2_set, opts, differences)
|
|
254
267
|
else
|
|
255
|
-
compareUnsortedAttributeSets(a1_set, a2_set, opts,
|
|
268
|
+
compareUnsortedAttributeSets(n1, n2, a1_set, a2_set, opts, differences)
|
|
256
269
|
end
|
|
257
270
|
end
|
|
258
271
|
|
|
@@ -262,29 +275,34 @@ module CompareXML
|
|
|
262
275
|
# When the attributes are sorted, only attributes of the same type are compared
|
|
263
276
|
# to each other, and missing attributes can be easily detected.
|
|
264
277
|
#
|
|
278
|
+
# @param [Nokogiri::XML::Element] n1 left node element
|
|
279
|
+
# @param [Nokogiri::XML::Element] n2 right node element
|
|
265
280
|
# @param [Array] a1_set left attribute set
|
|
266
281
|
# @param [Array] a2_set right attribute set
|
|
267
282
|
# @param [Hash] opts user-overridden options
|
|
268
|
-
# @param [Array]
|
|
283
|
+
# @param [Array] differences inequivalence messages
|
|
284
|
+
# @param [int] status comparison status code (EQUIVALENT by default)
|
|
269
285
|
#
|
|
270
286
|
# @return type of equivalence (from equivalence constants)
|
|
271
287
|
#
|
|
272
|
-
def compareSortedAttributeSets(a1_set, a2_set, opts,
|
|
288
|
+
def compareSortedAttributeSets(n1, n2, a1_set, a2_set, opts, differences, status = EQUIVALENT)
|
|
273
289
|
a1_set, a2_set = a1_set.sort_by { |a| a.name }, a2_set.sort_by { |a| a.name }
|
|
274
290
|
i = j = 0
|
|
275
291
|
|
|
276
292
|
while i < a1_set.length || j < a2_set.length
|
|
293
|
+
|
|
277
294
|
if a1_set[i].nil?
|
|
278
|
-
result = compareAttributes(nil, a2_set[j], opts,
|
|
295
|
+
result = compareAttributes(n1, n2, nil, a2_set[j], opts, differences); j += 1
|
|
279
296
|
elsif a2_set[j].nil?
|
|
280
|
-
result = compareAttributes(a1_set[i], nil, opts,
|
|
297
|
+
result = compareAttributes(n1, n2, a1_set[i], nil, opts, differences); i += 1
|
|
281
298
|
elsif a1_set[i].name < a2_set[j].name
|
|
282
|
-
result = compareAttributes(a1_set[i], nil, opts,
|
|
299
|
+
result = compareAttributes(n1, n2, a1_set[i], nil, opts, differences); i += 1
|
|
283
300
|
elsif a1_set[i].name > a2_set[j].name
|
|
284
|
-
result = compareAttributes(nil, a2_set[j], opts,
|
|
301
|
+
result = compareAttributes(n1, n2, nil, a2_set[j], opts, differences); j += 1
|
|
285
302
|
else
|
|
286
|
-
result = compareAttributes(a1_set[i], a2_set[j], opts,
|
|
303
|
+
result = compareAttributes(n1, n2, a1_set[i], a2_set[j], opts, differences); i += 1; j += 1
|
|
287
304
|
end
|
|
305
|
+
|
|
288
306
|
status = result unless result == EQUIVALENT
|
|
289
307
|
break unless status == EQUIVALENT || opts[:verbose]
|
|
290
308
|
end
|
|
@@ -293,21 +311,24 @@ module CompareXML
|
|
|
293
311
|
|
|
294
312
|
|
|
295
313
|
##
|
|
296
|
-
# Compares two sets of Nokogiri::XML::
|
|
314
|
+
# Compares two sets of Nokogiri::XML::Element attributes without sorting them.
|
|
297
315
|
# As a result attributes of different types may be compared, and even if all
|
|
298
316
|
# attributes are identical in both sets, if their order is different,
|
|
299
317
|
# the comparison will stop as soon two unequal attributes are found.
|
|
300
318
|
#
|
|
319
|
+
# @param [Nokogiri::XML::Element] n1 left node element
|
|
320
|
+
# @param [Nokogiri::XML::Element] n2 right node element
|
|
301
321
|
# @param [Array] a1_set left attribute set
|
|
302
322
|
# @param [Array] a2_set right attribute set
|
|
303
323
|
# @param [Hash] opts user-overridden options
|
|
304
|
-
# @param [Array]
|
|
324
|
+
# @param [Array] differences inequivalence messages
|
|
325
|
+
# @param [int] status comparison status code (EQUIVALENT by default)
|
|
305
326
|
#
|
|
306
327
|
# @return type of equivalence (from equivalence constants)
|
|
307
328
|
#
|
|
308
|
-
def compareUnsortedAttributeSets(a1_set, a2_set, opts,
|
|
329
|
+
def compareUnsortedAttributeSets(n1, n2, a1_set, a2_set, opts, differences, status = EQUIVALENT)
|
|
309
330
|
[a1_set.length, a2_set.length].max.times do |i|
|
|
310
|
-
result = compareAttributes(a1_set[i], a2_set[i], opts,
|
|
331
|
+
result = compareAttributes(n1, n2, a1_set[i], a2_set[i], opts, differences)
|
|
311
332
|
status = result unless result == EQUIVALENT
|
|
312
333
|
break unless status == EQUIVALENT
|
|
313
334
|
end
|
|
@@ -318,29 +339,33 @@ module CompareXML
|
|
|
318
339
|
##
|
|
319
340
|
# Compares two attributes by name and value.
|
|
320
341
|
#
|
|
342
|
+
# @param [Nokogiri::XML::Element] n1 left node element
|
|
343
|
+
# @param [Nokogiri::XML::Element] n2 right node element
|
|
321
344
|
# @param [Nokogiri::XML::Attr] a1 left attribute
|
|
322
345
|
# @param [Nokogiri::XML::Attr] a2 right attribute
|
|
323
346
|
# @param [Hash] opts user-overridden options
|
|
324
|
-
# @param [Array]
|
|
347
|
+
# @param [Array] differences inequivalence messages
|
|
348
|
+
# @param [int] status comparison status code (EQUIVALENT by default)
|
|
325
349
|
#
|
|
326
350
|
# @return type of equivalence (from equivalence constants)
|
|
327
351
|
#
|
|
328
|
-
def compareAttributes(a1, a2, opts,
|
|
352
|
+
def compareAttributes(n1, n2, a1, a2, opts, differences, status = EQUIVALENT)
|
|
329
353
|
if a1.nil?
|
|
330
354
|
status = MISSING_ATTRIBUTE
|
|
331
|
-
|
|
355
|
+
addDifference(n1, n2, nil, "#{a2.name}=\"#{a2.value}\"", opts, differences)
|
|
332
356
|
elsif a2.nil?
|
|
333
357
|
status = MISSING_ATTRIBUTE
|
|
334
|
-
|
|
358
|
+
addDifference(n1, n2, "#{a1.name}=\"#{a1.value}\"", nil, opts, differences)
|
|
335
359
|
elsif a1.name == a2.name
|
|
336
360
|
return status if attrsExcluded?(a1, a2, opts)
|
|
361
|
+
return status if attrContentExcluded?(a1, a2, opts)
|
|
337
362
|
if a1.value != a2.value
|
|
338
363
|
status = UNEQUAL_ATTRIBUTES
|
|
339
|
-
|
|
364
|
+
addDifference(n1, n2, "#{a1.name}=\"#{a1.value}\"", "#{a2.name}=\"#{a2.value}\"", opts, differences)
|
|
340
365
|
end
|
|
341
366
|
else
|
|
342
367
|
status = UNEQUAL_ATTRIBUTES
|
|
343
|
-
|
|
368
|
+
addDifference(n1, n2, "#{a1.name}=\"#{a1.value}\"", "#{a2.name}=\"#{a2.value}\"", opts, differences)
|
|
344
369
|
end
|
|
345
370
|
status
|
|
346
371
|
end
|
|
@@ -353,7 +378,7 @@ module CompareXML
|
|
|
353
378
|
# Several types of nodes are considered ignored:
|
|
354
379
|
# - comments (only in +ignore_comments+ mode)
|
|
355
380
|
# - text nodes (only in +ignore_text_nodes+ mode OR when a text node is empty)
|
|
356
|
-
# - node matches a user-specified css rule from +
|
|
381
|
+
# - node matches a user-specified css rule from +ignore_nodes+
|
|
357
382
|
#
|
|
358
383
|
# @param [Nokogiri::XML::Node] n node being tested for exclusion
|
|
359
384
|
# @param [Hash] opts user-overridden options
|
|
@@ -361,11 +386,10 @@ module CompareXML
|
|
|
361
386
|
# @return true if excluded, false otherwise
|
|
362
387
|
#
|
|
363
388
|
def nodeExcluded?(n, opts)
|
|
389
|
+
return true if n.is_a?(Nokogiri::XML::DTD)
|
|
364
390
|
return true if n.is_a?(Nokogiri::XML::Comment) && opts[:ignore_comments]
|
|
365
391
|
return true if n.is_a?(Nokogiri::XML::Text) && (opts[:ignore_text_nodes] || collapse(n.content).empty?)
|
|
366
|
-
opts[:ignore_nodes].each
|
|
367
|
-
return true if n.xpath('../*').css(css).include?(n)
|
|
368
|
-
end
|
|
392
|
+
opts[:ignore_nodes].each { |css| return true if n.parent.css(css).include? n }
|
|
369
393
|
false
|
|
370
394
|
end
|
|
371
395
|
|
|
@@ -393,43 +417,43 @@ module CompareXML
|
|
|
393
417
|
|
|
394
418
|
|
|
395
419
|
##
|
|
396
|
-
#
|
|
397
|
-
#
|
|
398
|
-
#
|
|
399
|
-
#
|
|
400
|
-
#
|
|
401
|
-
#
|
|
402
|
-
#
|
|
403
|
-
# <div>
|
|
404
|
-
# <h2>
|
|
405
|
-
# <b>...</b>
|
|
406
|
-
# <b>TARGET</b>
|
|
407
|
-
# </h2>
|
|
408
|
-
# </div>
|
|
409
|
-
# </body>
|
|
410
|
-
# </html>
|
|
411
|
-
#
|
|
412
|
-
# Note that the counts of element locations only apply to elements of the same type. For example, div(3) means
|
|
413
|
-
# that it is the 3rd <div> element in the <body>, but there could be many other elements in between the three
|
|
414
|
-
# <div> elements.
|
|
415
|
-
#
|
|
416
|
-
# When +ignore_comments+ mode is disabled, mismatching comments will show up as <...:comment>.
|
|
417
|
-
#
|
|
418
|
-
# @param [Nokogiri::XML::Node] n node for which to determine a hierarchical path
|
|
420
|
+
# Checks whether two given attributes should be excluded, based on their content.
|
|
421
|
+
# Checks whether both attributes contain content that should be excluded, and
|
|
422
|
+
# returns true only if an excluded string is contained in both attribute values.
|
|
423
|
+
#
|
|
424
|
+
# @param [Nokogiri::XML::Attr] a1 left attribute
|
|
425
|
+
# @param [Nokogiri::XML::Attr] a2 right attribute
|
|
426
|
+
# @param [Hash] opts user-overridden options
|
|
419
427
|
#
|
|
420
428
|
# @return true if excluded, false otherwise
|
|
421
429
|
#
|
|
422
|
-
def
|
|
423
|
-
|
|
430
|
+
def attrContentExcluded?(a1, a2, opts)
|
|
431
|
+
a1_excluded, a2_excluded = false, false
|
|
432
|
+
opts[:ignore_attr_content].each do |content|
|
|
433
|
+
a1_excluded = a1_excluded || a1.value.include?(content)
|
|
434
|
+
a2_excluded = a2_excluded || a2.value.include?(content)
|
|
435
|
+
return true if a1_excluded && a2_excluded
|
|
436
|
+
end
|
|
437
|
+
false
|
|
438
|
+
end
|
|
424
439
|
|
|
425
|
-
# find the index of the node if there are several of the same type
|
|
426
|
-
siblings = n.xpath("../#{name}")
|
|
427
|
-
name += "(#{siblings.index(n) + 1})" if siblings.length > 1
|
|
428
440
|
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
441
|
+
##
|
|
442
|
+
# Strips the whitespace (from beginning and end) and collapses it,
|
|
443
|
+
# i.e. multiple spaces, new lines and tabs are all collapsed to a single space.
|
|
444
|
+
#
|
|
445
|
+
# @param [Nokogiri::XML::Node] node1 left node
|
|
446
|
+
# @param [Nokogiri::XML::Node] node2 right node
|
|
447
|
+
# @param [String] diff1 left diffing value
|
|
448
|
+
# @param [String] diff2 right diffing value
|
|
449
|
+
# @param [Hash] opts user-overridden options
|
|
450
|
+
# @param [Array] differences inequivalence messages
|
|
451
|
+
#
|
|
452
|
+
# @return collapsed string
|
|
453
|
+
#
|
|
454
|
+
def addDifference(node1, node2, diff1, diff2, opts, differences)
|
|
455
|
+
if opts[:verbose]
|
|
456
|
+
differences << {node1: node1, node2: node2, diff1: diff1, diff2: diff2}
|
|
433
457
|
end
|
|
434
458
|
end
|
|
435
459
|
|
data/lib/compare-xml/version.rb
CHANGED
metadata
CHANGED
|
@@ -1,55 +1,55 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: compare-xml
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 0.
|
|
4
|
+
version: '0.6'
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Vadim Kononov
|
|
8
8
|
autorequire:
|
|
9
9
|
bindir: exe
|
|
10
10
|
cert_chain: []
|
|
11
|
-
date: 2016-04-
|
|
11
|
+
date: 2016-04-29 00:00:00.000000000 Z
|
|
12
12
|
dependencies:
|
|
13
13
|
- !ruby/object:Gem::Dependency
|
|
14
14
|
name: bundler
|
|
15
15
|
requirement: !ruby/object:Gem::Requirement
|
|
16
16
|
requirements:
|
|
17
|
-
- - ~>
|
|
17
|
+
- - "~>"
|
|
18
18
|
- !ruby/object:Gem::Version
|
|
19
19
|
version: '1.11'
|
|
20
20
|
type: :development
|
|
21
21
|
prerelease: false
|
|
22
22
|
version_requirements: !ruby/object:Gem::Requirement
|
|
23
23
|
requirements:
|
|
24
|
-
- - ~>
|
|
24
|
+
- - "~>"
|
|
25
25
|
- !ruby/object:Gem::Version
|
|
26
26
|
version: '1.11'
|
|
27
27
|
- !ruby/object:Gem::Dependency
|
|
28
28
|
name: rake
|
|
29
29
|
requirement: !ruby/object:Gem::Requirement
|
|
30
30
|
requirements:
|
|
31
|
-
- - ~>
|
|
31
|
+
- - "~>"
|
|
32
32
|
- !ruby/object:Gem::Version
|
|
33
33
|
version: '11.1'
|
|
34
34
|
type: :development
|
|
35
35
|
prerelease: false
|
|
36
36
|
version_requirements: !ruby/object:Gem::Requirement
|
|
37
37
|
requirements:
|
|
38
|
-
- - ~>
|
|
38
|
+
- - "~>"
|
|
39
39
|
- !ruby/object:Gem::Version
|
|
40
40
|
version: '11.1'
|
|
41
41
|
- !ruby/object:Gem::Dependency
|
|
42
42
|
name: nokogiri
|
|
43
43
|
requirement: !ruby/object:Gem::Requirement
|
|
44
44
|
requirements:
|
|
45
|
-
- - ~>
|
|
45
|
+
- - "~>"
|
|
46
46
|
- !ruby/object:Gem::Version
|
|
47
47
|
version: '1.6'
|
|
48
48
|
type: :runtime
|
|
49
49
|
prerelease: false
|
|
50
50
|
version_requirements: !ruby/object:Gem::Requirement
|
|
51
51
|
requirements:
|
|
52
|
-
- - ~>
|
|
52
|
+
- - "~>"
|
|
53
53
|
- !ruby/object:Gem::Version
|
|
54
54
|
version: '1.6'
|
|
55
55
|
description: CompareXML is a fast, lightweight and feature-rich tool that will solve
|
|
@@ -61,7 +61,7 @@ executables: []
|
|
|
61
61
|
extensions: []
|
|
62
62
|
extra_rdoc_files: []
|
|
63
63
|
files:
|
|
64
|
-
- .gitignore
|
|
64
|
+
- ".gitignore"
|
|
65
65
|
- Gemfile
|
|
66
66
|
- LICENSE.txt
|
|
67
67
|
- README.md
|
|
@@ -81,17 +81,17 @@ require_paths:
|
|
|
81
81
|
- lib
|
|
82
82
|
required_ruby_version: !ruby/object:Gem::Requirement
|
|
83
83
|
requirements:
|
|
84
|
-
- -
|
|
84
|
+
- - ">="
|
|
85
85
|
- !ruby/object:Gem::Version
|
|
86
86
|
version: '0'
|
|
87
87
|
required_rubygems_version: !ruby/object:Gem::Requirement
|
|
88
88
|
requirements:
|
|
89
|
-
- -
|
|
89
|
+
- - ">="
|
|
90
90
|
- !ruby/object:Gem::Version
|
|
91
91
|
version: '0'
|
|
92
92
|
requirements: []
|
|
93
93
|
rubyforge_project:
|
|
94
|
-
rubygems_version: 2.
|
|
94
|
+
rubygems_version: 2.5.2
|
|
95
95
|
signing_key:
|
|
96
96
|
specification_version: 4
|
|
97
97
|
summary: A customizable tool that compares two instances of Nokogiri::XML::Node for
|