canon 0.2.11 → 0.2.12

data/lib/canon/comparison/dimensions.rb

@@ -1,54 +1,23 @@
 # frozen_string_literal: true
 
-# Comparison dimensions
-#
-# Provides dimension classes for comparing specific aspects of documents.
-# Each dimension knows how to extract and compare data according to different behaviors.
-#
-# == Architecture
-#
-# Dimensions represent "WHAT to compare" - specific aspects of a document that can be compared:
-# - Text content
-# - Comments
-# - Attribute values
-# - Attribute presence
-# - Attribute order
-# - Element position
-# - Structural whitespace
-#
-# == Behaviors
-#
-# Each dimension supports comparison behaviors:
-# - :strict - Exact comparison
-# - :normalize - Normalized comparison (e.g., collapse whitespace)
-# - :ignore - Skip comparison
-#
-# == Usage
-#
-#   # Get a dimension instance
-#   dimension = Canon::Comparison::Dimensions::Registry.get(:text_content)
-#
-#   # Compare two nodes
-#   dimension.equivalent?(node1, node2, :normalize)
-#
-#   # Or use the registry directly
-#   Canon::Comparison::Dimensions::Registry.compare(:text_content, node1, node2, :normalize)
-
-require_relative "dimensions/base_dimension"
-require_relative "dimensions/registry"
-require_relative "dimensions/text_content_dimension"
-require_relative "dimensions/comments_dimension"
-require_relative "dimensions/attribute_values_dimension"
-require_relative "dimensions/attribute_presence_dimension"
-require_relative "dimensions/attribute_order_dimension"
-require_relative "dimensions/element_position_dimension"
-require_relative "dimensions/structural_whitespace_dimension"
-
 module Canon
   module Comparison
+    # Dimension value objects for comparison aspects.
+    #
+    # Each format (XML/HTML, JSON, YAML) has a distinct set of dimensions —
+    # specific aspects of a document that can be compared with different
+    # behaviors (:strict, :normalize, :ignore).
+    #
+    # A Dimension knows its metadata (name, valid behaviors, normative
+    # classification rule).  Comparison logic stays in the comparators where
+    # it has full node context.
+    #
+    # DimensionSet groups dimensions per format.  Registry provides pre-built
+    # sets with format lookup (html/html4/html5 all resolve to the XML set).
     module Dimensions
-      # Version constant for the dimensions module
-      VERSION = "1.0.0"
+      autoload :Dimension, "canon/comparison/dimensions/dimension"
+      autoload :DimensionSet, "canon/comparison/dimensions/dimension_set"
+      autoload :Registry, "canon/comparison/dimensions/registry"
     end
   end
 end

data/lib/canon/comparison/html_comparator.rb

@@ -1,21 +1,6 @@
 # frozen_string_literal: true
 
 require "nokogiri" unless RUBY_ENGINE == "opal"
-require_relative "../comparison" # Load base module with constants first
-require_relative "markup_comparator"
-require_relative "xml_comparator"
-require_relative "match_options"
-require_relative "comparison_result"
-require_relative "compare_profile"
-require_relative "html_compare_profile"
-require_relative "../diff/diff_node"
-require_relative "../diff/diff_classifier"
-require_relative "strategies/match_strategy_factory"
-require_relative "../html/data_model"
-require_relative "xml_node_comparison"
-require_relative "xml_comparator/diff_node_builder"
-# Whitespace sensitivity module (single source of truth for sensitive elements)
-require_relative "whitespace_sensitivity"
 
 module Canon
   module Comparison
@@ -106,12 +91,6 @@ module Canon
           # Store resolved match options hash for use in comparison logic
           opts[:match_opts] = match_opts_hash
 
-          # Use tree diff if semantic_diff option is enabled
-          if match_opts.semantic_diff?
-            return perform_semantic_tree_diff(html1, html2, opts,
-                                              match_opts_hash)
-          end
-
           # Create child_opts with resolved options
           child_opts = opts.merge(child_opts)
 
