Class: Canon::Comparison::DiffNodeBuilder

Inherits:
Object
  • Object
show all
Defined in:
lib/canon/comparison/diff_node_builder.rb

Overview

Single factory for DiffNode creation in the DOM comparison path.

Centralises reason building, metadata enrichment (path, serialization, attributes), and whitespace visualization — previously duplicated across MarkupComparator and XmlComparator.

Class Method Summary collapse

Class Method Details

.build(node1:, node2:, diff1:, diff2:, dimension:, **_opts) ⇒ Object

Build an enriched DiffNode.

Raises:

  • (ArgumentError) 


14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 14

def self.build(node1:, node2:, diff1:, diff2:, dimension:, **_opts)
  raise ArgumentError, "dimension required for DiffNode" if dimension.nil?

  reason = build_reason(node1, node2, diff1, diff2, dimension)
  metadata = enrich_metadata(node1, node2)

  Canon::Diff::DiffNode.new(
    node1: node1,
    node2: node2,
    dimension: dimension,
    reason: reason,
    **metadata,
  )
end

.build_attribute_difference_reason(attrs1, attrs2) ⇒ Object

--- Attribute reason builders -----------------------------------------



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 96

def self.build_attribute_difference_reason(attrs1, attrs2)
  unless attrs1 && attrs2
    return "#{attrs1&.keys&.size || 0} vs #{attrs2&.keys&.size || 0} attributes"
  end

  keys1 = attrs1.keys.to_set
  keys2 = attrs2.keys.to_set

  only_in_first = keys1 - keys2
  only_in_second = keys2 - keys1
  different_values = (keys1 & keys2).reject { |k| attrs1[k] == attrs2[k] }

  parts = []
  parts << "only in first: #{only_in_first.to_a.sort.join(', ')}" if only_in_first.any?
  parts << "only in second: #{only_in_second.to_a.sort.join(', ')}" if only_in_second.any?
  parts << "different values: #{different_values.sort.join(', ')}" if different_values.any?

  parts.empty? ? "#{keys1.size} vs #{keys2.size} attributes (same names)" : parts.join("; ")
end

.build_attribute_order_reason(node1, node2) ⇒ Object 



131
132
133
134
135
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 131

def self.build_attribute_order_reason(node1, node2)
  keys1 = extract_attributes(node1)&.keys || []
  keys2 = extract_attributes(node2)&.keys || []
  "Attribute order changed: [#{keys1.join(', ')}] → [#{keys2.join(', ')}]"
end

.build_attribute_values_reason(node1, node2) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 116

def self.build_attribute_values_reason(node1, node2)
  attrs1 = extract_attributes(node1) || {}
  attrs2 = extract_attributes(node2) || {}

  differing = (attrs1.keys | attrs2.keys).sort.reject do |k|
    attrs1[k.to_s] == attrs2[k.to_s]
  end

  changed = differing.map do |k|
    "Changed: #{k}=\"#{attrs1[k.to_s]}\" → \"#{attrs2[k.to_s]}\""
  end

  changed.empty? ? "attributes differ" : "Attributes differ (#{changed.join('; ')})"
end

.build_comment_difference_reason(node1, node2) ⇒ Object

--- Comment reason ----------------------------------------------------



176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 176

def self.build_comment_difference_reason(node1, node2)
  cm1 = node1 && NodeInspector.comment_node?(node1)
  cm2 = node2 && NodeInspector.comment_node?(node2)

  return nil unless cm1 || cm2

  if cm1 && !cm2
    "Comment present on EXPECTED only: <!--#{truncate(comment_text(node1))}-->"
  elsif cm2 && !cm1
    "Comment present on ACTUAL only: <!--#{truncate(comment_text(node2))}-->"
  else
    t1 = truncate(comment_text(node1))
    t2 = truncate(comment_text(node2))
    "Comment text differs: <!--#{t1}--> vs <!--#{t2}-->"
  end
end

.build_reason(node1, node2, diff1, diff2, dimension) ⇒ Object

--- Reason building ---------------------------------------------------



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 31

def self.build_reason(node1, node2, diff1, diff2, dimension)
  # Nil-node text content with namespace info
  if dimension == :text_content && (node1.nil? || node2.nil?)
    node = node1 || node2
    if node.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node)
      ns = Canon::XmlParsing.namespace_uri(node)
      ns_info = ns.nil? || ns.empty? ? "" : " (namespace: #{ns})"
      label = Canon::Comparison.code_pair_label(diff1, diff2)
      return "element '#{node.name}'#{ns_info}: #{label}"
    end
  end

  case dimension
  when :attribute_presence
    build_attribute_difference_reason(
      extract_attributes(node1), extract_attributes(node2)
    )
  when :attribute_values
    build_attribute_values_reason(node1, node2)
  when :text_content
    build_text_difference_reason(
      extract_text_content(node1), extract_text_content(node2)
    )
  when :attribute_order
    build_attribute_order_reason(node1, node2)
  when :comments
    build_comment_difference_reason(node1,
                                    node2) || fallback_reason(diff1,
                                                              diff2, dimension, node1, node2)
  when :whitespace_adjacency
    build_whitespace_adjacency_reason(node1, node2)
  else
    fallback_reason(diff1, diff2, dimension, node1, node2)
  end
