canon 0.2.12 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48895efa0afcaaa525d8dcb9b04c1eb5969aeacd96c2e9b1f575383109229ce8
-  data.tar.gz: 12baa3b412f857b7b6038149f8344f2aa295d8b29e96ed2a0401e64010df5478
+  metadata.gz: 0d1f4de27225e068e0bc1a00b2b7b2d980847bf9027a21f042de148aae65926e
+  data.tar.gz: 4561eaa1efb9abcd541ec8da05f2e33df11859c35d6e5fe3f5fee9fa9d22af3d
 SHA512:
-  metadata.gz: 9d9e2d1bfce446d850e1c991e161991a5112bdccdcb3d57d28170ba9d3180bcd0897aba7c78c7c2e6fe3ec3f5d5ba0e295c9c80627fd0d3c9e2a8bfef1434125
-  data.tar.gz: ec91e939f8d39f21e9c93fcfea178241eb601c6e5f66e9956468bfef0bf480ba05d587b705d108f39de661e184d7aaae3e0b79cf4c907a2d0c98b062d4564ec5
+  metadata.gz: ee29ec80689f0c53771017dca13d48ba4c3162db98f0e3605c3198148035cd564d818b8e4c08728608ef3abd055231d82850f79f933d2206ec4a36d488c6faa6
+  data.tar.gz: 37ae2bd7e928265b8c54e4025ae73d7e8761ce6e28ee2933e005129bd218d7003a5d547103bba140e11e829ef4d45aa7ef41768766b302f6608814f08fb74983

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-06-15 09:49:31 UTC using RuboCop version 1.87.0.
+# on 2026-08-27 03:37:16 UTC using RuboCop version 1.90.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -11,13 +11,43 @@ Gemspec/RequiredRubyVersion:
   Exclude:
     - 'canon.gemspec'
 
-# Offense count: 1272
+# Offense count: 6
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AllowForAlignment, AllowBeforeTrailingComments, ForceEqualSignAlignment.
+Layout/ExtraSpacing:
+  Exclude:
+    - 'lib/canon/diff_formatter/theme.rb'
+    - 'lib/tasks/performance_report.rb'
+
+# Offense count: 4
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AllowMultipleStyles, EnforcedHashRocketStyle, EnforcedColonStyle, EnforcedLastArgumentHashStyle.
+# SupportedHashRocketStyles: key, separator, table
+# SupportedColonStyles: key, separator, table
+# SupportedLastArgumentHashStyles: always_inspect, always_ignore, ignore_implicit, ignore_explicit
+Layout/HashAlignment:
+  Exclude:
+    - 'lib/tasks/performance_report.rb'
+
+# Offense count: 1267
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
 # URISchemes: http, https
 Layout/LineLength:
   Enabled: false
 
+# Offense count: 4
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: AllowInHeredoc.
+Layout/TrailingWhitespace:
+  Exclude:
+    - 'lib/tasks/performance_report.rb'
+
+# Offense count: 1
+Lint/CopDirectiveSyntax:
+  Exclude:
+    - 'lib/canon/comparison/comparison_result.rb'
+
 # Offense count: 57
 # Configuration parameters: IgnoreLiteralBranches, IgnoreConstantBranches, IgnoreDuplicateElseBranch.
 Lint/DuplicateBranch:
@@ -32,7 +62,7 @@ Lint/EmptyConditionalBody:
     - 'spec/canon/comparison_spec.rb'
 
 # Offense count: 5
-# Configuration parameters: MaximumRangeSize.
+# Configuration parameters: MaxRangeSize.
 Lint/MissingCopEnableDirective:
   Exclude:
     - 'lib/canon/commands/format_command.rb'
@@ -62,12 +92,12 @@ Lint/UselessConstantScoping:
   Exclude:
     - 'lib/canon/diff_formatter/theme.rb'
 
-# Offense count: 298
+# Offense count: 296
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Enabled: false
 
-# Offense count: 29
+# Offense count: 28
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns, inherit_mode.
 # AllowedMethods: refine
 Metrics/BlockLength:
@@ -78,7 +108,7 @@ Metrics/BlockLength:
 Metrics/BlockNesting:
   Max: 4
 
