canon 0.3.26 → 0.3.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '05685ad043ad0a5465f4e065c26cf35ad1b453511ce347a56e60d5a5153e731f'
-  data.tar.gz: 864587a2ddf54edd3f40d71676882b255904dfe6f46ee41a330ef8117ceddfed
+  metadata.gz: d8de5d7008a348037ef44fdd8bd5ee722e8077e058ab1e53cd2995b0dd5f0e2c
+  data.tar.gz: 930b0efd7c7302968a6ff2f4fd9af8a6261a1a57fc71707d9206333a380f47a8
 SHA512:
-  metadata.gz: 6e568174aeaf605650e7eb64267afddbe30fd4399b82c032757e60177631b75663b0cf388d16e2fbaddea774ea703cb4c88f3e11ac8307ee1a75a3ea6f6530cc
-  data.tar.gz: 5af9aded692f6b909ffd1eb50bb9e96c851b8ca98844a397ceec11f8a2eede33437f99d4df15a2870beee56954924d2fd1ec061b6cb4523d2204fa07524f0710
+  metadata.gz: 570bd7072c65d9c87316becd43334255bb176ee4260c1d40738cd51ee3d030c4ea3df9d93e923a2f6062c493271fb122bb252e1f41c6c0e40836d7fbe675fd5b
+  data.tar.gz: a7d60c235f74cdf466a35b4ef6204c9943d306a1167dead26123314326936f90f7d96a5d2ee3bd2ace308556655c2e6492d2beb2ebab25933d4ce796dfd84e9f

data/README.adoc

@@ -12,9 +12,19 @@ Key features:
 
 * **Format support**: XML, HTML, JSON, YAML
 * **Canonicalization**: W3C XML C14N 1.1, sorted JSON/YAML keys
-* **Semantic comparison**: Compare meaning, not formatting
+* **Semantic comparison**: Compare meaning, not formatting — attributes by
+  expanded name (namespace URI + local name), prefixes never affect results
 * **Multiple interfaces**: Ruby API, CLI, RSpec matchers
 * **Smart diff output**: By-line or by-object modes with syntax highlighting
+* **Fast native engines, zero mandatory C deps**:
+** XML on https://github.com/leptris/leptris[libleptris] (via moxml) whenever
+   installed — Nokogiri otherwise and for HTML; both byte-compatible, engine
+   parity is spec-gated
+** JSON on https://github.com/leptris/yeptris[libyeptris]' strict JSON surface
+   whenever the native materializer is installed (`gem install yeptris` —
+   platform gems, zero compilation), the stdlib JSON extension otherwise
+** YAML on yeptris opt-in (`CANON_YAML_BACKEND=yeptris`, ~3x Psych loads);
+   Psych otherwise
 
 == When to use formatting vs comparison
 
@@ -957,10 +967,25 @@ bundle exec rake performance:yaml
 * **XML/HTML Comparison**: Identical, similar, different documents
 * **Format Canonicalization**: XML C14N, JSON, YAML
 
+=== Engines
+
+Canon is engine-agnostic across its formats:
+
+* **XML**: libleptris via moxml whenever installed (parse, comparison, C14N,
+  pretty-printing); raw Nokogiri otherwise, and always Nokogiri for HTML.
+  `CANON_XML_BACKEND=nokogiri|moxml` forces either engine; parity between the
+  two is spec-gated (`spec/canon/xml/engine_parity_spec.rb`).
+* **JSON**: yeptris' strict JSON surface when the native materializer is
+  installed (platform gems — zero compilation), the stdlib JSON extension
+  otherwise. `CANON_YAML_BACKEND=psych` forces stdlib.
+* **YAML**: Psych by default; yeptris (≈3x loads) behind
+  `CANON_YAML_BACKEND=yeptris`. Parity is spec-gated
+  (`spec/canon/yaml_engine_parity_spec.rb`).
+
 === SAX Parser
 
 Canon includes a SAX-based XML parser (`Canon::Xml::SaxBuilder`) that provides
-significantly faster XML parsing by avoiding intermediate Nokogiri DOM trees.
+significantly faster XML parsing by avoiding intermediate engine DOM trees.
 
 [source,ruby]
 ----

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

@@ -34,14 +34,24 @@ module Canon
         # @param filtered [Hash] Output hash to populate
         def self.filter_array_attributes(attributes, opts, match_opts, filtered)
           attributes.each do |attr|