end

.build_text_difference_reason(text1, text2) ⇒ Object

--- Text diff reason --------------------------------------------------



162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 162

def self.build_text_difference_reason(text1, text2)
  return "missing vs '#{truncate(text2)}'" if text1.nil? && text2
  return "'#{truncate(text1)}' vs missing" if text1 && text2.nil?
  return "both missing" if text1.nil? && text2.nil?

  if whitespace_only?(text1) && whitespace_only?(text2)
    return "whitespace: #{describe_whitespace(text1)} vs #{describe_whitespace(text2)}"
  end

  "Text: \"#{visualize_whitespace(text1)}\" vs \"#{visualize_whitespace(text2)}\""
end

.build_whitespace_adjacency_reason(node1, node2) ⇒ Object

--- Whitespace adjacency reason (#137) --------------------------------



199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 199

def self.build_whitespace_adjacency_reason(node1, node2)
  text1 = extract_text_content(node1)
  text2 = extract_text_content(node2)

  ws_on_first = NodeInspector.whitespace_only_text?(node1) &&
    !NodeInspector.whitespace_only_text?(node2)
  ws_on_second = NodeInspector.whitespace_only_text?(node2) &&
    !NodeInspector.whitespace_only_text?(node1)

  unless ws_on_first || ws_on_second
    return build_text_difference_reason(text1, text2)
  end

  if ws_on_first
    build_adjacency_side(text1, text2, node1, "EXPECTED", "ACTUAL")
  else
    build_adjacency_side(text2, text1, node2, "ACTUAL", "EXPECTED")
  end
end

.comment_text(node) ⇒ Object 



193
194
195
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 193

def self.comment_text(node)
  NodeInspector.text_content(node).to_s
end

.describe_whitespace(text) ⇒ Object 



228
229
230
231
232
233
234
235
236
237
238
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 228

def self.describe_whitespace(text)
  return "0 chars" if text.nil? || text.empty?

  char_count = text.length
  parts = []
  parts << "#{text.count("\n")} newlines" if text.include?("\n")
  parts << "#{text.count(' ')} spaces" if text.include?(" ")
  parts << "#{text.count("\t")} tabs" if text.include?("\t")

  "#{char_count} chars (#{parts.join(', ')})"
end

.enrich_metadata(node1, node2) ⇒ Object

--- Metadata enrichment -----------------------------------------------



69
70
71
72
73
74
75
76
77
78
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 69

def self.enrich_metadata(node1, node2)
  {
    path: Canon::Diff::PathBuilder.build(node1 || node2,
                                         format: :document),
    serialized_before: serialize(node1),
    serialized_after: serialize(node2),
    attributes_before: extract_attributes(node1),
    attributes_after: extract_attributes(node2),
  }
end

.extract_attributes(node) ⇒ Object 



88
89
90
91
92
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 88

def self.extract_attributes(node)
  return nil if node.nil?

  Canon::Diff::NodeSerializer.extract_attributes(node)
end

.extract_text_content(node) ⇒ Object

--- Text content extraction -------------------------------------------



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 139

def self.extract_text_content(node)
  return nil if node.nil?

  case node
  when Canon::Xml::Nodes::TextNode
    node.value
  when Canon::Xml::Node
    node.text_content
  else
    if defined?(Nokogiri) && node.is_a?(Nokogiri::XML::Node)
      node.content.to_s
    elsif Canon::XmlParsing.xml_node?(node)
      Canon::XmlParsing.text_content(node)
    else
      node.to_s
    end
  end
rescue StandardError
  nil
end

.serialize(node) ⇒ Object

--- Node queries (delegate to NodeSerializer) -------------------------



82
83
84
85
86
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 82

def self.serialize(node)
  return nil if node.nil?

  Canon::Diff::NodeSerializer.serialize(node)
end

.truncate(text, max_length = 40) ⇒ Object 



246
247
248
249
250
251
252
253
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 246

def self.truncate(text, max_length = 40)
  return "" if text.nil?

  text = text.to_s
  return text if text.length <= max_length

  "#{text[0...max_length]}..."
end

.visualize_whitespace(text) ⇒ Object

--- Whitespace visualization ------------------------------------------



221
222
223
224
225
226
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 221

def self.visualize_whitespace(text)
  return "" if text.nil?

  viz_map = character_visualization_map
  text.chars.map { |char| viz_map[char] || char }.join
end

.whitespace_only?(text) ⇒ Boolean

Returns:

  • (Boolean) 


240
241
242
243
244
 
# File 'lib/canon/comparison/diff_node_builder.rb', line 240

def self.whitespace_only?(text)
  return false if text.nil?

  text.to_s.strip.empty?
end