-# Offense count: 261
+# Offense count: 262
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Enabled: false
@@ -197,7 +227,7 @@ RSpec/MultipleDescribes:
 RSpec/MultipleExpectations:
   Max: 15
 
-# Offense count: 93
+# Offense count: 92
 # Configuration parameters: AllowSubject.
 RSpec/MultipleMemoizedHelpers:
   Max: 16
@@ -257,6 +287,23 @@ RSpec/VerifiedDoubles:
     - 'spec/canon/diff_formatter/diff_detail_formatter_spec.rb'
     - 'spec/canon/tree_diff/operation_converter_spec.rb'
 
+# Offense count: 13
+# This cop supports unsafe autocorrection (--autocorrect-all).
+Style/DirectiveScope:
+  Exclude:
+    - 'lib/canon.rb'
+    - 'lib/canon/commands/diff_command.rb'
+    - 'lib/canon/comparison/comparison_result.rb'
+    - 'lib/canon/diff_formatter.rb'
+    - 'lib/canon/diff_formatter/by_line/base_formatter.rb'
+    - 'lib/canon/diff_formatter/by_line/html_formatter.rb'
+    - 'lib/canon/diff_formatter/by_line_formatter.rb'
+    - 'spec/canon/comparison/xml_comparator_spec.rb'
+    - 'spec/canon/comparison_spec.rb'
+    - 'spec/canon/diff_formatter/formatting_diff_visualization_spec.rb'
+    - 'spec/canon/fixtures_integrity_spec.rb'
+    - 'spec/canon/string_matcher_spec.rb'
+
 # Offense count: 1
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: EnforcedStyle, AllowComments.

data/CLAUDE.md