@@ -188,9 +167,7 @@ module Canon
         # accepted: dom_diff routes html/html4/html5 input through
         # Nokogiri::HTML5.fragment per #118.
         def fragment_node?(node)
-          node.is_a?(Nokogiri::XML::DocumentFragment) ||
-            node.is_a?(Nokogiri::HTML4::DocumentFragment) ||
-            node.is_a?(Nokogiri::HTML5::DocumentFragment)
+          XmlBackend.document_fragment?(node)
         end
 
         # Compare children of document fragments using the shared
@@ -232,62 +209,6 @@ module Canon
           end
         end
 
-        # Perform semantic tree diff using SemanticTreeMatchStrategy
-        #
-        # @param html1 [String, Nokogiri::HTML::Document] First HTML
-        # @param html2 [String, Nokogiri::HTML::Document] Second HTML
-        # @param opts [Hash] Comparison options
-        # @param match_opts_hash [Hash] Resolved match options
-        # @return [Boolean, ComparisonResult] Result of tree diff comparison
-        def perform_semantic_tree_diff(html1, html2, opts, match_opts_hash)
-          # Capture original HTML strings for display (see equivalent? for details).
-          original_str1 = opts.delete(:_original_str1) ||
-            extract_original_string(html1)
-          original_str2 = opts.delete(:_original_str2) ||
-            extract_original_string(html2)
-
-          # Parse to Canon::Xml::Node (preserves preprocessing)
-          # For HTML, we parse as XML to get Canon::Xml::Node structure
-          node1 = parse_node_for_semantic(html1,
-                                          match_opts_hash[:preprocessing])
-          node2 = parse_node_for_semantic(html2,
-                                          match_opts_hash[:preprocessing])
-
-          # Create strategy using factory
-          strategy = Strategies::MatchStrategyFactory.create(
-            format: :html,
-            match_options: match_opts_hash,
-          )
-
-          # Pass Canon::Xml::Node directly - adapter now handles it
-          differences = strategy.match(node1, node2)
-
-          # Return based on verbose mode
-          if opts[:verbose]
-            # Get preprocessed strings for display
-            preprocessed = strategy.preprocess_for_display(node1, node2)
-
-            # Detect HTML version (default to HTML5 for Canon nodes)
-            html_version = :html5
-
-            # Return ComparisonResult with strategy metadata
-            ComparisonResult.new(
-              differences: differences,
-              preprocessed_strings: preprocessed,
-              original_strings: [original_str1, original_str2],
-              format: :html,
-              html_version: html_version,
-              match_options: match_opts_hash.merge(strategy.metadata),
-              algorithm: :semantic,
-              parse_errors_expected: Comparison.parse_errors_for(node1),
-              parse_errors_received: Comparison.parse_errors_for(node2),
-            )
-          else
-            # Simple boolean result - equivalent if no normative differences
-            differences.none?(&:normative?)
-          end
-        end
-
         # Parse node as fragment to preserve actual content
         # Uses HTML4.fragment or HTML5.fragment based on content detection
         #
@@ -296,15 +217,11 @@ module Canon
         # @param match_opts [Hash] Match options
         # @return [Nokogiri::HTML::DocumentFragment] Parsed fragment
         def parse_node_as_fragment(node, preprocessing = :none, match_opts = {})
-          # If already an XML fragment (no meta tags), return it
-          if node.is_a?(Nokogiri::XML::DocumentFragment)
+          if XmlBackend.document_fragment?(node)
             return node
           end
 
-          # Convert HTML fragments to string and re-parse as XML to remove phantom tags
-          # This handles cases where pre-parsed HTML4/HTML5 fragments have auto-inserted meta
-          html_string = if node.is_a?(Nokogiri::HTML4::DocumentFragment) ||
-              node.is_a?(Nokogiri::HTML5::DocumentFragment)
+          html_string = if XmlBackend.document_fragment?(node)
                           node.to_s # Use to_s to avoid re-inserting meta tags
                         elsif node.is_a?(String)
                           node
@@ -312,10 +229,7 @@ module Canon
                           node.to_html
                         end
 
