canon 0.2.11 → 0.2.12

data/lib/canon/comparison/xml_comparator/diff_node_builder.rb

@@ -1,300 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-require_relative "../../diff/diff_node"
-require_relative "../../diff/path_builder"
-require_relative "../../diff/node_serializer"
-require_relative "../node_inspector"
-
-module Canon
-  module Comparison
-    # Builder for creating enriched DiffNode objects
-    # Handles path building, serialization, and attribute extraction
-    class DiffNodeBuilder
-      # Build an enriched DiffNode
-      #
-      # @param node1 [Object, nil] First node
-      # @param node2 [Object, nil] Second node
-      # @param diff1 [String] Difference type for node1
-      # @param diff2 [String] Difference type for node2
-      # @param dimension [Symbol] The match dimension causing this difference
-      # @return [DiffNode, nil] Enriched DiffNode or nil if dimension is nil
-      def self.build(node1:, node2:, diff1:, diff2:, dimension:, **_opts)
-        # Validate dimension is required
-        if dimension.nil?
-          raise ArgumentError,
-                "dimension required for DiffNode"
-        end
-
-        # Build informative reason message
-        reason = build_reason(node1, node2, diff1, diff2, dimension)
-
-        # Enrich with path, serialized content, and attributes for Stage 4 rendering
-        metadata = enrich_metadata(node1, node2)
-
-        Canon::Diff::DiffNode.new(
-          node1: node1,
-          node2: node2,
-          dimension: dimension,
-          reason: reason,
-          **metadata,
-        )
-      end
-
-      # Build a human-readable reason for a difference
-      #
-      # @param node1 [Object] First node
-      # @param node2 [Object] Second node
-      # @param diff1 [String] Difference type for node1
-      # @param diff2 [String] Difference type for node2
-      # @param dimension [Symbol] The dimension of the difference
-      # @return [String] Human-readable reason
-      def self.build_reason(node1, node2, diff1, diff2, dimension)
-        # For deleted/inserted nodes, include namespace information if available
-        if dimension == :text_content && (node1.nil? || node2.nil?)
-          node = node1 || node2
-          if node.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node)
-            ns = node.namespace_uri
-            ns_info = if ns.nil? || ns.empty?
-                        ""
-                      else
-                        " (namespace: #{ns})"
-                      end
-            label = Canon::Comparison.code_pair_label(diff1, diff2)
-            return "element '#{node.name}'#{ns_info}: #{label}"
-          end
-        end
-
-        # For attribute presence differences, show what attributes differ
-        if dimension == :attribute_presence
-          attrs1 = extract_attributes(node1)
-          attrs2 = extract_attributes(node2)
-          return build_attribute_difference_reason(attrs1, attrs2)
-        end
-
-        # For attribute value differences, show which attributes changed
-        if dimension == :attribute_values
-          return build_attribute_values_reason(node1, node2)
-        end
-
-        # For text content differences, show the actual text (truncated if needed)
-        if dimension == :text_content
-          text1 = extract_text_content(node1)
-          text2 = extract_text_content(node2)
-          return build_text_difference_reason(text1, text2)
-        end
-
-        # For attribute order differences, show the actual attribute names
-        if dimension == :attribute_order
-          attrs1 = extract_attributes(node1)&.keys || []
-          attrs2 = extract_attributes(node2)&.keys || []
-          return "Attribute order changed: [#{attrs1.join(', ')}] → [#{attrs2.join(', ')}]"
-        end
-
-        # For asymmetric comment nodes (#144), name the side that carries
-        # the comment and surface the comment text rather than reusing
-        # the generic "element structure mismatch" wording.
-        if dimension == :comments
-          comment_reason = build_comment_difference_reason(node1, node2)
-          return comment_reason if comment_reason
-        end
-
-        # Default reason
-        if diff1 == Canon::Comparison::MISSING_NODE && diff2 == Canon::Comparison::MISSING_NODE
-          "element structure mismatch (children differ)"
-        elsif dimension == :element_structure &&
-            diff1 == Canon::Comparison::UNEQUAL_ELEMENTS &&
-            diff2 == Canon::Comparison::UNEQUAL_ELEMENTS &&
-            (node1.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node1)) &&
-            (node2.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node2)) &&
-            node1.name && node2.name && node1.name != node2.name
-          "different element name (<#{node1.name}> vs <#{node2.name}>)"
-        else
-          Canon::Comparison.code_pair_label(diff1, diff2)
-        end
-      end
-
-      # Enrich DiffNode with canonical path, serialized content, and attributes
-      # This extracts presentation-ready metadata from nodes for Stage 4 rendering
-      #
-      # @param node1 [Object, nil] First node
-      # @param node2 [Object, nil] Second node
-      # @return [Hash] Enriched metadata hash
-      def self.enrich_metadata(node1, node2)
-        {
-          path: build_path(node1 || node2),
-          serialized_before: serialize(node1),
-          serialized_after: serialize(node2),
-          attributes_before: extract_attributes(node1),
-          attributes_after: extract_attributes(node2),
-        }
-      end
-
-      # Build canonical path for a node
-      #
-      # @param node [Object] Node to build path for
-      # @return [String, nil] Canonical path with ordinal indices
-      def self.build_path(node)
-        return nil if node.nil?
-
-        Canon::Diff::PathBuilder.build(node, format: :document)
-      end
-
-      # Serialize a node to string for display
-      #
-      # @param node [Object, nil] Node to serialize
-      # @return [String, nil] Serialized content
-      def self.serialize(node)
-        return nil if node.nil?
-
-        Canon::Diff::NodeSerializer.serialize(node)
-      end
-
-      # Extract attributes from a node as a normalized hash
-      #
-      # @param node [Object, nil] Node to extract attributes from
-      # @return [Hash, nil] Normalized attributes hash
-      def self.extract_attributes(node)
-        return nil if node.nil?
-
-        Canon::Diff::NodeSerializer.extract_attributes(node)
-      end
-
-      # Build a clear reason message for attribute presence differences
-      # Shows which attributes are only in node1, only in node2, or different values
-      #
-      # @param attrs1 [Hash, nil] First node's attributes
-      # @param attrs2 [Hash, nil] Second node's attributes
-      # @return [String] Clear explanation of the attribute difference
-      def self.build_attribute_difference_reason(attrs1, attrs2)
-        return "#{attrs1&.keys&.size || 0} vs #{attrs2&.keys&.size || 0} attributes" unless attrs1 && attrs2
-
-        keys1 = attrs1.keys.to_set
-        keys2 = attrs2.keys.to_set
-
-        only_in_1 = keys1 - keys2
-        only_in_2 = keys2 - keys1
-        common = keys1 & keys2
-
-        # Check if values differ for common keys
-        different_values = common.reject { |k| attrs1[k] == attrs2[k] }
-
-        parts = []
-        parts << "only in first: #{only_in_1.to_a.sort.join(', ')}" if only_in_1.any?
-        parts << "only in second: #{only_in_2.to_a.sort.join(', ')}" if only_in_2.any?
-        parts << "different values: #{different_values.sort.join(', ')}" if different_values.any?
-
-        if parts.empty?
-          "#{keys1.size} vs #{keys2.size} attributes (same names)"
-        else
-          parts.join("; ")
-        end
-      end
-
-      # Build a reason message for attribute value differences
-      # Shows each changed attribute with its before/after values
-      #
-      # @param node1 [Object, nil] First node
-      # @param node2 [Object, nil] Second node
-      # @return [String] Clear explanation of the attribute value differences
-      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_parts = differing.map do |k|
-          "Changed: #{k}=\"#{attrs1[k.to_s]}\" → \"#{attrs2[k.to_s]}\""
-        end
-
-        if changed_parts.empty?
-          "attributes differ"
-        else
-          "Attributes differ (#{changed_parts.join('; ')})"
-        end
-      end
-
-      # Extract text content from a node
-      #
-      # @param node [Object, nil] Node to extract text from
-      # @return [String, nil] Text content or nil
-      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 Canon::XmlBackend.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
-
-      # Build a clear reason message for text content differences
-      # Shows the actual text content (truncated if too long)
-      #
-      # @param text1 [String, nil] First text content
-      # @param text2 [String, nil] Second text content
-      # @return [String] Clear explanation of the text difference
-      def self.build_text_difference_reason(text1, text2)
-        # Handle nil cases
-        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?
-
-        # Both have content - show truncated versions
-        "'#{truncate(text1)}' vs '#{truncate(text2)}'"
-      end
-
-      # Build a Reason line for a +:comments+ diff. Returns +nil+ when
-      # neither side carries a comment (caller falls back to default).
-      def self.build_comment_difference_reason(node1, node2)
-        cm1 = node1 && Canon::Comparison::NodeInspector.comment_node?(node1)
-        cm2 = node2 && Canon::Comparison::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
-
-      def self.comment_text(node)
-        Canon::Comparison::NodeInspector.text_content(node).to_s
-      end
-
-      # Truncate text for display in reason messages
-      #
-      # @param text [String] Text to truncate
-      # @param max_length [Integer] Maximum length
-      # @return [String] Truncated text
-      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
-    end
-  end
-end