canon 0.3.60 → 0.3.62

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1cbc73f1d667885f1f989a9534d8123dbcc67ae7eda250cc24cba00e7ad24a7
-  data.tar.gz: b9a27d00c02f533c6679237e190eb7f6bc6532fe0f945957bdc5d521bb84217b
+  metadata.gz: c5ab88d04204cba8fb555ca3ebae0091a6a9d22fbb5e06e58974195e6bace30d
+  data.tar.gz: 3f952b1cb790351630ba1cb659e69492e67ff34ede453c98624877df4bb9b5f5
 SHA512:
-  metadata.gz: b060895cd58c7321db7d0640a02ca166f3efb9b5cb4c90d5fafb7d615b3faf6c73f4e29d42533d56ac9fd393e625bac473d9cd122273dc81b3598b0be76b86f9
-  data.tar.gz: 4b160273200d229151e61842bc994cd8e1d23f495107f495edde383b2fdccda2e9de150a65160d34c5e3177a7bf236282a6e1bb675c72b2bf667deb200e3dab4
+  metadata.gz: 6128ca89822cbf059a28e3f753d42a56e3ab40fd5ed98bb4cca9a467ae1124387b443747d0d480eb0da1bfd8358bc17e870dc4709e12c857b427bd35c56479c4
+  data.tar.gz: 1f6100fa01d92715eac814bb0538172b7ebc993cddbeaea34855631a76880cbf5b791403ba581c9b446a7903784aa1217542bc7c45ea18174b3e27eec2d7fb1d

data/lib/canon/comparison/xml_comparator.rb

@@ -201,11 +201,17 @@ module Canon
         # side answers both; any hit falls through to the pipeline.
         def verbose_report_proven_empty?(n1, n2, opts)
           return true unless opts[:verbose]
+
           # Identical input parses identically — differences and
-          # attribute order coincide by construction; only the SAX
-          # recover-error surface (parse-error banner, issue #130)
-          # needs its one scan.
-          return !Xml::Sax.probe(n1).saw_error? if n1 == n2
+          # attribute order coincide by construction. Recover errors
+          # ride the fingerprint's diag check when the engine exposes
+          # them (libleptris 1.9.205+, #1200); otherwise the one SAX
+          # scan covers the parse-error banner (issue #130).
+          if n1 == n2
+            return true if Xml::DigestGate.recover_diags_available?
+
+            return !Xml::Sax.probe(n1).saw_error?
+          end
 
           left = Xml::Sax.probe(n1)
           return false if left.saw_error?

data/lib/canon/diff/formatting_detector.rb

@@ -107,8 +107,14 @@ module Canon
       # case-insensitive (e.g., "UTF-8" equals "utf-8").
       # The standalone declaration in XML 1.1 is also case-insensitive.
       CASE_INSENSITIVE_ATTRS = %w[encoding standalone].freeze
-      QUOTE_CHARS = ["\"", "'"].freeze
-      SKIP_CHARS = [" ", "="].freeze
+      # Byte-level scan sets — the tokenizer reads via getbyte, whose
+      # Integer results allocate nothing (String#[] mints a 1-char
+      # string per character scanned).
+      NAME_END_BYTES = [32, 47, 62].freeze # space, /, >
+      SKIP_BYTES = [32, 61].freeze         # space, =
+      QUOTE_BYTES = [34, 39].freeze        # ", '
+      SPACE_BYTE = 32
+      EMPTY_CONTENT_RE = /\A[ \t\r\n\f\v]*\z/
 
       # Normalize attribute order within XML tags so that
       # <elem b="2" a="1"> compares equal to <elem a="1" b="2">.
@@ -121,19 +127,23 @@ module Canon
         i = 0
 
         while i < text.length
-          if text[i] == "<"
-            # Handle processing instruction <?...?>, comment <!--...-->,
-            # and regular tags
-            new_i, tag_output = process_tag(text, i)
-            if new_i
-              result << tag_output
-              i = new_i
-              next
-            end
+          lt = text.index("<", i)
+          if lt.nil?
+            result << text[i..]
+            break
+          end
+          result << text[i...lt] if lt > i
+
+          # Handle processing instruction <?...?>, comment <!--...-->,
+          # and regular tags
+          new_i, tag_output = process_tag(text, lt)
+          if new_i
+            result << tag_output
+            i = new_i
+          else
+            result << "<"
+            i = lt + 1
           end
-
-          result << text[i]
-          i += 1
         end
 
         result
@@ -178,57 +188,59 @@ module Canon
       # @param tag_content [String] Content between < and >
       # @return [Hash, nil] { name: String, attrs: Array<{name:, value:}> }
       def self.tokenize_tag_content(tag_content)
-        return nil if tag_content.strip.empty?
+        return nil if tag_content.match?(EMPTY_CONTENT_RE)
 
         i = 0
+        length = tag_content.length
         # Find tag name (first non-whitespace word)
-        i += 1 while i < tag_content.length && tag_content[i] == " "
-        return nil if i >= tag_content.length
+        i += 1 while i < length && tag_content.getbyte(i) == SPACE_BYTE
+        return nil if i >= length
 
         name_start = i
-        i += 1 while i < tag_content.length && tag_content[i] != " " &&
-            tag_content[i] != "/" && tag_content[i] != ">"
+        i += 1 while i < length &&
+            !NAME_END_BYTES.include?(tag_content.getbyte(i))
         tag_name = tag_content[name_start...i]
 
         # Skip whitespace