-          # Use XML fragment parser to preserve structure without auto-generated elements.
-          # Decode HTML named entities (  etc.) to UTF-8 characters since XML
-          # parser only understands the five XML entities.
-          frag = Nokogiri::XML.fragment(
+          frag = XmlBackend.xml_fragment(
             decode_html_named_entities(html_string),
           )
 
@@ -402,24 +316,15 @@ module Canon
 
             # Normalize HTML documents to fragments to avoid DTD differences
             # This ensures comparing string with document works correctly
-            if node.is_a?(Nokogiri::HTML::Document) ||
-                node.is_a?(Nokogiri::HTML4::Document) ||
-                node.is_a?(Nokogiri::HTML5::Document)
-              # Get root element and create fragment from its outer HTML
-              # This avoids DOCTYPE and other document-level nodes
+            if XmlBackend.html_document?(node)
               root = node.at_css("html") || node.root
               if root
-                node = Nokogiri::XML.fragment(root.to_html)
+                node = XmlBackend.xml_fragment(root.to_html)
               end
             end
 
-            # For preprocessing modes that require whitespace filtering,
-            # apply the same post-parsing normalization used for string inputs.
-            # This is needed because dom_diff() pre-parses HTML5 strings into
-            # Nokogiri fragments before calling HtmlComparator, bypassing the
-            # string-input path where these filters are normally applied.
             if %i[normalize format rendered].include?(preprocessing)
-              frag = node.is_a?(Nokogiri::XML::DocumentFragment) ? node : Nokogiri::XML.fragment(node.to_html)
+              frag = XmlBackend.document_fragment?(node) ? node : XmlBackend.xml_fragment(node.to_html)
               normalize_html_style_script_comments(frag)
               if preprocessing == :rendered
                 normalize_rendered_whitespace(frag, match_opts)
@@ -467,11 +372,7 @@ module Canon
                           node
                         end
 
-          # Parse as Nokogiri fragment for DOM comparison
-          # Use XML fragment parser to avoid auto-inserted meta tags.
-          # Decode HTML named entities (  etc.) to UTF-8 characters since
-          # XML parser only understands the five XML entities.
-          frag = Nokogiri::XML.fragment(
+          frag = XmlBackend.xml_fragment(
             decode_html_named_entities(html_string),
           )
 
@@ -565,17 +466,7 @@ module Canon
         # @param node [Canon::Xml::Node, Nokogiri::XML::Node] HTML node
         # @return [Symbol] :html5 or :html4
         def detect_html_version_from_node(node)
-          # Check node type for Nokogiri
-          if node.is_a?(Nokogiri::HTML5::Document) ||
-              node.is_a?(Nokogiri::HTML5::DocumentFragment)
-            :html5
-          elsif node.is_a?(Nokogiri::HTML4::Document) ||
-              node.is_a?(Nokogiri::HTML4::DocumentFragment)
-            :html4
-          else
-            # Default to HTML5 for Canon::Xml::Node and unknown types
-            :html5
-          end
+          XmlBackend.html_version_from_node(node)
         end
 
         # Serialize node to string for diff display
@@ -585,7 +476,7 @@ module Canon
         # @return [String] Serialized HTML string
         def serialize_for_display(node)
           if node.is_a?(Canon::Xml::Node)
-            XmlNodeComparison.serialize_node_to_xml(node)
+            Canon::Diff::NodeSerializer.serialize(node)
           elsif Canon::XmlParsing.xml_node?(node)
             Canon::XmlBackend.nokogiri? ? node.to_html : Canon::XmlParsing.serialize(node)
           else
@@ -780,32 +671,18 @@ compare_profile = nil)
         # XML documents typically have XML processing instructions or are
         # instances of Nokogiri::XML::Document (not HTML variants)
         def xml_document?(node)
-          # Check if it's a pure XML document (not HTML4/HTML5 which also
-          # inherit from XML::Document)
-          # Check both Document and DocumentFragment variants
-          return false if node.is_a?(Nokogiri::HTML4::Document) ||
-            node.is_a?(Nokogiri::HTML5::Document) ||
-            node.is_a?(Nokogiri::HTML4::DocumentFragment) ||
-            node.is_a?(Nokogiri::HTML5::DocumentFragment)
-
-          # If it's an XML document, check for XML processing instruction
-          if node.is_a?(Nokogiri::XML::Document) && node.children.any? do |child|
-            child.is_a?(Nokogiri::XML::ProcessingInstruction) &&
-                child.name == "xml"
+          return false if XmlBackend.html_document?(node) || XmlBackend.document_fragment?(node)
+
+          if XmlBackend.nokogiri? && node.is_a?(Nokogiri::XML::Document) && node.children.any? do |child|
+            child.is_a?(Nokogiri::XML::ProcessingInstruction) && child.name == "xml"
           end
-            # XML documents often start with <?xml ...?> processing instruction
             return true
-
-            # Note: We don't blindly return true here because HTML documents
-            # also inherit from XML::Document. We only return true if there's
-            # an XML processing instruction above.
           end
 
-          # Check if it's a fragment that contains XML processing instructions
-          if (node.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node)) && node.children.any? do |child|
-            child.is_a?(Nokogiri::XML::ProcessingInstruction) &&
-                child.name == "xml"
-          end
+          if (node.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node)) &&
+              XmlBackend.nokogiri? && node.children.any? do |child|
+                child.is_a?(Nokogiri::XML::ProcessingInstruction) && child.name == "xml"
+              end
             return true
           end
 