@@ -0,0 +1,197 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+Canon is a canonicalization, formatting, and comparison library for serialization formats (XML, HTML, JSON, YAML). It produces standardized forms suitable for comparison, testing, digital signatures, and human-readable output.
+
+## Common Commands
+
+```bash
+# Install dependencies
+bundle install
+
+# Run all tests
+bundle exec rake spec        # or: bundle exec rspec
+
+# Run a single test file
+bundle exec rspec spec/canon/comparison/xml_comparator_spec.rb
+
+# Run tests with specific pattern
+bundle exec rspec spec/canon/comparison --tag focus
+
+# Lint (rubocop)
+bundle exec rake rubocop
+
+# Default task (runs tests + lint)
+bundle exec rake
+
+# Performance benchmarks (takes ~5 minutes)
+bundle exec rake performance:run
+
+# Quick benchmark (~30 seconds)
+bundle exec rake performance:quick
+```
+
+### Size Limits
+
+Canon protects against pathologically large files with configurable limits:
+- **File size**: Default 5MB (`CANON_MAX_FILE_SIZE`)
+- **Node count**: Default 10,000 (`CANON_MAX_NODE_COUNT`)
+- **Diff output**: Default 10,000 lines (`CANON_MAX_DIFF_LINES`)
+
+```bash
+export CANON_MAX_FILE_SIZE=10485760  # 10MB
+export CANON_MAX_NODE_COUNT=50000
+bundle exec rspec
+```
+
+## Architecture
+
+### Core Entry Points
+
+- `lib/canon.rb` — Main module entry point. Provides `Canon.format`, `Canon.parse`, and shorthand methods like `Canon.format_xml`, `Canon.parse_json`. Defines `SUPPORTED_FORMATS = [:xml, :yaml, :json, :html, :html4, :html5, :string]`.
+- `lib/canon/cli.rb` — Thor-based CLI. Two commands: `canon format` (canonicalize/pretty-print) and `canon diff` (semantic comparison). See CLI long descriptions for full option documentation.
+- `exe/canon` — CLI entry point (runs the Thor CLI).
+
+### Two Comparison Algorithms — Distinct by Design
+
+Canon provides two **fundamentally different** comparison algorithms. They are NOT alternative implementations of the same approach. They use different methods, accept different options, produce different intermediate representations, and solve different problems. The pipelines must never be merged or "unified."
+
+#### DOM Algorithm (`diff_algorithm: :dom`, default)
+
+Position-based recursive tree walk. Compares children by position, attributes by name, namespace by URI.
+
+- **Method**: Positional recursive descent through the DOM tree
+- **Code path**: `dom_diff` → format comparators (`XmlComparator`, `HtmlComparator`, `JsonComparator`, `YamlComparator`)
+- **Algorithm-specific options**: Filtering (`ignore_children`, `ignore_text_nodes`, `ignore_attrs`, `ignore_nodes`, `ignore_attr_content`, `diff_children`)
+- **Intermediate representation**: Integer comparison-result codes (EQUIVALENT, MISSING_NODE, UNEQUAL_TEXT_CONTENTS, etc.)
+- **Output**: DiffNodes with diff codes
+- **Strength**: Deterministic positional comparison with fine-grained filtering; O(n) performance
+- **Location**: `lib/canon/comparison/`
+
+#### Semantic Tree Algorithm (`diff_algorithm: :semantic`)
+
+Signature-based tree matching. Computes node signatures, uses hash matching + similarity matching + structural propagation to find node correspondences even when nodes have moved. Produces insert/update/delete/move operations.
+
+- **Method**: Signature computation → three-phase matching (hash, similarity, structural propagation) → operation detection
+- **Code path**: `semantic_diff` → `TreeDiffIntegrator` → format adapters → `OperationConverter` → DiffNodes
+- **Algorithm-specific options**: Matching strategy (`similarity_threshold`, `hash_matching`, `similarity_matching`, `propagation`)
+- **Intermediate representation**: Operations (INSERT, DELETE, UPDATE, MOVE)
+- **Output**: Operations → converted to DiffNodes
+- **Strength**: Detects moved/renamed nodes and structural reorganization
+- **Location**: `lib/canon/tree_diff/`
+
+#### Shared Infrastructure (safe to consolidate)
+
+Both algorithms share these pipeline steps — this is the ONLY layer where consolidation makes sense:
+- Format detection (`FormatDetector`)
+- Config resolution (`Canon::Config`)
+- Match option resolution (`MatchOptions` resolvers, profiles, dimensions)
+- Preprocessing (`:none`, `:c14n`, `:normalize`, `:format`)
+- Parsing (format-specific `.parse` methods)
+- DiffNode output format — both produce DiffNodes
+- Diff formatting (`by_line` / `by_object`) — both feed into the same formatters
+
+#### NOT Shared (do NOT merge)
+
+- The comparison engines are entirely separate codepaths with no shared comparison logic
+- DOM-specific filtering options (`ignore_*`) have no meaning in semantic matching
+- Semantic-specific matching options (`similarity_threshold`, `hash_matching`) have no meaning in DOM comparison
+- Intermediate representations differ: diff codes vs tree-matching operations
+
+#### Two Activation Paths
+
+Semantic diff can be activated two ways:
+1. `diff_algorithm: :semantic` — caught by `Comparison.equivalent?`, routes to `Comparison.semantic_diff` (owns full pipeline end-to-end)
+2. `match: { semantic_diff: true }` — passes through `dom_diff` to the format comparator, which detects the flag and calls its own `perform_semantic_tree_diff`
+
+Path 1 is the primary API. Path 2 exists for direct comparator calls and is tested in `spec/canon/tree_diff/canon_integration_spec.rb`.
+
+### Four-Layer Architecture
+
+The comparison pipeline flows through four independent layers:
+
+1. **Preprocessing** — Optional normalization (`:none`, `:c14n`, `:normalize`, `:format`)
+2. **Algorithm Selection** — `:dom` (position-based, stable) or `:semantic` (signature-based, experimental)
+3. **Match Options** — Dimension behaviors per format (`:text_content`, `:structural_whitespace`, `:attribute_values`, etc.) controlled via profiles (`:strict`, `:spec_friendly`, `:rendered`, `:content_only`)
+4. **Diff Formatting** — `by_line` or `by_object` output mode
+
+**Critical distinction**: Do NOT use `Canon.format_xml` output for string comparison in tests. The formatting process changes line counts and causes false failures. Use `Canon::Comparison.equivalent?` or RSpec matchers instead.
+
+### Key Modules
+
+- `lib/canon/comparison/` — DOM-based comparison logic. `comparison.rb` is the main facade; comparators live in submodules. `MatchOptions::Xml` defines profiles (`:strict`, `:spec_friendly`, `:rendered`, `:content_only`) and per-dimension behaviors.
+- `lib/canon/tree_diff/` — Semantic tree diff engine. Separate from the DOM comparators. Integrates back into the main pipeline via `OperationConverter`.
+- `lib/canon/diff_formatter/` — Output formatters for diff results. Two modes: `by_line` (line-by-line, used for HTML and strings) and `by_object` (semantic/object-level, used for XML/JSON/YAML). Contains format-specific formatters for XML, HTML, JSON, YAML output.
+- `lib/canon/formatters/` — Pretty-printers for canonicalization/formatting (distinct from diff formatters). `XmlFormatter` supports Canonical XML (C14N).
+- `lib/canon/config.rb` — Global configuration with per-format settings (profiles, preprocessing, diff options). Read at runtime via `Canon::Config.instance`.
+- `lib/canon/rspec_matchers.rb` — RSpec matchers (`be_xml_equivalent_to`, `be_json_equivalent_to`, etc.). These delegate to `Canon::Comparison.equivalent?` with the global config. Automatically included in RSpec.
+- `lib/canon/xml/sax_builder.rb` — SAX-based canon-tree builder (~6x faster than DOM parsing for large documents). Engine-neutral; `lib/canon/xml/sax.rb` selects the driver (`NokogiriDriver` on CRuby, `MoxmlDriver` under Opal).
+
+### XML Engines
+
+Canon is engine-agnostic across three seams (MECE — one concern per module):
+
+- `Canon::XmlBackend` — XML engine selection. The default follows moxml's resolved adapter: **leptris whenever it is installed** (parse ~1.6x, serialize ~3.8x vs Nokogiri), raw Nokogiri otherwise (wrapping Nokogiri in moxml buys nothing — the wrapper adds 2-3x overhead). `:moxml` under Opal. `CANON_XML_BACKEND=nokogiri|moxml` forces either engine.
+- `Canon::XmlParsing` — the only place that talks to engines for XML parse/serialize (moxml parses pass `readonly: true` — canon never mutates engine documents); node type queries answer for ANY recognized node (Nokogiri or moxml) by type, never by active backend — user-supplied Nokogiri nodes keep working under the moxml engine.
+- `Canon::Html::NokogiriSupport` — HTML is always Nokogiri on CRuby (moxml has no HTML adapter, leptris no HTML parser); independent of the XML engine.
+- `Canon::Xml::Sax` — SAX driver selection: `NokogiriDriver` on CRuby (per-event C callbacks beat FFI SAX today), `MoxmlDriver` under Opal. The builder (`SaxBuilder`) is engine-neutral.
+
+Engine parity is complete through libleptris 1.9.8 / leptris-ruby 1.9.33 / moxml 0.5.12: attribute-value normalization, prolog/epilog PIs and comments, DTD ATTLIST defaults off by default (opt-in via `ParseOptions::DTDATTR`), PI-data whitespace matching libxml2, materialize with namespace declarations and a root-subtree-only record contract (moxml#140), readonly parse, deterministic `Document#free` (wired into `from_moxml_xml` — moxml#134). Canon's moxml conversion is record-based (`build_from_moxml` consumes `materialize` records — no per-node wrapper allocation; ~0.55x the Nokogiri conversion). `spec/canon/xml/engine_parity_spec.rb` is fully green. Remaining product gaps: moxml#129 (serializer byte parity — last blocker for pretty-printing on leptris) and leptris#594 (SAX at parity, not faster — the SAX driver stays Nokogiri). Pretty-printers (`PrettyPrinter::Xml`, `XmlNormalized`) deliberately stay on the Nokogiri pipeline — pretty-printed bytes are canon's product.
+
+Engine A/B testing: `CANON_XML_BACKEND=nokogiri bundle exec rspec` (or `=moxml` to force leptris when it isn't the resolved default). The default suite must stay green under BOTH values; the only expected pendings are the upstream-tracked ones. The benchmark header (`rake performance:quick`) reports the active engine.
+
+### Format Detection
+
+`Canon::Comparison::FormatDetector` auto-detects format from string content or object type (Moxml::Node → XML, Nokogiri::HTML → HTML, Hash → JSON, etc.). HTML4 vs HTML5 is determined by DOCTYPE.
+
+### Difference Result Format
+
+When `verbose: true`, comparison returns `Canon::Comparison::ComparisonResult` (or legacy Hash/Array). The result exposes:
+- `differences` — array of `DiffNode` objects
+- `equivalent?` — boolean
+- `preprocessed_strings` / `original_strings` — for diff display
+- `tree_diff_operations` / `tree_diff_statistics` / `tree_diff_matching` — only when using semantic algorithm
+
+### Difference Classification
+
+Differences are classified into three tiers:
+- **Normative** — Affects equivalence (documents not equivalent if different)
+- **Informative** — Tracked but doesn't affect equivalence
+- **Formatting-only** — Pure whitespace/formatting differences when normalized content matches
+
+Use `show_diffs: :normative` to display only equivalence-affecting differences.
+
+### Testing Notes
+
+- Tests use a shared fixture system (`spec/canon/fixtures/`). `spec/canon/fixtures_integrity_spec.rb` validates fixture references.
+- `spec/spec_helper.rb` disables monkey-patching and uses `expect` syntax.
+- Specs named `*_spec.rb` under `spec/canon/` map to `lib/canon/`.
+
+## Architectural Rules
+
+These rules are non-negotiable. Violations must be fixed before merge.
+
+### No `respond_to?` — use proper types
+
+`respond_to?` is a type-system bypass. It means the code does not know what it is working with, which is a failure of the model. Every object flowing through the comparison pipeline is one of a known set of types (`Canon::Xml::Node` and subclasses, `Nokogiri::XML::Node` and subclasses, `ComparisonResult`, `DiffNode`, `Hash`, `String`). Use `is_a?` for type dispatch, or better yet, design the classes so that polymorphism handles dispatch automatically (e.g., a shared base class or module providing the same interface).
+
+If you find yourself writing `respond_to?`, stop and introduce a proper type check or a shared protocol instead.
+
+### No `send` to bypass visibility — make the method public
+
+Using `send` to call a private method from another module or class is an encapsulation violation. If another object needs to call a method, that method must be public. Private means "internal implementation detail of this class" — if it is needed externally, it is not private. Either make it public or rethink the boundary.
+
+### No duplicated type-checking logic
+
+Backend-agnostic node queries (text node?, text content, whitespace check) must live in one place. The `Canon::Comparison::NodeInspector` module provides a single source of truth for cross-backend node type operations. All code that needs to query node properties must use it — never re-implement type dispatch inline.
+
+### Single module for cross-cutting utilities
+
+When multiple modules need the same capability (e.g., checking if a node is a whitespace-only text node), extract a single utility module. Do not duplicate the logic in each consumer.
+
+### Two algorithm pipelines must remain separate
+
+DOM and Semantic comparison are fundamentally different algorithms with different option sets, different intermediate representations, and different codepaths. Proposals to "unify" or "merge" the algorithm pipelines are always wrong. The correct approach is to extract shared infrastructure (format detection, config, parsing, output formatting) into reusable methods while keeping the algorithm cores independent. See "Two Comparison Algorithms — Distinct by Design" above.

data/lib/canon/commands/diff_command.rb

@@ -12,7 +12,7 @@ module Canon
       end
 
       # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable-next Metrics/AbcSize
       def run(file1, file2)
         # Detect formats
         format1 = @options[:format1] || @options[:format] || detect_format(file1)
@@ -98,7 +98,6 @@ module Canon
       rescue StandardError => e
         abort "Error processing files: #{e.message}"
       end
-      # rubocop:enable Metrics/AbcSize
       # rubocop:enable Metrics/MethodLength
 
       private

data/lib/canon/comparison/comparison_result.rb

@@ -162,13 +162,12 @@ show_diffs: :all, diff_mode: :separate, legacy_terminal: false)
       def summarize_diff_node(diff)
         parts = ["Not equivalent:"]
 
-        # rubocop:disable Layout/SpaceBeforeInterpolation,Style/ConditionalAssignment
+        # rubocop:disable-next Layout/SpaceBeforeInterpolation,Style/ConditionalAssignment
         if diff.path
           parts << "#{diff.reason} at #{diff.path}"
         else
           parts << diff.reason.to_s
         end
-        # rubocop:enable Layout/SpaceBeforeInterpolation,Style/ConditionalAssignment
 
         if diff.serialized_before && diff.serialized_after
           before_preview = truncate_preview(diff.serialized_before)

data/lib/canon/comparison/diff_node_builder.rb

@@ -145,7 +145,7 @@ module Canon
         when Canon::Xml::Node
           node.text_content
         else
-          if Canon::XmlBackend.nokogiri? && node.is_a?(Nokogiri::XML::Node)
+          if defined?(Nokogiri) && node.is_a?(Nokogiri::XML::Node)
             node.content.to_s
           elsif Canon::XmlParsing.xml_node?(node)
             Canon::XmlParsing.text_content(node)

data/lib/canon/comparison/format_detector.rb

@@ -22,39 +22,37 @@ module Canon
         # @param obj [Object] Object to detect format of
         # @return [Symbol] Format type (:xml, :html, :json, :yaml, :ruby_object, :string)
         def detect(obj)
-          if XmlBackend.moxml?
-            case obj
-            when Moxml::Node, Moxml::Document
-              :xml
-            when String
-              detect_string(obj)
-            when Hash, Array
-              :ruby_object
-            else
-              raise Canon::Error, "Unknown format for object: #{obj.class}"
-            end
+          case obj
+          when Moxml::Node, Moxml::Document
+            :xml
+          when String
+            detect_string(obj)
+          when Hash, Array
+            :ruby_object
           else
-            case obj
-            when Moxml::Node, Moxml::Document
-              :xml
-            when Nokogiri::HTML::DocumentFragment, Nokogiri::HTML5::DocumentFragment
-              :html
-            when Nokogiri::XML::DocumentFragment
-              obj.document&.html? ? :html : :xml
-            when Nokogiri::XML::Document, Nokogiri::XML::Node
-              obj.html? ? :html : :xml
-            when Nokogiri::HTML::Document, Nokogiri::HTML5::Document
-              :html
-            when String
-              detect_string(obj)
-            when Hash, Array
-              :ruby_object
-            else
-              raise Canon::Error, "Unknown format for object: #{obj.class}"
-            end
+            detect_nokogiri(obj)
           end
         end
 
+        # Nokogiri nodes arrive from user input regardless of the active
+        # XML engine, so detection is by node type (Opal never sees them —
+        # Nokogiri is not loaded there).
+        def detect_nokogiri(obj)
+          return :html if defined?(Nokogiri) && obj.is_a?(Nokogiri::HTML::DocumentFragment)
+          return :html if defined?(Nokogiri) && obj.is_a?(Nokogiri::HTML5::DocumentFragment)
+
+          if defined?(Nokogiri) && obj.is_a?(Nokogiri::XML::DocumentFragment)
+            return obj.document&.html? ? :html : :xml
+          end
+          if defined?(Nokogiri) && (obj.is_a?(Nokogiri::XML::Document) || obj.is_a?(Nokogiri::XML::Node))
+            return obj.html? ? :html : :xml
+          end
+          return :html if defined?(Nokogiri) && obj.is_a?(Nokogiri::HTML::Document)
+          return :html if defined?(Nokogiri) && obj.is_a?(Nokogiri::HTML5::Document)
+
+          raise Canon::Error, "Unknown format for object: #{obj.class}"
+        end
+
         # Detect the format of a string with caching
         #
         # @param str [String] String to detect format of

data/lib/canon/comparison/html_comparator.rb

@@ -167,7 +167,7 @@ module Canon
         # accepted: dom_diff routes html/html4/html5 input through
         # Nokogiri::HTML5.fragment per #118.
         def fragment_node?(node)
-          XmlBackend.document_fragment?(node)
+          Html::NokogiriSupport.document_fragment?(node)
         end
 
         # Compare children of document fragments using the shared
@@ -217,11 +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 XmlBackend.document_fragment?(node)
+          if Html::NokogiriSupport.document_fragment?(node)
             return node
           end
 
-          html_string = if XmlBackend.document_fragment?(node)
+          html_string = if Html::NokogiriSupport.document_fragment?(node)
                           node.to_s # Use to_s to avoid re-inserting meta tags
                         elsif node.is_a?(String)
                           node
@@ -229,7 +229,7 @@ module Canon
                           node.to_html
                         end
 
-          frag = XmlBackend.xml_fragment(
+          frag = Html::NokogiriSupport.xml_fragment(
             decode_html_named_entities(html_string),
           )
 
@@ -316,15 +316,15 @@ module Canon
 
             # Normalize HTML documents to fragments to avoid DTD differences
             # This ensures comparing string with document works correctly
-            if XmlBackend.html_document?(node)
+            if Html::NokogiriSupport.html_document?(node)
               root = node.at_css("html") || node.root
               if root
-                node = XmlBackend.xml_fragment(root.to_html)
+                node = Html::NokogiriSupport.xml_fragment(root.to_html)
               end
             end
 
             if %i[normalize format rendered].include?(preprocessing)
-              frag = XmlBackend.document_fragment?(node) ? node : XmlBackend.xml_fragment(node.to_html)
+              frag = Html::NokogiriSupport.document_fragment?(node) ? node : Html::NokogiriSupport.xml_fragment(node.to_html)
               normalize_html_style_script_comments(frag)
               if preprocessing == :rendered
                 normalize_rendered_whitespace(frag, match_opts)
@@ -372,7 +372,7 @@ module Canon
                           node
                         end
 
-          frag = XmlBackend.xml_fragment(
+          frag = Html::NokogiriSupport.xml_fragment(
             decode_html_named_entities(html_string),
           )
 
@@ -466,7 +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)
-          XmlBackend.html_version_from_node(node)
+          Html::NokogiriSupport.html_version_from_node(node)
         end
 
         # Serialize node to string for diff display
@@ -478,7 +478,7 @@ module Canon
           if node.is_a?(Canon::Xml::Node)
             Canon::Diff::NodeSerializer.serialize(node)
           elsif Canon::XmlParsing.xml_node?(node)
-            Canon::XmlBackend.nokogiri? ? node.to_html : Canon::XmlParsing.serialize(node)
+            defined?(Nokogiri) && node.is_a?(Nokogiri::XML::Node) ? node.to_html : Canon::XmlParsing.serialize(node)
           else
             node.to_s
           end
@@ -495,7 +495,7 @@ module Canon
           elsif html.is_a?(Canon::Xml::Node)
             Canon::Xml::DataModel.serialize(html)
           elsif Canon::XmlParsing.xml_node?(html)
-            Canon::XmlBackend.nokogiri? ? html.to_html : html.to_s
+            defined?(Nokogiri) && html.is_a?(Nokogiri::XML::Node) ? html.to_html : html.to_s
           else
             html.to_s
           end
@@ -671,16 +671,16 @@ compare_profile = nil)
         # XML documents typically have XML processing instructions or are
         # instances of Nokogiri::XML::Document (not HTML variants)
         def xml_document?(node)
-          return false if XmlBackend.html_document?(node) || XmlBackend.document_fragment?(node)
+          return false if Html::NokogiriSupport.html_document?(node) || Html::NokogiriSupport.document_fragment?(node)
 
-          if XmlBackend.nokogiri? && node.is_a?(Nokogiri::XML::Document) && node.children.any? do |child|
+          if defined?(Nokogiri) && node.is_a?(Nokogiri::XML::Document) && node.children.any? do |child|
             child.is_a?(Nokogiri::XML::ProcessingInstruction) && child.name == "xml"
           end
             return true
           end
 
           if (node.is_a?(Canon::Xml::Node) || Canon::XmlParsing.xml_node?(node)) &&
-              XmlBackend.nokogiri? && node.children.any? do |child|
+              defined?(Nokogiri) && node.children.any? do |child|
                 child.is_a?(Nokogiri::XML::ProcessingInstruction) && child.name == "xml"
               end
             return true

data/lib/canon/comparison/node_inspector.rb

@@ -35,11 +35,11 @@ module Canon
         return false unless node
         return node.node_type == :comment if node.is_a?(Canon::Xml::Node)
 
-        if XmlBackend.nokogiri?
-          return true if node.is_a?(Nokogiri::XML::Node) && node.comment?
+        if defined?(Nokogiri) && node.is_a?(Nokogiri::XML::Node)
+          return true if node.comment?
 
           # HTML comments are parsed as TEXT nodes by Nokogiri
-          if node.is_a?(Nokogiri::XML::Node) && node.text?
+          if node.text?
             text_stripped = text_content(node).to_s.strip.gsub("\\", "")
             return true if text_stripped.start_with?("<!--") && text_stripped.end_with?("-->")
           end
@@ -154,12 +154,8 @@ module Canon
         return [] if node.nil?
         return Array(node.parse_errors).map(&:to_s) if node.is_a?(Canon::Xml::Node)
 
-        if XmlBackend.nokogiri?
-          if node.is_a?(Nokogiri::XML::Document) || node.is_a?(Nokogiri::HTML5::Document)
-            Array(node.errors).map(&:to_s)
-          else
-            []
-          end
+        if defined?(Nokogiri) && (node.is_a?(Nokogiri::XML::Document) || node.is_a?(Nokogiri::HTML5::Document))
+          Array(node.errors).map(&:to_s)
         else
           []
         end

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

@@ -178,7 +178,7 @@ dimension:, differences:, **opts)
           when Canon::Xml::Nodes::ElementNode
             node.attribute_nodes
           else
-            if Canon::XmlBackend.nokogiri? && node.is_a?(Nokogiri::XML::Element)
+            if defined?(Nokogiri) && node.is_a?(Nokogiri::XML::Element)
               node.attribute_nodes
             else
               node.attributes

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

@@ -35,7 +35,7 @@ module Canon
           # Select parser backend
           resolved_parser = parser || resolve_parser_config
 
-          if resolved_parser == :sax && RUBY_ENGINE != "opal"
+          if resolved_parser == :sax
             Canon::Xml::SaxBuilder.parse(xml_string,
                                          preserve_whitespace: preserve_whitespace)
           else
@@ -94,7 +94,7 @@ parser: nil)
 
           resolved_parser = parser || resolve_parser_config
 
-          if resolved_parser == :sax && RUBY_ENGINE != "opal"
+          if resolved_parser == :sax
             Canon::Xml::SaxBuilder.parse(xml_str,
                                          preserve_whitespace: preserve_whitespace)
           else
@@ -109,7 +109,7 @@ parser: nil)
         def self.resolve_parser_config
           Canon::Config.instance.xml.diff.parser
         rescue StandardError
-          Canon::XmlBackend.nokogiri? ? :sax : :dom
+          :sax
         end
       end
     end

data/lib/canon/comparison/xml_node_comparison.rb

