canon 0.1.3 → 0.1.5

data/lib/canon/rspec_matchers.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require "canon" unless defined?(::Canon)
-require "compare-xml"
-require "diffy"
+require "canon/comparison"
+require "canon/diff_formatter"
+require "canon/config"
 
 begin
   require "rspec/expectations"
@@ -11,117 +12,226 @@ end
 
 module Canon
   module RSpecMatchers
+    # Configuration for RSpec matchers - delegates to Canon::Config
+    class << self
+      def configure
+        yield Canon::Config.configure
+      end
+
+      def reset_config
+        Canon::Config.reset!
+      end
+
+      # Delegate configuration getters to Canon::Config
+      def xml
+        Canon::Config.instance.xml
+      end
+
+      def html
+        Canon::Config.instance.html
+      end
+
+      def json
+        Canon::Config.instance.json
+      end
+
+      def yaml
+        Canon::Config.instance.yaml
+      end
+    end
+
     # Base matcher class for serialization equivalence
+    # This is a THIN WRAPPER around Canon::Comparison API
     class SerializationMatcher
-      def initialize(expected, format = :xml)
+      def initialize(expected, format = nil, match_profile: nil,
+                     match: nil, preprocessing: nil)
         @expected = expected
-        unless SUPPORTED_FORMATS.include?(format.to_sym)
-          raise Canon::Error, "Unsupported format: #{format}"
-        end
-
-        @format = format.to_sym
-        @result = nil
+        @format = format&.to_sym
+        @match_profile = match_profile
+        @match = match
+        @preprocessing = preprocessing
       end
 
       def matches?(target)
         @target = target