data/lib/canon/comparison/html_compare_profile.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "compare_profile"
-# Whitespace sensitivity module (single source of truth for sensitive elements)
-require_relative "whitespace_sensitivity"
-
 module Canon
   module Comparison
     # HtmlCompareProfile extends CompareProfile with HTML-specific comparison policies
@@ -29,34 +25,35 @@ module Canon
       # Override for HTML-specific comment handling
       #
       # In HTML, comments are presentational content (not part of the DOM semantics)
-      # unless explicitly set to :strict. This differs from XML where comments
-      # may carry semantic meaning.
-      #
-      # HTML default for comments is :ignore, so comments don't affect equivalence
-      # unless the user explicitly sets comments: :strict
+      # unless explicitly set to :strict.
       #
       # @param dimension [Symbol] The match dimension to check
       # @return [Boolean] true if differences affect equivalence
       def affects_equivalence?(dimension)
-        # Comments in HTML: default is :ignore (presentational)
-        # Only affect equivalence if explicitly set to :strict
         if dimension == :comments
-          # Check if comments key exists in options
           if match_options.is_a?(Hash)
-            # If comments key doesn't exist, default to false (HTML default: ignore)
             return false unless match_options.key?(:comments)
 
-            # If key exists, check if it's :strict
             return match_options[:comments] == :strict
           elsif match_options.is_a?(ResolvedMatchOptions)
-            behavior = behavior_for(dimension)
-            return behavior == :strict
+            return behavior_for(dimension) == :strict
           end
-          # Default: comments don't affect equivalence in HTML
           return false
         end
 
-        # All other dimensions use base class behavior
+        super
+      end
+
+      # Override normative classification for HTML-specific comment handling.
+      #
+      # Delegates to the parent class for all dimensions, which in turn delegates
+      # to Dimension objects.  For :comments, applies the same HTML-specific rule
+      # as affects_equivalence? — comments default to non-normative in HTML.
+      def normative_dimension?(dimension)
+        if dimension == :comments
+          return affects_equivalence?(:comments)
+        end
+
         super
       end
 

data/lib/canon/comparison/json_comparator.rb

@@ -1,49 +1,30 @@
 # frozen_string_literal: true
 
 require "json"
-require_relative "match_options"
-require_relative "comparison_result"
 
 module Canon
   module Comparison
     # JSON comparison class
-    # Handles comparison of JSON objects with various options
+    # Delegates to RubyObjectComparator for actual comparison logic
     class JsonComparator