-        i += 1 while i < tag_content.length && tag_content[i] == " "
+        i += 1 while i < length && tag_content.getbyte(i) == SPACE_BYTE
 
         # Parse attributes
         attrs = []
-        while i < tag_content.length
+        while i < length
           # Skip whitespace
-          i += 1 while i < tag_content.length && tag_content[i] == " "
-          break if i >= tag_content.length
+          i += 1 while i < length && tag_content.getbyte(i) == SPACE_BYTE
+          break if i >= length
 
           # Read attribute name
           attr_start = i
-          i += 1 while i < tag_content.length && tag_content[i] != "=" &&
-              tag_content[i] != " " && tag_content[i] != "/" &&
-              tag_content[i] != ">"
-          break if i >= tag_content.length || i == attr_start
+          i += 1 while i < length &&
+              !NAME_END_BYTES.include?(tag_content.getbyte(i)) &&
+              tag_content.getbyte(i) != 61
+          break if i >= length || i == attr_start
 
           attr_name = tag_content[attr_start...i]
 
           # Skip whitespace and =
-          i += 1 while i < tag_content.length &&
-              SKIP_CHARS.include?(tag_content[i])
-          break if i >= tag_content.length
+          i += 1 while i < length &&
+              SKIP_BYTES.include?(tag_content.getbyte(i))
+          break if i >= length
 
           # Read quoted value
-          quote = tag_content[i]
-          break unless QUOTE_CHARS.include?(quote)
+          quote = tag_content.getbyte(i)
+          break unless QUOTE_BYTES.include?(quote)
 
           i += 1
           value_start = i
-          while i < tag_content.length && tag_content[i] != quote
+          while i < length && tag_content.getbyte(i) != quote
             i += 1
           end
-          break if i >= tag_content.length
+          break if i >= length
 
           attr_value = tag_content[value_start...i]
           i += 1 # skip closing quote
 
-          attrs << { name: attr_name, value: "#{quote}#{attr_value}#{quote}" }
+          quote_char = quote.chr
+          attrs << { name: attr_name, value: "#{quote_char}#{attr_value}#{quote_char}" }
         end
 
         { name: tag_name, attrs: attrs }
@@ -241,9 +253,9 @@ module Canon
       # @param i [Integer] Position of '<'
       # @return [Array(Integer, String), nil] [new_position, tag_string] or nil
       def self.process_tag(text, pos)
-        if text[pos + 1] == "?"
+        if text.getbyte(pos + 1) == 63 # ?
           process_processing_instruction(text, pos)
-        elsif text[pos + 1] == "!" && text[(pos + 2)...(pos + 4)] == "--"
+        elsif text.getbyte(pos + 1) == 33 && text[(pos + 2)...(pos + 4)] == "--" # !
           process_comment(text, pos)
         else
           process_regular_tag(text, pos)

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

@@ -642,6 +642,23 @@ module Canon
         #
         # @param token [String] The token to apply visualization to
         # @param color [Symbol, nil] Optional color to apply
+        # Whole-string gsub through the map — the previous
+        # chars.map.fetch.join minted two arrays and one 1-char string
+        # per character of every displayed line.
+        def visualize(token)
+          return token if @visualization_map.empty?
+
+          token.gsub(visualization_union, @visualization_map)
+        end
+
+        # Longer keys first so "\r\n" wins over "\r"/"\n" at the
+        # same position.
+        def visualization_union
+          @visualization_union ||= Regexp.union(
+            @visualization_map.keys.sort_by(&:length).reverse,
+          )
+        end
+
         # @return [String] Visualized and optionally colored token
         def apply_visualization(token, color = nil)
           return "" if token.nil?
@@ -649,9 +666,7 @@ module Canon
           visual = if @character_visualization == :content_only
                      visualize_content_only(token.to_s)
                    else
-                     token.to_s.chars.map do |char|
-                       @visualization_map.fetch(char, char)
-                     end.join
+                     visualize(token.to_s)
                    end
 
           if color && @use_color

data/lib/canon/version.rb

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

data/lib/canon/xml/digest_gate.rb

@@ -21,6 +21,28 @@ module Canon
     module DigestGate
       module_function
 
+      # libleptris 1.9.205+ records duplicate-attribute recover
+      # events on the parsed document (#1200): read through the
+      # FFI diag counter. Evaluated lazily at call time — a load-time
+      # constant would freeze before leptris loads (defined? never
+      # resolves pending autoloads). When the adapter is not leptris
+      # (or the binding predates the surface), the verbose lane
+      # falls back to the SAX probe for its error scan.
+      def recover_diags_available?
+        defined?(::Leptris::XML::FFI) &&
+          ::Leptris::XML::FFI.respond_to?(:leptris_document_parse_diag_count)
+      rescue StandardError
+        false
+      end
+
+      def recover_diags?(doc)
+        return false unless recover_diags_available?
+
+        native = doc.native
+        native = native.c_ptr if native.respond_to?(:c_ptr)
+        ::Leptris::XML::FFI.leptris_document_parse_diag_count(native).positive?
+      end
+
       def available?
         return false if RUBY_ENGINE == "opal"
         return false unless Canon::XmlBackend.moxml? &&
@@ -106,7 +128,11 @@ module Canon
         doc = context.parse(xml, readonly: true, strict: false)
         root = doc.root
         return nil unless root
-        return nil if clean && doc.parse_errors.any?
+
+        if clean
+          return nil if doc.parse_errors.any?
+          return nil if recover_diags?(doc)
+        end
 
         skeleton = doc.children.filter_map do |child|
           next if Canon::XmlParsing.same_engine_node?(child, root)

metadata

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