canon 0.3.21 → 0.3.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd899c17d1512c815d189076fe08721dbe66b7d964f8bac69abde35f207b8c76
-  data.tar.gz: 205ad0b365288bf883f2ce57f68b612217151e30ae90fb0f959b29f252063826
+  metadata.gz: 7e3fda4e37d9ca6cf584389c0ffec06c70811ec488910377151ed8ee29f20a35
+  data.tar.gz: cb73f6f95b16ce10b9ada9f13d1e91eaad0a4bce416d84ddfb49439227f270d5
 SHA512:
-  metadata.gz: 5aa4d552592cda5a55417415efb225151eb0d39d899fe0471eb26f10ceeca64ae56de786d8e807e0085264ba800cfd5937a6ec15e182e71957381414f3036105
-  data.tar.gz: b52ceb55e3ca6c6affcca3c7091a0e3f6e22d1c077b65732e7073915c3f6914cb86a61e675b11636baeb1ea09e94c223c933e961c0b366fb3e621c592a50170b
+  metadata.gz: 48a6dacc76c75c234a34583264f0cd3816c643bda7152ccbeee62cb4057fd370c70b168414bca515addc400de5ea12dacb82b9a356d35e4421596bff0109806b
+  data.tar.gz: a33a5b36fbd98f43d4832dbb275737726f5e9dc1786b91fc34313684a8e431724e3f169a426c18af3d90a15be1fb9a4970e561ef25d2f576ff52229cfebc1829

data/CLAUDE.md

@@ -143,6 +143,10 @@ Engine parity is complete through libleptris 1.9.8 / leptris-ruby 1.9.33 / moxml
 
 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.
 
+### YAML Engines
+
+`Canon::YamlBackend` selects the YAML engine: `:psych` (default) or `:yeptris` (FFI over libyeptris, the YAML counterpart of the leptris XML stack — `CANON_YAML_BACKEND=yeptris` opts in; the optional `yeptris` Gemfile group must be enabled). `Canon::YamlParsing` is the single gateway for string loads; `YAML.dump` stays on Psych everywhere — canonical output bytes are canon's product and the writers differ. The default stays `:psych` until the yeptris Psych-parity gaps close (yeptris-ruby#29 empty documents, #30 sexagesimal scalars, #31 >64-bit integers); `spec/canon/yaml_engine_parity_spec.rb` is the executable gate, with upstream-tracked cases pending. Never `require "yeptris/psych"` — it rebinds the global `::Psych` constant for the whole process; only the namespaced `Yeptris::YAML` API is used.
+
 ### 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.

data/lib/canon/comparison/node_inspector.rb

@@ -68,8 +68,11 @@ module Canon
       def self.whitespace_only_text?(node)
         return false unless text_node?(node)
 
+        # This runs per child pair in the realignment walk — the
+        # zero-allocation form of `text.strip.empty?` (exactly
+        # String#strip's character set; see WhitespacePolicy).
         text = text_content(node)
-        !text.empty? && text.strip.empty?
+        !text.empty? && text.match?(Canon::Xml::WhitespacePolicy::STRIP_ONLY)
       end
 
       # --- Noise classification ---

data/lib/canon/comparison/yaml_comparator.rb

@@ -90,7 +90,7 @@ module Canon
         def parse_yaml(obj)
           return obj unless obj.is_a?(String)
 
-          YAML.safe_load(obj, aliases: true)
+          Canon::YamlParsing.safe_load(obj, aliases: true)
         end
       end
     end

data/lib/canon/formatters/html_formatter_base.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "nokogiri" unless RUBY_ENGINE == "opal"
+require "set"
 
 module Canon
   module Formatters
@@ -55,6 +56,14 @@ module Canon
       WHITESPACE_SENSITIVE_ELEMENTS = %w[
         pre code textarea script style
       ].freeze
+      # Set form for the per-sibling hot lookup; Nokogiri lowercases
+      # HTML element names, so the downcase fallback only runs for
+      # unusual (already-mixed-case) input.
+      BLOCK_ELEMENT_SET = BLOCK_ELEMENTS.to_set
+      # Compiled once — building the alternation and compiling the
+      # regex per format call cost more than the gsub it drives.
+      BLOCK_SPACING_PATTERN =
+        Regexp.new("(</(?:#{BLOCK_ELEMENTS.join('|')})>)(<(?:#{BLOCK_ELEMENTS.join('|')})[\s>])").freeze
       # Format HTML using canonical form
       # @param html [String] HTML document to canonicalize
       # @return [String] Canonical form of HTML
@@ -100,6 +109,15 @@ module Canon
           next unless node.element?
           next if node.attributes.empty?
 
+          names = node.attributes.keys
+          # Already-sorted un-namespaced is the common case — removing
+          # and re-adding every attribute is expensive, so check first.
+          # Namespaced attributes must take the slow path: the
+          # remove/re-add below flattens their prefix, and skipping
+          # would change the canonical output.
+          next if names.each_cons(2).all? { |a, b| (a <=> b) <= 0 } &&
+            node.attributes.each_value.all? { |a| a.namespace.nil? }
+
           sorted_attrs = node.attributes.sort_by { |name, _| name }
           node.attributes.each_key { |name| node.remove_attribute(name) }
           sorted_attrs.each { |name, attr| node[name] = attr.value }
@@ -122,7 +140,7 @@ module Canon
           end
 
           # Handle whitespace-only text nodes
-          if node.text.strip.empty? && node.parent&.element?
+          if node.text.match?(Canon::Xml::WhitespacePolicy::STRIP_ONLY) && node.parent&.element?
             # Check if this text node is between block-level elements
             prev_sibling = node.previous_sibling
             next_sibling = node.next_sibling
@@ -138,14 +156,17 @@ module Canon
           else
             # Collapse multiple whitespace characters into single spaces
             # but preserve leading/trailing single spaces for inline content
-            normalized = node.text.gsub(/\s+/, " ")
+            text = node.text
+            normalized = text.gsub(/\s+/, " ")
             # Only strip if the entire parent chain suggests it's appropriate
             # (e.g., at document boundaries)
             if node.parent&.name == "body" &&
                 (node.previous_sibling.nil? || node.next_sibling.nil?)
               normalized = normalized.strip
             end
-            node.content = normalized
+            # node.content= re-parses the string — skip it when nothing
+            # changed (text with no collapsible whitespace).
+            node.content = normalized unless normalized == text
           end
         end
       end
@@ -154,19 +175,20 @@ module Canon
       # @param html [String] Serialized HTML string
       # @return [String] HTML with proper spacing between block elements
       def self.ensure_block_element_spacing(html)
-        # Build regex pattern for block element tags
-        block_tags = BLOCK_ELEMENTS.join("|")
-
         # Add space between closing and opening block element tags
-        # Match: ><opening_block_tag or </closing_block_tag><opening_block_tag
-        html.gsub(/(<\/(?:#{block_tags})>)(<(?:#{block_tags})[\s>])/, '\1 \2')
+        # (pattern compiled once — see BLOCK_SPACING_PATTERN)
+        html.gsub(BLOCK_SPACING_PATTERN, '\1 \2')
       end
 
       # Check if a node is a block-level element
       # @param node [Nokogiri::XML::Node, nil] Node to check
       # @return [Boolean] true if node is a block element
       def self.block_element?(node)
-        node&.element? && BLOCK_ELEMENTS.include?(node.name.downcase)
+        return false unless node&.element?
+
+        name = node.name
+        BLOCK_ELEMENT_SET.include?(name) ||
+          BLOCK_ELEMENT_SET.include?(name.downcase)
       end
 
       # Check if a node is a whitespace-sensitive element
@@ -178,8 +200,14 @@ module Canon
         # Check if this element or any ancestor is whitespace-sensitive
         current = node
         while current
-          if current.element? && WHITESPACE_SENSITIVE_ELEMENTS.include?(current.name.downcase)
-            return true
+          if current.element?
+            name = current.name
+            # Nokogiri lowercases HTML names — the downcase fallback
+            # only allocates for unusual mixed-case input.
+            if WHITESPACE_SENSITIVE_ELEMENTS.include?(name) ||
+                WHITESPACE_SENSITIVE_ELEMENTS.include?(name.downcase)
+              return true
+            end
           end
           # Stop at document root - documents don't have parents
           break if current.is_a?(Nokogiri::XML::Document) || current.is_a?(Nokogiri::HTML5::Document)

data/lib/canon/formatters/yaml_formatter.rb

@@ -17,7 +17,7 @@ module Canon
         # Return as-is if already parsed
         return yaml if yaml.is_a?(Hash) || yaml.is_a?(Array)
 
-        YAML.safe_load(yaml, permitted_classes: [Symbol, Date, Time])
+        Canon::YamlParsing.safe_load(yaml)
       end
 
       def self.sort_yaml_keys(obj)

data/lib/canon/validators/yaml_validator.rb

@@ -22,7 +22,7 @@ module Canon
         return if input.is_a?(Hash) || input.is_a?(Array) # Already parsed
         return if input.strip.empty?
 
-        YAML.safe_load(input, permitted_classes: [Symbol, Date, Time])
+        Canon::YamlParsing.safe_load(input)
       rescue Psych::SyntaxError => e
         location = extract_location(e)
 

data/lib/canon/version.rb

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

data/lib/canon/yaml_backend.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Canon
+  # Selection of the YAML engine: :psych (stdlib) or :yeptris
+  # (FFI over libyeptris — the YAML counterpart of the leptris XML
+  # stack).
+  #
+  # Mirrors XmlBackend's discipline (MECE — this module owns selection,
+  # YamlParsing owns the calls). The default stays :psych until the
+  # yeptris Psych-safe_load parity gaps close (yeptris-ruby#29 empty
+  # documents crash, #30 sexagesimal scalars, #31 >64-bit integers);
+  # yeptris is 3.1x faster at loading (measured, 2,000-item document),
+  # so CANON_YAML_BACKEND=yeptris opts in early and the default flips
+  # once the parity spec runs clean.
+  #
+  # Only the namespaced API (Yeptris::YAML) is ever used — requiring
+  # "yeptris/psych" rebinds the global ::Psych constant for the whole
+  # process, which a library must never do.
+  module YamlBackend
+    VALID_BACKENDS = %i[psych yeptris].freeze
+
+    class << self
+      def active
+        @active ||= begin
+          wanted = forced || :psych
+          # A forced yeptris without a loadable gem/native lib must
+          # degrade to Psych, not NameError in the gateway.
+          wanted = :psych if wanted == :yeptris && !yeptris_available?
+          wanted
+        end
+      end
+
+      def psych?
+        active == :psych
+      end
+
+      def yeptris?
+        active == :yeptris
+      end
+
+      def reset!
+        @active = nil
+      end
+
+      def yeptris_available?
+        return false if RUBY_ENGINE == "opal"
+
+        require "yeptris"
+        Yeptris::YAML.respond_to?(:load)
+      rescue LoadError, StandardError
+        false
+      end
+
+      private
+
+      def forced
+        value = ENV["CANON_YAML_BACKEND"].to_s.downcase
+        return nil unless VALID_BACKENDS.include?(value.to_sym)
+
+        value.to_sym
+      end
+    end
+  end
+end

data/lib/canon/yaml_parsing.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Canon
+  # The only place canon talks to a YAML engine. All string loads go
+  # through safe_load here (see XmlParsing for the XML equivalent);
+  # YAML.dump stays on Psych everywhere — canonical output bytes are
+  # canon's product and the writers differ.
+  module YamlParsing
+    module_function
+
+    # Psych::safe_load semantics. yeptris is safe-by-default plain
+    # data with Symbol/Date/Time built in (aliases resolve), so the
+    # permitted-class list is inherently satisfied; parse failures are
+    # normalized to Psych::SyntaxError so canon's rescues hold on both
+    # engines.
+    def safe_load(yaml, permitted_classes: [Symbol, Date, Time],
+                  aliases: false)
+      if YamlBackend.yeptris?
+        begin
+          ::Yeptris::YAML.load(yaml)
+        rescue ::Yeptris::ParseError => e
+          raise Psych::SyntaxError.new(nil, 0, 0, 0, e.message, "")
+        rescue ::FFI::NullPointerError
+          # yeptris-ruby#29: empty/comment-only input. Psych returns
+          # nil; mirror that until the upstream fix lands.
+          nil
+        end
+      else
+        YAML.safe_load(yaml, permitted_classes: permitted_classes,
+                             aliases: aliases)
+      end
+    end
+  end
+end

data/lib/canon.rb

@@ -5,6 +5,8 @@ require "canon/errors"
 require "nokogiri" unless RUBY_ENGINE == "opal"
 require "canon/xml_backend"
 require "canon/xml_parsing"
+require "canon/yaml_backend"
+require "canon/yaml_parsing"
 require "canon/config"
 require "canon/data_model"
 require "canon/xml"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.21
+  version: 0.3.23
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-06 00:00:00.000000000 Z
+date: 2026-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diff-lcs
@@ -407,6 +407,8 @@ files:
 - lib/canon/xml/xpath_engine.rb
 - lib/canon/xml_backend.rb
 - lib/canon/xml_parsing.rb
+- lib/canon/yaml_backend.rb
+- lib/canon/yaml_parsing.rb
 - lib/tasks/benchmark_runner.rb
 - lib/tasks/performance.rake
 - lib/tasks/performance_comparator.rb