-      # Default comparison options for JSON
       DEFAULT_OPTS = {
-        # Output options
         verbose: false,
-
-        # Match system options
         match_profile: nil,
         match: nil,
         preprocessing: nil,
         global_profile: nil,
         global_options: nil,
-
-        # Diff display options
         diff: nil,
       }.freeze
 
       class << self
-        # Parse JSON from string or return as-is
-        #
-        # @param obj [String, Hash, Array] JSON string or parsed object
-        # @return [Object] Parsed JSON object
         def parse(obj)
           parse_json(obj)
         end
 
-        # Compare two JSON objects for equivalence
-        #
-        # @param json1 [String, Hash, Array] First JSON
-        # @param json2 [String, Hash, Array] Second JSON
-        # @param opts [Hash] Comparison options
-        # @return [Boolean, ComparisonResult] true if equivalent, or ComparisonResult if verbose
         def equivalent?(json1, json2, opts = {})
           opts = DEFAULT_OPTS.merge(opts)
 
-          # Resolve match options with format-specific defaults
           match_opts_hash = MatchOptions::Json.resolve(
             format: :json,
             match_profile: opts[:match_profile],
@@ -53,24 +34,16 @@ module Canon
             global_options: opts[:global_options],
           )
 
-          # Wrap in ResolvedMatchOptions for consistency with XML/HTML
-          Canon::Comparison::ResolvedMatchOptions.new(
-            match_opts_hash,
-            format: :json,
-          )
-
-          # Store resolved match options for use in comparison logic
           opts[:match_opts] = match_opts_hash
 
-          # Parse JSON if strings
           obj1 = parse_json(json1)
           obj2 = parse_json(json2)
 
           differences = []
-          result = compare_ruby_objects(obj1, obj2, opts, differences, "")
+          result = RubyObjectComparator.compare_objects(obj1, obj2, opts,
+                                                        differences, "")
 
           if opts[:verbose]
-            # Format JSON for display
             json_str1 = obj1.is_a?(String) ? obj1 : JSON.pretty_generate(obj1)
             json_str2 = obj2.is_a?(String) ? obj2 : JSON.pretty_generate(obj2)
 
@@ -87,148 +60,14 @@ module Canon
 
         private
 
-        # Parse JSON from string or return as-is
         def parse_json(obj)
           return obj unless obj.is_a?(String)
 
           begin
             JSON.parse(obj)
           rescue JSON::ParserError
-            obj # Return original string if parsing fails
-          end
-        end
-
-        # Compare Ruby objects (Hash, Array, primitives) for JSON/YAML
-        def compare_ruby_objects(obj1, obj2, opts, differences, path)
-          # Check for type mismatch
-          unless obj1.instance_of?(obj2.class)
-            add_ruby_difference(path, obj1, obj2, Comparison::UNEQUAL_TYPES,
-                                opts, differences)
-            return Comparison::UNEQUAL_TYPES
-          end
-
-          case obj1
-          when Hash
-            compare_hashes(obj1, obj2, opts, differences, path)
-          when Array
-            compare_arrays(obj1, obj2, opts, differences, path)
-          when NilClass, TrueClass, FalseClass, Numeric, String, Symbol
-            compare_primitives(obj1, obj2, opts, differences, path)
-          else
-            # Fallback to equality comparison
-            if obj1 == obj2
-              Comparison::EQUIVALENT
-            else
-              add_ruby_difference(path, obj1, obj2,
-                                  Comparison::UNEQUAL_PRIMITIVES, opts,
-                                  differences)
-              Comparison::UNEQUAL_PRIMITIVES
-            end
-          end
-        end
-
-        # Compare two hashes
-        def compare_hashes(hash1, hash2, opts, differences, path)
-          keys1 = hash1.keys
-          keys2 = hash2.keys
-
-          # Sort keys if order should be ignored (based on match options)
-          match_opts = opts[:match_opts]
-          if match_opts[:key_order] != :strict
-            keys1 = keys1.sort_by(&:to_s)
-            keys2 = keys2.sort_by(&:to_s)
-          elsif keys1 != keys2
-            # Strict mode: key order matters
-            # Check if keys are in same order
-            # Keys are different or in different order
-            # First check if it's just ordering (same keys, different order)
-            if keys1.sort_by(&:to_s) == keys2.sort_by(&:to_s)
-              # Same keys, different order - this is a key_order difference
-              key_path = path.empty? ? "(key order)" : "#{path}.(key order)"
-              add_ruby_difference(key_path, keys1, keys2,
-                                  Comparison::UNEQUAL_HASH_KEY_ORDER, opts, differences)
-              return Comparison::UNEQUAL_HASH_KEY_ORDER
-            end
-          end
-
-          # Check for missing keys
-          missing_in_2 = keys1 - keys2
-          missing_in_1 = keys2 - keys1
-
-          missing_in_2.each do |key|
-            key_path = path.empty? ? key.to_s : "#{path}.#{key}"
-            add_ruby_difference(key_path, hash1[key], nil,
-                                Comparison::MISSING_HASH_KEY, opts, differences)
-          end
-
-          missing_in_1.each do |key|
-            key_path = path.empty? ? key.to_s : "#{path}.#{key}"
-            add_ruby_difference(key_path, nil, hash2[key],
-                                Comparison::MISSING_HASH_KEY, opts, differences)
-          end
-
-          has_missing_keys = !missing_in_1.empty? || !missing_in_2.empty?
-
-          # Compare common keys
-          common_keys = keys1 & keys2
-          all_equivalent = true
-          common_keys.each do |key|
-            key_path = path.empty? ? key.to_s : "#{path}.#{key}"
-            result = compare_ruby_objects(hash1[key], hash2[key], opts,
-                                          differences, key_path)
-            all_equivalent = false unless result == Comparison::EQUIVALENT
-          end
-
-          # Return appropriate status
-          return Comparison::MISSING_HASH_KEY if has_missing_keys && all_equivalent
-          return Comparison::UNEQUAL_HASH_VALUES unless all_equivalent
-
-          has_missing_keys ? Comparison::MISSING_HASH_KEY : Comparison::EQUIVALENT
-        end
-
-        # Compare two arrays
-        def compare_arrays(arr1, arr2, opts, differences, path)
-          unless arr1.length == arr2.length
-            add_ruby_difference(path, arr1, arr2,
-                                Comparison::UNEQUAL_ARRAY_LENGTHS, opts,
-                                differences)
-            return Comparison::UNEQUAL_ARRAY_LENGTHS
+            obj
           end
-
-          all_equivalent = true
-          arr1.each_with_index do |elem1, index|
-            elem2 = arr2[index]
-            elem_path = "#{path}[#{index}]"
-            result = compare_ruby_objects(elem1, elem2, opts, differences,
-                                          elem_path)
-            all_equivalent = false unless result == Comparison::EQUIVALENT
-          end
-
-          all_equivalent ? Comparison::EQUIVALENT : Comparison::UNEQUAL_ARRAY_ELEMENTS
-        end
-
-        # Compare primitive values
-        def compare_primitives(val1, val2, opts, differences, path)
-          if val1 == val2
-            Comparison::EQUIVALENT
-          else
-            add_ruby_difference(path, val1, val2,
-                                Comparison::UNEQUAL_PRIMITIVES, opts,
-                                differences)
-            Comparison::UNEQUAL_PRIMITIVES
-          end
-        end
-
-        # Add a Ruby object difference
-        def add_ruby_difference(path, obj1, obj2, diff_code, opts, differences)
-          return unless opts[:verbose]
-
-          differences << {
-            path: path,
-            value1: obj1,
-            value2: obj2,
-            diff_code: diff_code,
-          }
         end
       end
     end

data/lib/canon/comparison/json_parser.rb

@@ -10,8 +10,6 @@ module Canon
       # @param obj [String, Hash, Array] Object to parse
       # @return [Hash, Array] Parsed Ruby object
       def self.parse_json(obj)
-        # Delegate to JsonComparator's private method via public API
-        require_relative "json_comparator"
         JsonComparator.parse_json(obj)
       end
     end