canon 0.3.47 → 0.3.49

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8180f10b0965070c408985ca44868fc14ae2256f24dac607492470aea7e5d076
-  data.tar.gz: e50498b713b972237a67af3b3f5c2cd5fb0cf1cbc3fef0dbb57f628810ce2341
+  metadata.gz: 8f3f2bed07760530a3f122f18e184ac0e925db9d6551bacc46ef896552fb79ce
+  data.tar.gz: 4de5e38b9be98f354a843bb3fdd1c725534fab28f6078cbf95a7c278d0c2596b
 SHA512:
-  metadata.gz: 52c5eb3fcb8ab3e09c7de5b8b7120f2baad191467aeccab6154254cd0007128f76ae2f5dbd26102abf19c3cf9f289f3c0445db88917562d7b7edafe9aef7ae5b
-  data.tar.gz: 373032bcba62f9685c41f09bb0d3dce294c50fa8785252e3737231a67f9a0fdfdb5372c85f3b28da5983faf39d4cdf89723dfae8397969511d2688afecaf3418
+  metadata.gz: '002904526d2626e462005b4a3627540a1d6587c458b60adb871ad03134054485c2712707579106f727fa00066b213d8db903f96be5d695470aed08ec82157461'
+  data.tar.gz: 537566ace8ff29b3124bbd9fd2789250d95d539de60b0e8ba89a3d5ebf83dee871fe0e7525d8d76381286f8adf71886957a3c4a29b1887f861fc0201b44bd862

data/CLAUDE.md