-            name = attr.name
+            # Expanded name (XML Namespaces 1.0 §5.2/§5.3): an
+            # unprefixed attribute is in NO namespace — {no-ns}srsName
+            # and {uri}srsName are different attributes, and two
+            # prefixes bound to the same URI are the same attribute.
+            # Local-name keys conflated qualified with unqualified
+            # attributes whenever the prefix matched the element's
+            # (issue #155).
+            name = expanded_attribute_name(attr)
             value = attr.value
 
             # Skip namespace declarations - they're handled separately
-            next if namespace_declaration?(name)
+            next if namespace_declaration?(attr.name)
 
-            # Skip if attribute name should be ignored
-            next if ignore_by_name?(name, opts)
+            # Skip if attribute name should be ignored — by local name
+            # (user-facing list) or expanded key, so ignore lists keep
+            # working against both forms.
+            next if ignore_by_name?(attr.name, opts) ||
+              ignore_by_name?(name, opts)
 
             # Skip if attribute content should be ignored
             next if ignore_by_content?(value, opts)
@@ -54,6 +64,26 @@ module Canon
           end
         end
 
+        # Expanded attribute key: "{namespace-uri}local-name", or the
+        # bare local name when the attribute is in no namespace.
+        # Prefixed-but-unresolvable attributes (namespace-invalid
+        # documents — an undeclared prefix has no expanded name) fall
+        # back to the local name: recovery comparison cannot do better.
+        def self.expanded_attribute_name(attr)
+          case attr
+          when Canon::Xml::Nodes::AttributeNode
+            uri = attr.namespace_uri
+            attr.prefix
+          when defined?(Nokogiri) && Nokogiri::XML::Attr
+            uri = attr.namespace&.href
+            attr.namespace&.prefix
+          else
+            uri = attr.namespace_uri
+            nil
+          end
+          uri && !uri.empty? ? "{#{uri}}#{attr.name}" : attr.name
+        end
+
         # Filter hash-format attributes (Nokogiri/Moxml)
         #
         # @param attributes [Hash] Hash-like attributes

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

@@ -33,82 +33,11 @@ module Canon
         # @return [String] Formatted diff
         def format(doc1, doc2)
           compute_line_num_width(doc1, doc2)
-          # If we have DiffNodes from comparison, use the new pipeline
-          if @differences&.any?(Canon::Diff::DiffNode)
-            # Check if we should skip based on show_diffs setting
-            if should_skip_diff_display?
-              return ""
-            end
-
-            # Use new pipeline when DiffNodes available
-            return format_with_pipeline(doc1, doc2)
-          end
-
-          # LEGACY: Fall back to old DOM-based behavior
-          # Check if we should show any diffs based on differences array
-          if should_skip_diff_display?
-            return ""
-          end
-
-          output = []
-
-          begin
-            # Parse to DOM using HTML parser
-            root1 = Canon::Html::DataModel.from_html(doc1,
-                                                     version: @html_version)
-            root2 = Canon::Html::DataModel.from_html(doc2,
-                                                     version: @html_version)
-
-            # Match elements semantically
-            matcher = Canon::Xml::ElementMatcher.new
-            matches = matcher.match_trees(root1, root2)
-
-            # Pretty-print HTML for line mapping
-            pretty_printer = Canon::PrettyPrinter::Html.new(indent: 2)
-            pretty1 = pretty_printer.format(doc1)
-            pretty2 = pretty_printer.format(doc2)
-
-            # Build line range maps using pretty-printed documents
-            mapper1 = Canon::Xml::LineRangeMapper.new(indent: 2)
-            mapper2 = Canon::Xml::LineRangeMapper.new(indent: 2)
-            map1 = mapper1.build_map(root1, pretty1)
-            map2 = mapper2.build_map(root2, pretty2)
-
-            # Use pretty-printed document lines for display
-            lines1 = pretty1.split("\n")
-            lines2 = pretty2.split("\n")
-
-            # Display diffs based on element matches
-            result = format_element_matches(matches, map1, map2, lines1, lines2)
-            output << result
-          rescue StandardError => e
-            # Fall back to simple diff on error
-            output << colorize("Warning: DOM parsing failed, using simple diff",
-                               :yellow)
-            output << colorize("Error: #{e.class}: #{e.message}", :red)
+          return "" if should_skip_diff_display?
 