-        send("match_#{@format}")
-      rescue NoMethodError
-        raise Canon::Error, "Unsupported format: #{@format}"
-      end
-
-      def match_xml
-        @result = CompareXML.equivalent?(
-          Nokogiri::XML(@target),
-          Nokogiri::XML(@expected),
-          {
-            collapse_whitespace: true,
-            ignore_attr_order: true,
-            verbose: true,
-          },
+
+        # Build comparison options from config and matcher params
+        opts = build_comparison_options
+
+        # Add format hint if explicitly provided
+        opts[:format] = @format if @format
+
+        # Delegate to Canon::Comparison.equivalent? - the SINGLE source of truth
+        # Comparison handles format detection, HTML parsing, and all business logic
+        @comparison_result = Canon::Comparison.equivalent?(
+          @expected,
+          @target,
+          opts,
         )
 
-        @result.empty?
+        # When verbose: true, result is a ComparisonResult object
+        # Use the equivalent? method to check for normative differences
+        case @comparison_result
+        when Canon::Comparison::ComparisonResult
+          @comparison_result.equivalent?
+        when Hash
+          # Legacy format - Hash with :differences array and :preprocessed strings
+          @comparison_result[:differences].empty?
+        when Array
+          # Legacy format - XML/JSON/YAML returns []
+          @comparison_result.empty?
+        else
+          # Boolean result
+          @comparison_result
+        end
       end
 
-      # Canonicalize and check string equivalence for YAML/JSON
-      def match_yaml
-        canonicalize_and_compare(:yaml)
+      def failure_message
+        "expected #{format_name} to be equivalent\n\n#{diff_output}"
       end
 
-      def match_json
-        canonicalize_and_compare(:json)
+      def failure_message_when_negated
+        "expected #{format_name} not to be equivalent"
       end
 
-      private
+      def expected
+        @expected
+      end
 
-      def canonicalize_and_compare(format)
-        @actual_sorted = Canon.format(@target, format)
-        @expected_sorted = Canon.format(@expected, format)
-        @actual_sorted == @expected_sorted
+      def actual
+        @target
       end
 
-      def failure_message
-        case @format
-        when :xml
-          xml_failure_message
-        when :yaml, :json
-          generic_failure_message
+      def diffable
+        false
+      end
+
+      private
+
+      def format_name
+        # Use explicitly provided format if available
+        if @format
+          case @format
+          when :html4, :html5 then "HTML"
+          when :string then "STRING"
+          else @format.to_s.upcase
+          end
+        else
+          # Fall back to detection only if format not provided
+          begin
+            detected_format = Canon::Comparison.send(:detect_format, @expected)
+            detected_format.to_s.upcase
+          rescue StandardError
+            "CONTENT"
+          end
         end
       end
 
-      def xml_failure_message
-        index = 0
-        @result.map do |hash|
-          index += 1
-          index_str = index.to_s.rjust(2, "0")
-          "DIFF #{index_str}:\n" \
-          "    expected node: #{hash[:node1]}\n" \
-          "    actual node  : #{hash[:node2]}\n" \
-          "    diff from    : #{hash[:diff1]}\n" \
-          "    diff to      : #{hash[:diff2]}\n"
-        end.join("\n")
-      end
-
-      def generic_failure_message
-        diff = Diffy::Diff.new(
-          @expected_sorted,
-          @actual_sorted,
-          include_diff_info: false,
-          include_plus_and_minus_in_html: true,
-          diff_options: "-u",
-        )
+      def build_comparison_options
+        opts = { verbose: true } # Always use verbose for diff generation
+
+        # Add per-test parameters (highest priority)
+        opts[:match_profile] = @match_profile if @match_profile
+        opts[:match] = @match if @match
+        opts[:preprocessing] = @preprocessing if @preprocessing
+
+        # Add global configuration from Canon::Config (lower priority)
+        if @format
+          config_format = normalize_format_for_config(@format)
+
+          # Only access config if format is supported
+          if Canon::Config.instance.respond_to?(config_format)
+            format_config = Canon::Config.instance.public_send(config_format)
+            if format_config.match.profile
+              opts[:global_profile] =
+                format_config.match.profile
+            end
+            unless format_config.match.options.empty?
+              opts[:global_options] =
+                format_config.match.options
+            end
+            opts[:preprocessing] ||= format_config.preprocessing
+          elsif !%i[xml html html4 html5 json yaml
+                    string].include?(@format)
+            # Unsupported format - raise error early
+            raise Canon::Error, "Unsupported format: #{@format}"
+          end
+        end
 
-        "expected #{@format.to_s.upcase} to be equivalent\n\n" \
-          "Diff:\n" +
-          diff.to_s(:color)
+        opts
       end
 
-      def failure_message_when_negated
-        [
-          "expected:",
-          @target.to_s,
-          "not be equivalent to:",
-          @expected.to_s,
-        ].join("\n")
+      def normalize_format_for_config(format)
+        case format
+        when :html4, :html5 then :html
+        else format
+        end
       end
 
-      def diffable
-        true
+      def diff_output
+        # For string format, use simple diff since there's no comparison_result
+        if @format == :string
+          config_format = :xml # Use XML config as fallback for string
+          diff_config = Canon::Config.instance.public_send(config_format).diff
+
+          formatter = Canon::DiffFormatter.new(
+            use_color: diff_config.use_color,
+            mode: :by_line, # Always use by_line for strings
+            context_lines: diff_config.context_lines,
+            diff_grouping_lines: diff_config.grouping_lines,
+            show_diffs: diff_config.show_diffs,
+          )
+
+          return formatter.format([], :string, doc1: @expected.to_s,
+                                               doc2: @target.to_s)
+        end
+
+        # Get diff configuration
+        config_format = normalize_format_for_config(@format || :xml)
+        diff_config = Canon::Config.instance.public_send(config_format).diff
+
+        # Delegate to Canon::DiffFormatter - the SINGLE source of diff generation
+        formatter = Canon::DiffFormatter.new(
+          use_color: diff_config.use_color,
+          mode: diff_config.mode,
+          context_lines: diff_config.context_lines,
+          diff_grouping_lines: diff_config.grouping_lines,
+          show_diffs: diff_config.show_diffs,
+          verbose_diff: diff_config.verbose_diff,
+        )
+
+        # Format the diff using the comparison result
+        formatter.format_comparison_result(@comparison_result, @expected,
+                                           @target)
+      rescue StandardError => e
+        "\nError generating diff: #{e.message}"
       end
     end
 
     # Matcher methods
-    def be_serialization_equivalent_to(expected, format: :xml)
-      SerializationMatcher.new(expected, format)
+    def be_serialization_equivalent_to(expected, format: :xml,
+                                      match_profile: nil, match: nil,
+                                      preprocessing: nil)
+      SerializationMatcher.new(expected, format,
+                               match_profile: match_profile,
+                               match: match,
+                               preprocessing: preprocessing)
     end
 
-    def be_analogous_with(expected)
-      SerializationMatcher.new(expected, :xml)
+    def be_analogous_with(expected, match_profile: nil, match: nil,
+                         preprocessing: nil)
+      SerializationMatcher.new(expected, :xml,
+                               match_profile: match_profile,
+                               match: match,
+                               preprocessing: preprocessing)
     end
 
-    def be_xml_equivalent_to(expected)
-      SerializationMatcher.new(expected, :xml)
+    def be_xml_equivalent_to(expected, match_profile: nil, match: nil,
+                            preprocessing: nil)
+      SerializationMatcher.new(expected, :xml,
+                               match_profile: match_profile,
+                               match: match,
+                               preprocessing: preprocessing)
     end
 
     def be_yaml_equivalent_to(expected)
@@ -132,7 +242,39 @@ module Canon
       SerializationMatcher.new(expected, :json)
     end
 
-    if defined?(::RSpec)
+    def be_html_equivalent_to(expected, match_profile: nil, match: nil,
+                             preprocessing: nil)
+      SerializationMatcher.new(expected, :html,
+                               match_profile: match_profile,
+                               match: match,
+                               preprocessing: preprocessing)
+    end
+
+    def be_html4_equivalent_to(expected, match_profile: nil, match: nil,
+                              preprocessing: nil)
+      SerializationMatcher.new(expected, :html4,
+                               match_profile: match_profile,
+                               match: match,
+                               preprocessing: preprocessing)
+    end
+
+    def be_html5_equivalent_to(expected, match_profile: nil, match: nil,
+                              preprocessing: nil)
+      SerializationMatcher.new(expected, :html5,
+                               match_profile: match_profile,
+                               match: match,
+                               preprocessing: preprocessing)
+    end
+
+    def be_equivalent_to(expected)
+      SerializationMatcher.new(expected, nil)
+    end
+
+    def be_string_equivalent_to(expected)
+      SerializationMatcher.new(expected, :string)
+    end
+
+    if defined?(::RSpec) && ::RSpec.respond_to?(:configure)
       RSpec.configure do |config|
         config.include(Canon::RSpecMatchers)
       end

data/lib/canon/validators/base_validator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../errors"
+
+module Canon
+  module Validators
+    # Base class for all input validators
+    #
+    # This abstract base class defines the interface that all format-specific
+    # validators must implement. Each validator is responsible for validating
+    # input in a specific format and raising detailed ValidationError when
+    # issues are found.
+    class BaseValidator
+      # Validate input and raise ValidationError if invalid
+      #
+      # @param input [String] The input to validate
+      # @raise [Canon::ValidationError] If input is invalid
+      # @return [void]
+      def self.validate!(input)
+        raise NotImplementedError,
+              "#{name} must implement validate! method"
+      end
+
+      # Extract line and column information from an error
+      #
+      # @param error [Exception] The error containing location information
+      # @return [Hash] Hash with :line and :column keys
+      def self.extract_location(error)
+        line = nil
+        column = nil
+
+        # Try to extract line/column from error message
+        if error.respond_to?(:line)
+          line = error.line
+        elsif error.message =~ /line[:\s]+(\d+)/i
+          line = ::Regexp.last_match(1).to_i
+        end
+
+        if error.respond_to?(:column)
+          column = error.column
+        elsif error.message =~ /column[:\s]+(\d+)/i
+          column = ::Regexp.last_match(1).to_i
+        end
+
+        { line: line, column: column }
+      end
+    end
+  end
+end

data/lib/canon/validators/html_validator.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require_relative "base_validator"
+
+module Canon
+  module Validators
+    # Validator for HTML input
+    #
+    # Validates HTML input (HTML4, HTML5, or XHTML) using Nokogiri.
+    # Automatically detects the HTML type and applies appropriate validation.
+    # Raises detailed ValidationError with line and column information
+    # when malformed HTML is detected.
+    class HtmlValidator < BaseValidator
+      # Validate HTML input
+      #
+      # @param input [String] The HTML string to validate
+      # @raise [Canon::ValidationError] If HTML is malformed
+      # @return [void]
+      def self.validate!(input)
+        return if input.nil? || input.strip.empty?
+
+        # Strip XML declaration for validation (it's not critical for parsing)
+        cleaned_input = input.sub(/\A\s*<\?xml[^?]*\?>\s*/, "")
+
+        if xhtml?(cleaned_input)
+          validate_xhtml!(cleaned_input)
+        else
+          validate_html5!(cleaned_input)
+        end
+      end
+
+      # Check if HTML is XHTML
+      #
+      # @param html [String] The HTML string to check
+      # @return [Boolean] true if XHTML, false otherwise
+      def self.xhtml?(html)
+        html.include?("XHTML") ||
+          html.include?('xmlns="http://www.w3.org/1999/xhtml"') ||
+          html.match?(/xmlns:\w+/)
+      end
+
+      # Validate XHTML input using XML strict parsing
+      #
+      # @param input [String] The XHTML string to validate
+      # @raise [Canon::ValidationError] If XHTML is malformed
+      # @return [void]
+      def self.validate_xhtml!(input)
+        Nokogiri::XML(input) do |config|
+          config.strict.nonet
+        end
+      rescue Nokogiri::XML::SyntaxError => e
+        location = extract_location(e)
+        raise Canon::ValidationError.new(
+          e.message.split("\n").first,
+          format: :html,
+          line: location[:line],
+          column: location[:column],
+          details: "XHTML validation failed: #{extract_details(e)}",
+        )
+      end
+
+      # Validate HTML5 input
+      #
+      # @param input [String] The HTML5 string to validate
+      # @raise [Canon::ValidationError] If HTML5 is malformed
+      # @return [void]
+      def self.validate_html5!(input)
+        doc = Nokogiri::HTML5(input, max_errors: 100)
+
+        # Check for parse errors
+        return unless doc.errors.any?
+
+        # Find first significant error (level 2 = error, level 1 = warning)
+        # Filter out doctype warnings and other non-critical issues
+        significant_errors = doc.errors.select do |e|
+          e.level >= 2 && !doctype_or_warning?(e)
+        end
+
+        return if significant_errors.empty?
+
+        error = significant_errors.first
+        location = extract_location(error)
+        raise Canon::ValidationError.new(
+          error.message,
+          format: :html,
+          line: location[:line],
+          column: location[:column],
+          details: build_error_details(significant_errors),
+        )
+      end
+
+      # Extract additional error details
+      #
+      # @param error [Nokogiri::XML::SyntaxError] The syntax error
+      # @return [String, nil] Additional details about the error
+      def self.extract_details(error)
+        return nil unless error.respond_to?(:errors)
+
+        details = error.errors.map(&:message).reject do |msg|
+          msg == error.message
+        end
+        details.join("; ") unless details.empty?
+      end
+
+      # Build error details from multiple errors
+      #
+      # @param errors [Array<Nokogiri::XML::SyntaxError>] Array of errors
+      # @return [String, nil] Combined error details
+      def self.build_error_details(errors)
+        return nil if errors.size <= 1
+
+        significant = errors.select { |e| e.level >= 2 }
+        return nil if significant.empty?
+
+        details = significant[1..3].map do |e|
+          loc = extract_location(e)
+          msg = e.message
+          msg += " (line #{loc[:line]})" if loc[:line]
+          msg
+        end
+        details.join("; ")
+      end
+
+      # Check if error is a doctype or other non-critical warning
+      #
+      # @param error [Nokogiri::XML::SyntaxError] The error to check
+      # @return [Boolean] true if error is non-critical
+      def self.doctype_or_warning?(error)
+        error.message.match?(/doctype|Expected a doctype token/i)
+      end
+
+      private_class_method :xhtml?, :validate_xhtml!, :validate_html5!,
+                           :extract_details, :build_error_details,
+                           :doctype_or_warning?
+    end
+  end
+end

data/lib/canon/validators/json_validator.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "base_validator"
+
+module Canon
+  module Validators
+    # Validator for JSON input
+    #
+    # Validates JSON input using Ruby's JSON parser.
+    # Raises detailed ValidationError with position information
+    # when malformed JSON is detected.
+    class JsonValidator < BaseValidator
+      # Validate JSON input
+      #
+      # @param input [String] The JSON string to validate
+      # @raise [Canon::ValidationError] If JSON is malformed
+      # @return [void]
+      def self.validate!(input)
+        return if input.nil? || input.strip.empty?
+
+        JSON.parse(input)
+      rescue JSON::ParserError => e
+        # Extract position from error message
+        position = extract_position(e.message)
+
+        raise Canon::ValidationError.new(
+          clean_error_message(e.message),
+          format: :json,
+          line: position[:line],
+          column: position[:column],
+          details: extract_context(input, position),
+        )
+      end
+
+      # Extract line and column from JSON error message
+      #
+      # @param message [String] The error message
+      # @return [Hash] Hash with :line and :column keys
+      def self.extract_position(message)
+        line = nil
+        column = nil
+
+        # JSON errors often report character position
+        if message =~ /at line (\d+), column (\d+)/i
+          line = ::Regexp.last_match(1).to_i
+          column = ::Regexp.last_match(2).to_i
+        elsif /at character offset (\d+)/i.match?(message)
+          # For character offset, we can't easily determine line/column
+          # without parsing the input
+        end
+
+        { line: line, column: column }
+      end
+
+      # Clean error message by removing technical details
+      #
+      # @param message [String] The raw error message
+      # @return [String] Cleaned error message
+      def self.clean_error_message(message)
+        # Remove 'unexpected token' technical details and keep main message
+        message.split(" at ").first.strip
+      end
+
+      # Extract context around the error position
+      #
+      # @param input [String] The input JSON string
+      # @param position [Hash] Position hash with :line key
+      # @return [String, nil] Context snippet around the error
+      def self.extract_context(input, position)
+        return nil unless position[:line]
+
+        lines = input.split("\n")
+        line_idx = position[:line] - 1
+        return nil if line_idx.negative? || line_idx >= lines.size
+
+        # Get the problematic line and surrounding lines
+        start_idx = [0, line_idx - 1].max
+        end_idx = [lines.size - 1, line_idx + 1].min
+
+        context_lines = lines[start_idx..end_idx]
+        "Near: #{context_lines.join(' ')}"
+      end
+
+      private_class_method :extract_position, :clean_error_message,
+                           :extract_context
+    end
+  end
+end

data/lib/canon/validators/xml_validator.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require_relative "base_validator"
+
+module Canon
+  module Validators
+    # Validator for XML input
+    #
+    # Validates XML input using Nokogiri's strict parsing mode.
+    # Raises detailed ValidationError with line and column information
+    # when malformed XML is detected.
+    class XmlValidator < BaseValidator
+      # Validate XML input
+      #
+      # @param input [String] The XML string to validate
+      # @raise [Canon::ValidationError] If XML is malformed
+      # @return [void]
+      def self.validate!(input)
+        return if input.nil? || input.strip.empty?
+
+        # Parse with strict error handling
+        Nokogiri::XML(input) do |config|
+          config.strict.nonet
+        end
+      rescue Nokogiri::XML::SyntaxError => e
+        location = extract_location(e)
+        raise Canon::ValidationError.new(
+          e.message.split("\n").first,
+          format: :xml,
+          line: location[:line],
+          column: location[:column],
+          details: extract_details(e),
+        )
+      end
+
+      # Extract additional error details
+      #
+      # @param error [Nokogiri::XML::SyntaxError] The syntax error
+      # @return [String, nil] Additional details about the error
+      def self.extract_details(error)
+        return nil unless error.respond_to?(:errors)
+
+        details = error.errors.map(&:message).reject do |msg|
+          msg == error.message
+        end
+        details.join("; ") unless details.empty?
+      end
+
+      private_class_method :extract_details
+    end
+  end
+end