@@ -145,7 +145,7 @@ Engine A/B testing: `CANON_XML_BACKEND=nokogiri bundle exec rspec` (or `=moxml`
 
 ### C14N Engines
 
-`Canon::Xml::C14n.canonicalize` stays on canon's Ruby C14N 1.1 processor by default. leptris' native C-side C14N 1.1 is ~50x faster on large documents and byte-identical on the main corpus, but diverges from the spec on edge cases (attribute ordering, prefix preservation, `>`/tab escaping, document-level PIs — leptris#1015, all pinned in `spec/canon/xml/c14n_engine_parity_spec.rb`). `CANON_C14N_BACKEND=leptris` opts in; when the parity gate runs clean the default flips. `canonicalize_subset` and `with_comments: true` always use the Ruby processor.
+`Canon::Xml::C14n.canonicalize` uses leptris' native C-side C14N 1.1 by DEFAULT (since libleptris 1.9.178 / gem 1.9.178.0) — 23x faster than the Ruby processor through canon's API (1MB document). The native parse runs `noblanks: true` (compact bytes, matching the Ruby lane's product), relative namespace URIs raise identically, and document-level PIs serialize in spec-correct document order (the Ruby processor's root-first order was non-conformant for prolog PIs). `CANON_C14N_BACKEND=ruby` forces the Ruby processor. `canonicalize_subset` and `with_comments: true` always use the Ruby processor. The parity spec (`spec/canon/xml/c14n_engine_parity_spec.rb`) pins byte-identity; its pending cases track intentional divergences (document-order PIs) and the canon-side CR-reference finding.
 
 ### YAML Engines
 

data/lib/canon/diff/diff_node_enricher.rb

@@ -41,6 +41,11 @@ module Canon
         # Track occurrences for text_content dimension to find correct element instance
         @text_occurrence1 = Hash.new(0)
         @text_occurrence2 = Hash.new(0)
+        # Opener-offset caches: one scan per unique element name per
+        # document replaces the per-call regex walk (which was also
+        # quadratic on repeated element names).
+        @opener_offsets1 = {}
+        @opener_offsets2 = {}
       end
 
       def enrich
@@ -1461,27 +1466,44 @@ range_start, range_end)
       # tag (no inside-the-element correction — see
       # locate_element_at_index).
       def count_elements_before_position_open(text, char_offset, opener)
-        count = 0
-        pos = 0
-        while (hit = text.index(opener, pos)) && hit < char_offset
-          count += 1
-          pos = hit + 1
-        end
-        count
+        count_openers_before(opener_offsets(text, opener), char_offset)
       end
 
       def count_elements_before_position(text, char_offset, element_name)
-        # Index loop instead of copying the prefix per call — the
-        # copy was O(offset) on every occurrence check.
-        opener = /<#{element_name}[>\s]/
-        count = 0
+        # Subtract 1 because the count includes the element we are inside
+        [count_openers_before(opener_offsets(text, opener_for(element_name)),
+                              char_offset) - 1, 0].max
+      end
+
+      # Count of opener offsets strictly before char_offset — binary
+      # search over the cached, ascending offset array.
+      def count_openers_before(offsets, char_offset)
+        idx = offsets.bsearch_index { |offset| offset >= char_offset }
+        idx || offsets.length
+      end
+
+      # All opener offsets for one opener regex in one document,
+      # cached per text (one linear scan per unique element name per
+      # document — callers previously re-scanned per occurrence
+      # check, which was also quadratic on repeated element names).
+      def opener_offsets(text, opener)
+        if text.equal?(@text1)
+          (@opener_offsets1[opener.source] ||= scan_opener_offsets(text, opener))
+        elsif text.equal?(@text2)
+          (@opener_offsets2[opener.source] ||= scan_opener_offsets(text, opener))
+        else
+          scan_opener_offsets(text, opener)
+        end
+      end
+
+      def scan_opener_offsets(text, opener)
+        offsets = []
         pos = 0
-        while (hit = text.index(opener, pos)) && hit < char_offset
-          count += 1
+        while (hit = text.index(opener, pos))
+          offsets << hit
           pos = hit + 1
         end
-        # Subtract 1 because the count includes the element we are inside
-        [count - 1, 0].max
+        offsets
       end
     end
   end

data/lib/canon/version.rb

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

data/lib/canon/xml/c14n.rb

@@ -23,39 +23,37 @@ module Canon
       end
 
       # leptris' C-side C14N 1.1 — 23x faster than the Ruby processor
-      # through canon's own API (1MB document) and byte-identical on
-      # the parity corpus, but OPT-IN (CANON_C14N_BACKEND=leptris)
-      # pending three families verified against libxml2 ground truth
-      # (leptris#1096 follow-up): (1) whitespace-only text between
-      # elements is preserved — the Ruby lane's parse drops it and
-      # compact bytes are canon's product for every pretty-printed
-      # document; (2) whitespace-only processing-instruction data is
-      # retained (libxml2 drops it); (3) document-level nodes carry
-      # no "\n" separators (the Ruby lane, like libxml2, inserts
-      # them). libleptris 1.9.176/177 (gem 1.9.177.0) closed the
-      # earlier families — attribute ordering, prefix loss and
-      # rebinding, `>`/TAB escaping, redundant namespace
-      # redeclarations, xmlns:xml omission — and document-level PIs
-      # now serialize in document order (the Ruby processor's
-      # root-first order is non-conformant for prolog PIs).
-      # Relative namespace URIs raise exactly as the Ruby lane does.
-      # Comments mode keeps the Ruby path (the native seam exposes no
-      # with-comments form).
+      # through canon's own API (1MB document) and the DEFAULT lane
+      # since libleptris 1.9.178 (gem 1.9.178.0): the leptris#1117
+      # families are closed by the native parse-policy knob
+      # (`noblanks: true` — same compact bytes as the Ruby lane's
+      # parse) and by the canonicalizer itself (whitespace-only PI
+      # data dropped, document-level "\n" separators inserted). The
+      # one residual byte difference vs the Ruby lane is intentional
+      # and a correctness improvement: document-level PIs now
+      # serialize in document order (REC-xml-c14n 2.1) instead of
+      # the Ruby lane's non-conformant root-first reorder. Relative
+      # namespace URIs raise exactly as the Ruby lane does.
+      # Comments mode keeps the Ruby path regardless (the native
+      # seam exposes no with-comments form). CANON_C14N_BACKEND=ruby
+      # forces the stdlib lane.
       def self.native_canonicalize(xml, with_comments)
         return nil if with_comments
         return nil if RUBY_ENGINE == "opal"
-        return nil unless ENV["CANON_C14N_BACKEND"].to_s.casecmp("leptris").zero?
+        return nil if ENV["CANON_C14N_BACKEND"].to_s.casecmp("ruby").zero?
         return nil unless Canon::XmlBackend.moxml? &&
           Canon::XmlParsing.moxml_adapter_name == :leptris
         return nil unless native_c14n_available?
 
         validate_relative_namespaces!(xml)
 
-        doc = Canon::XmlParsing.moxml_context.parse(xml, readonly: true,
-                                                         strict: false)
+        doc = Canon::XmlParsing.moxml_context.parse(xml,
+                                                    readonly: true,
+                                                    strict: false,
+                                                    noblanks: true)
         begin
-          doc.native.canonicalize(::Leptris::XML::FFI::C14N_1_1, nil,
-                                  mode: ::Leptris::XML::FFI::C14N_MODE_CANONICAL)
+          doc.native.c14n(::Leptris::XML::FFI::C14N_1_1, nil,
+                          mode: ::Leptris::XML::FFI::C14N_MODE_CANONICAL)
         ensure
           doc.free
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.47
+  version: 0.3.49
 platform: ruby
 authors:
 - Ribose Inc.