@@ -216,8 +216,8 @@ diff_children, differences)
         when Canon::Xml::Node
           node1.node_type == node2.node_type
         else
-          if Canon::XmlBackend.nokogiri?
-            node1.is_a?(Nokogiri::XML::Node) && node1.node_type == node2.node_type
+          if defined?(Nokogiri) && node1.is_a?(Nokogiri::XML::Node)
+            node1.node_type == node2.node_type
           else
             Canon::XmlParsing.xml_node?(node1) && Canon::XmlParsing.node_type(node1) == Canon::XmlParsing.node_type(node2)
           end

data/lib/canon/comparison.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "moxml"
-require "nokogiri" if Canon::XmlBackend.nokogiri?
+require "nokogiri" unless RUBY_ENGINE == "opal"
 
 module Canon
   # Comparison module for XML, HTML, JSON, and YAML documents

data/lib/canon/diff_formatter/by_line/base_formatter.rb

@@ -38,7 +38,7 @@ module Canon
           end
         end
 
-        # rubocop:disable Metrics/ParameterLists
+        # rubocop:disable-next Metrics/ParameterLists
         def initialize(use_color: true, context_lines: 3,
                        diff_grouping_lines: nil, visualization_map: nil,
                        show_diffs: :all, differences: [],
@@ -58,7 +58,6 @@ module Canon
           @theme = theme
           @character_visualization = character_visualization
         end
-        # rubocop:enable Metrics/ParameterLists
 
         # Get the resolved theme hash
         # @return [Hash] Theme hash