-            # Include relevant backtrace lines
-            relevant_trace = e.backtrace.select do |line|
-              line.include?("canon")
-            end.take(3)
-            unless relevant_trace.empty?
-              output << colorize("Backtrace:", :yellow)
-              relevant_trace.each do |line|
-                output << colorize("  #{line}", :yellow)
-              end
-            end
-
-            output << ""
-            simple = SimpleFormatter.new(
-              use_color: @use_color,
-              context_lines: @context_lines,
-              diff_grouping_lines: @diff_grouping_lines,
-              visualization_map: @visualization_map,
-            )
-            output << simple.format(doc1, doc2)
-          end
-
-          output.join("\n")
+          # The DiffNode pipeline is the only renderer: without
+          # DiffNodes there is nothing to report (#84).
+          format_with_pipeline(doc1, doc2)
         end
 
         # Format using new DiffReportBuilder pipeline
@@ -260,227 +189,6 @@ module Canon
 
           output.join("\n")
         end
-
-        private
-
-        # Format element matches for display
-        def format_element_matches(matches, map1, map2, lines1, lines2)
-          output = []
-
-          # Detect non-ASCII characters in the diff
-          all_text = (lines1 + lines2).join
-          non_ascii = Legend.detect_non_ascii(all_text, @visualization_map)
-
-          # Add Unicode legend if any non-ASCII characters detected
-          unless non_ascii.empty?
-            output << Legend.build_legend(non_ascii, use_color: @use_color)
-            output << ""
-          end
-
-          # Build a set of elements to skip (children of parents showing diffs)
-          elements_to_skip = build_skip_set(matches, map1, map2, lines1,
-                                            lines2)
-
-          # Build a set of children of matched parents
-          children_of_matched_parents = build_children_set(matches)
-
-          # Collect diff sections with metadata
-          diff_sections = collect_diff_sections(matches, map1, map2, lines1,
-                                                lines2, elements_to_skip,
-                                                children_of_matched_parents)
-
-          # Sort by line number
-          diff_sections.sort_by! do |section|
-            section[:start_line1] || section[:start_line2] || 0
-          end
-
-          # Group diffs by proximity if diff_grouping_lines is set
-          formatted_diffs = if @diff_grouping_lines
-                              groups = group_diff_sections(diff_sections,
-                                                           @diff_grouping_lines)
-                              format_diff_groups(groups)
-                            else
-                              diff_sections.filter_map do |s|
-                                s[:formatted]
-                              end.join("\n\n")
-                            end
-
-          output << formatted_diffs
-          output.join("\n")
-        end
-
-        # Build set of elements to skip (children with parents showing diffs)
-        def build_skip_set(matches, map1, map2, lines1, lines2)
-          elements_to_skip = Set.new
-          elements_with_diffs = Set.new
-
-          # Build set of element pairs that have semantic diffs
-          build_elements_with_semantic_diffs_set
-
-          # First pass: identify elements with line differences
-          # (semantic filtering happens in collect_diff_sections)
-          matches.each do |match|
-            next unless match.status == :matched
-
-            range1 = map1[match.elem1]
-            range2 = map2[match.elem2]
-            next unless range1 && range2
-
-            elem_lines1 = lines1[range1.start_line..range1.end_line]
-            elem_lines2 = lines2[range2.start_line..range2.end_line]
-
-            # Add if there are line diffs
-            # Semantic filtering is done in collect_diff_sections
-            if elem_lines1 != elem_lines2
-              elements_with_diffs.add(match.elem1)
-            end
-          end
-
-          # Second pass: skip children of elements with diffs
-          elements_with_diffs.each do |elem|
-            current = Canon::Comparison::NodeInspector.parent(elem)
-            while current
-              if Canon::Comparison::NodeInspector.element_node?(current) &&
-                  elements_with_diffs.include?(current)
-                elements_to_skip.add(elem)
-                break
-              end
-              current = Canon::Comparison::NodeInspector.parent(current)
-            end
-          end
-
-          elements_to_skip
-        end
-
-        # Collect diff sections with metadata
-        def collect_diff_sections(matches, map1, map2, lines1, lines2,
-                                   elements_to_skip, _children_of_matched_parents)
-          diff_sections = []
-          no_range_count = 0
-          no_diff_count = 0
-
-          # If there are NO semantic diffs, don't show any matched elements
-          # (all text diffs were normalized away)
-          elements_with_semantic_diffs = build_elements_with_semantic_diffs_set
-
-          matches.each do |match|
-            case match.status
-            when :matched
-              next if elements_to_skip.include?(match.elem1)
-
-              # Only apply semantic filtering if we have DiffNode objects
-              # (when called standalone or without DiffNodes, show all diffs)
-              if !@differences.nil? && !@differences.empty? && @differences.any?(Canon::Diff::DiffNode)
-                # Skip if no semantic diffs exist (all diffs were normalized)
-                next if elements_with_semantic_diffs.empty?
-
-                # Skip if this element has no semantic diffs in its subtree
-                next unless has_semantic_diff_in_subtree?(match.elem1,
-                                                          elements_with_semantic_diffs)
-              end
-
-              range1 = map1[match.elem1]
-              range2 = map2[match.elem2]
-              if !range1 || !range2
-                no_range_count += 1
-              end
-
-              section = format_matched_element_with_metadata(match, map1,
-                                                             map2, lines1,
-                                                             lines2)
-              if range1 && range2 && !section
-                no_diff_count += 1
-              end
-              diff_sections << section if section
-            when :deleted
-              # Don't skip deleted elements - they should always be shown
-              section = format_deleted_element_with_metadata(match, map1,
-                                                             lines1)
-              diff_sections << section if section
-            when :inserted
-              # Don't skip inserted elements - they should always be shown
-              section = format_inserted_element_with_metadata(match, map2,
-                                                              lines2)
-              diff_sections << section if section
-            end
-          end
-
-          diff_sections
-        end
-
-        # Format a matched element showing differences
-        def format_matched_element(match, map1, map2, lines1, lines2)
-          range1 = map1[match.elem1]
-          range2 = map2[match.elem2]
-          return nil unless range1 && range2
-
-          # Extract line ranges
-          elem_lines1 = lines1[range1.start_line..range1.end_line]
-          elem_lines2 = lines2[range2.start_line..range2.end_line]
-
-          # Skip if identical
-          return nil if elem_lines1 == elem_lines2
-
-          # Run line diff
-          diffs = ::Diff::LCS.sdiff(elem_lines1, elem_lines2)
-
-          # Identify diff blocks
-          diff_blocks = identify_diff_blocks(diffs)
-          return nil if diff_blocks.empty?
-
-          # Group into contexts
-          contexts = group_diff_blocks_into_contexts(diff_blocks,
-                                                     @diff_grouping_lines || 0)
-
-          # Expand with context lines
-          expanded_contexts = expand_contexts_with_context_lines(contexts,
-                                                                 @context_lines,
-                                                                 diffs.length)
-
-          # Format contexts
-          output = []
-          expanded_contexts.each_with_index do |context, idx|
-            output << "" if idx.positive?
-            output << format_context(context, diffs, range1.start_line,
-                                     range2.start_line)
-          end
-
-          output.join("\n")
-        end
-
-        # Format a deleted element
-        def format_deleted_element(match, map1, lines1)
-          range1 = map1[match.elem1]
-          return nil unless range1
-
-          output = []
-          path_str = match.path.join("/")
-          output << colorize("Element: #{path_str} [DELETED]", :red, :bold)
-
-          # Show all lines as deleted
-          (range1.start_line..range1.end_line).each do |i|
-            output << format_unified_line(i + 1, nil, "-", lines1[i], :red)
-          end
-
-          output.join("\n")
-        end
-
-        # Format an inserted element
-        def format_inserted_element(match, map2, lines2)
-          range2 = map2[match.elem2]
-          return nil unless range2
-
-          output = []
-          path_str = match.path.join("/")
-          output << colorize("Element: #{path_str} [INSERTED]", :green, :bold)
-
-          # Show all lines as inserted
-          (range2.start_line..range2.end_line).each do |i|
-            output << format_unified_line(nil, i + 1, "+", lines2[i], :green)
-          end
-
-          output.join("\n")
-        end
       end
     end
   end

data/lib/canon/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Canon
-  VERSION = "0.3.26"
+  VERSION = "0.3.27"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.26
+  version: 0.3.27
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-07 00:00:00.000000000 Z
+date: 2026-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs