canon 0.3.18 → 0.3.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b27c3659e1b75307f170fb50161ce649c54ab4a12600716d3b006fce8b01ad1a
-  data.tar.gz: 89c288d724f4a3b0b410938d94959880b4fbbcff1ec550b53593840bd33d52c8
+  metadata.gz: b04c8b44b470bb85f2ec003f434a0fa8ede8eec74f687b388241814e60841415
+  data.tar.gz: a944aa18b2dd0993362d15a92cf70488a0618841445873c617c206a5e6fe4f72
 SHA512:
-  metadata.gz: '0922a2a6d6061f7472ac55de8c6e0172a8ce8d2939f8f144f71493b148248fb597c07d916c67dc9a4549d35a6e65b7757e5cb3f0d0ae79a7a39f7b35306bbb22'
-  data.tar.gz: e5b5b898ca11ef0bdc077d8cfb78d6575bc7c9a6b712f2a0ccbd2a3f338704d66883c730e32651af1776746b751b996c723b29af80044d8cd44944f9b18df883
+  metadata.gz: dfc4366fc597d9a8c33201cf7ed4857f3577e791d0fc80160c0e6dbeda359f5c7ea0d8df49f4dcec22ffe7c596e1a694ec114b8005bce7275f9e6572b3643f77
+  data.tar.gz: 3b00f6d66f7c75e3f4dccb224347b3092ea4713aa44906c1bc623b3fee6086f940d9c13b5af10c8c60f063d8e16e82a99adc412e662cb4fe092bb23f8129c1b4

data/lib/canon/comparison/whitespace_sensitivity.rb

@@ -39,16 +39,26 @@ module Canon
 
       class << self
         # Classify the whitespace behaviour for an element using ancestor walk.
+        # Results are cached per element per match_opts (classify runs
+        # per text node/pair otherwise — once per element is enough;
+        # the sets it depends on are memoized alongside in the same
+        # entry).
         def classify_element(element, match_opts)
           return :strip unless element
           return :strip unless node_name(element)
 
-          preserve_set  = resolved_preserve_elements_set(match_opts)
-          collapse_set  = resolved_collapse_elements_set(match_opts)
-          strip_set = resolved_strip_elements_set(match_opts)
-
-          walk_ancestor_classification(element, preserve_set, collapse_set,
-                                       strip_set)
+          cache = classification_map(match_opts)
+          cached = cache[element]
+          return cached if cached
+
+          classification = walk_ancestor_classification(
+            element,
+            resolved_preserve_elements_set(match_opts),
+            resolved_collapse_elements_set(match_opts),
+            resolved_strip_elements_set(match_opts),
+          )
+          cache[element] = classification
+          classification
         end
 
         # Check if an element is whitespace-sensitive based on configuration.
@@ -147,12 +157,27 @@ module Canon
           parent = NodeInspector.parent(text_node)
           return false unless parent
 
+          # One pass: find the node by identity while tracking the
+          # nearest non-whitespace siblings on each side (index plus
+          # two directional scans cost three passes before).
           siblings = NodeInspector.children(parent)
-          idx = siblings.index(text_node)
-          return false unless idx
-
-          prev_neighbour = nearest_non_whitespace_sibling(siblings, idx, -1)
-          next_neighbour = nearest_non_whitespace_sibling(siblings, idx,  1)
+          prev_neighbour = nil
+          next_neighbour = nil
+          found = false
+
+          siblings.each do |sibling|
+            if found
+              if next_neighbour.nil? && !whitespace_text_node?(sibling)
+                next_neighbour = sibling
+                break
+              end
+            elsif sibling.equal?(text_node)
+              found = true
+            elsif !whitespace_text_node?(sibling)
+              prev_neighbour = sibling
+            end
+          end
+          return false unless found
 
           inline_element?(prev_neighbour) && inline_element?(next_neighbour)
         end
@@ -236,6 +261,20 @@ module Canon
           cache[match_opts] ||= [nil, nil, nil]
         end
 
+        # Per-match_opts classification map (slot 3 of the resolved
+        # entry). Weak element keys: entries vanish with their trees,
+        # so finished comparisons retain nothing. Opal has no
+        # ObjectSpace::WeakMap — there the map holds strong references
+        # and dies with the bounded resolved-sets cache clear.
+        def classification_map(match_opts)
+          entry = resolved_sets_entry(match_opts)
+          entry[3] ||= if defined?(ObjectSpace::WeakMap)
+                         ObjectSpace::WeakMap.new
+                       else
+                         {}.compare_by_identity
+                       end
+        end
+
         def walk_ancestor_classification(element, preserve_set, collapse_set,
                                          strip_set)
           current = element

data/lib/canon/version.rb

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

data/lib/canon/xml/data_model.rb

@@ -79,19 +79,29 @@ module Canon
         nil
       end
 
+      # Encoding-declaration probe: anchored, and it only ever scans the
+      # XML declaration prefix — a document without one bails after a
+      # few characters.
+      XML_ENCODING_DECL = /\A\s*<\?xml[^>]*\bencoding\s*=\s*["']([^"']+)["'][^>]*\?>/i
+
       def self.extract_xml_encoding(xml_string)
         # A valid UTF-8 string matches directly (the regex is
         # ASCII-only); anything else still needs the BINARY view so a
-        # broken byte sequence cannot raise mid-probe. Skipping the
-        # dup avoids a full-document copy on every parse.
-        unless xml_string.encoding.name == "UTF-8" && xml_string.valid_encoding?
+        # broken byte sequence cannot raise mid-probe. The validity is
+        # tested by the match itself, not a full-document scan: invalid
+        # bytes outside the scanned prefix never raise, and invalid
+        # bytes inside it fall back to the BINARY retry.
+        if xml_string.encoding.name == "UTF-8"
+          begin
+            return xml_string[XML_ENCODING_DECL, 1]
+          rescue ArgumentError
+            xml_string = xml_string.dup.force_encoding("BINARY")
+          end
+        else
           xml_string = xml_string.dup.force_encoding("BINARY")
         end
-        if xml_string =~ /\A\s*<\?xml[^>]*\bencoding\s*=\s*["']([^"']+)["'][^>]*\?>/i
-          return Regexp.last_match(1)
-        end
 
-        nil
+        xml_string[XML_ENCODING_DECL, 1]
       end
 
       def self.parse(xml_string)

data/lib/canon/xml/sax_builder.rb

@@ -52,8 +52,9 @@ strip_doctype: false)
       # @param xml [String] XML string potentially containing DOCTYPE
       # @return [String] XML string with DOCTYPE removed
       def self.strip_doctype_declaration(xml)
-        # Find DOCTYPE start (case-insensitive)
-        doctype_start = xml.upcase.index("<!DOCTYPE")
+        # Find DOCTYPE start (case-insensitive). A literal + /i index
+        # scans in place — upcase would copy the whole document per call.
+        doctype_start = xml.index(/<!DOCTYPE/i)
         return xml unless doctype_start
 
         # Find the end of DOCTYPE - it ends with >

data/lib/canon/xml/whitespace_policy.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Canon
   module Xml
     # Parse-time whitespace policy: whether a character-data node
@@ -60,13 +62,18 @@ element_parent: true)
       # carries NBSP (U+00A0 — never insignificant; strip is ASCII-only
       # so it is checked explicitly).
       HTML_WHITESPACE_SENSITIVE_TAGS = %w[pre code textarea script style].freeze
+      # Set form for the hot lookup; element names arrive lowercased
+      # from the HTML parser, so the downcase fallback only allocates
+      # for unusual (non-lowercased) names.
+      HTML_SENSITIVE_TAG_SET = HTML_WHITESPACE_SENSITIVE_TAGS.to_set
 
       def keep_html_text?(content, parent_name:, text_node: nil)
         return true unless content.match?(STRIP_ONLY)
         return true if content.include?(" ")
 
-        parent_name = parent_name.to_s.downcase
-        return true if HTML_WHITESPACE_SENSITIVE_TAGS.include?(parent_name)
+        parent_name = parent_name.to_s
+        return true if HTML_SENSITIVE_TAG_SET.include?(parent_name)
+        return true if HTML_SENSITIVE_TAG_SET.include?(parent_name.downcase)
 
         # Computed last: the sibling scan is O(siblings), so it must
         # not run for the content-bearing text nodes that fail the

metadata

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