canon 0.3.30 → 0.3.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 308416a45e76807d58f00f40a88d5d6f53617d2a9dac468da8add04fa8175a2f
-  data.tar.gz: 2fa30986100df7b8238263546513705513635bd6c39f1552f0e0f8774f510f5f
+  metadata.gz: 44f563b9b8ac9fa82cc08c9413ca4a17afd8080c524d6eb92536572356892539
+  data.tar.gz: 4a7cbe635232ca07fa8b9924e46c027849145fbc6ac6846df3ec9de4c51edbc4
 SHA512:
-  metadata.gz: 0ffdb20ffc91117fdf24afb405f1684aea837316c1481ed5cc7e435bff4bf5d409876d9ca5851e187d3cd128b192ce3516b49114e6ac5d56a327dd87330f0ec9
-  data.tar.gz: aaeac239ac4707d8034eb92c8205753e3ec94ff203bf0b4023c33d0b7a92d57742e632ee29998de5a2ed041e45ea7bf2453b2479bb24ed9b9164dacba8db4ab1
+  metadata.gz: a228ef2b06e3e59545aab338afd72cdcf4943c32b34fa24063e43884f01b41444558966cb121986513d28041a92f0918864106886875ef44da9b3f00e53dcdc2
+  data.tar.gz: 9dbddd3a07e0d6076118ed7e2619de864b9bf3c99ff68c109fa31805a912a1839054d4cf843f712faa2df2a2ee619806d256a47bdce9399feb422721d6117e71

data/CLAUDE.md

@@ -149,7 +149,7 @@ Engine A/B testing: `CANON_XML_BACKEND=nokogiri bundle exec rspec` (or `=moxml`
 
 ### 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; `Canon::JsonParsing` mirrors it for JSON (the same yeptris engine serves both — `Yeptris::YAML.load` auto-detects JSON and routes to the native C-API materializer; JSON falls back to stdlib unless `YamlBackend.yeptris_native?`, since the FFI ladder is ~29x slower than the stdlib C extension). `YAML.dump` stays on Psych everywhere — canonical output bytes are canon's product and the writers differ. **JSON defaults to the strict yeptris surface whenever the native materializer is installed** (yeptris 0.1.13.4 ships platform gems — zero compilation, zero env; parity spec-pinned to `JSON.parse` upstream). The YAML default stays `:psych` until the yeptris Psych-parity gaps close (yeptris-ruby#30 sexagesimal scalars, #31 >64-bit integers — #29 empty documents was fixed in 0.1.12); `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.
+`Canon::YamlBackend` selects the YAML engine: `:yeptris` (default — Marshal bulk materialization in yeptris 0.1.28, 4.5–5x Psych load) or `:psych` (`CANON_YAML_BACKEND=psych` forces the stdlib engine). The default follows availability: yeptris when loadable, Psych otherwise. `Canon::YamlParsing` is the single gateway for string loads; `Canon::JsonParsing` mirrors it for JSON (the same yeptris engine serves both — `Yeptris::YAML.load` auto-detects JSON and routes to the native C-API materializer; JSON falls back to stdlib unless `YamlBackend.yeptris_native?`, since the FFI ladder is ~29x slower than the stdlib C extension). `YAML.dump` stays on Psych everywhere — canonical output bytes are canon's product and the writers differ. **JSON defaults to the strict yeptris surface whenever the native materializer is installed** (yeptris 0.1.13.4 ships platform gems — zero compilation, zero env; parity spec-pinned to `JSON.parse` upstream). The parity gate (`spec/canon/yaml_engine_parity_spec.rb`) ran clean after yeptris-ruby #29/#30/#31/#37 all closed (0.1.15.1), so YAML loads flip to yeptris by default; the spec stays as the executable gate for future yeptris releases. Never `require "yeptris/psych"` — it rebinds the global `::Psych` constant for the whole process; only the namespaced `Yeptris::YAML` API is used.
 
 ### Format Detection
 

data/lib/canon/commands/diff_command.rb

@@ -199,10 +199,10 @@ module Canon
           content
         when :json
           # Parse JSON to Ruby object
-          JSON.parse(content)
+          Canon::JsonParsing.parse(content)
         when :yaml
           # Parse YAML to Ruby object
-          YAML.safe_load(content)
+          Canon::YamlParsing.safe_load(content)
         else
           abort "Error: Unsupported format '#{format}'"
         end

data/lib/canon/comparison/xml_comparator.rb

@@ -74,6 +74,25 @@ module Canon
           # Store resolved match options hash for use in comparison logic
           opts[:match_opts] = match_opts_hash
 
+          # FAST PATH: leptris Merkle digest — equal root-subtree
+          # digests plus identical document-level skeletons prove
+          # content identity (modulo whitespace-only text nodes and
+          # attribute order), which implies equivalence wherever
+          # canon's whitespace handling is the same symmetric
+          # parse-time strip. Callers whose whitespace semantics
+          # differ from that skip the gate: strict attribute order
+          # (invisible to the digest), user-configured whitespace
+          # element lists, xml:space documents (checked inside the
+          # gate), and verbose callers who need the report.
+          if !(opts[:verbose] ||
+                 match_opts_hash[:attribute_order] == :strict ||
+                 match_opts_hash[:preserve_whitespace_elements] ||
+                 match_opts_hash[:collapse_whitespace_elements] ||
+                 match_opts_hash[:strip_whitespace_elements]) &&
+              Xml::DigestGate.equal?(n1, n2)
+            return true
+          end
+
           # Create child_opts with resolved options
           child_opts = opts.merge(child_opts)
 

data/lib/canon/config/profile_loader.rb

@@ -126,7 +126,7 @@ module Canon
 
         def load_yaml(path)
           content = File.read(path)
-          YAML.safe_load(content, permitted_classes: [Symbol]) || {}
+          Canon::YamlParsing.safe_load(content, permitted_classes: [Symbol]) || {}
         end
       end
     end

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)
 
-        Canon::YamlParsing.safe_load(yaml)
+        Canon::YamlParsing.safe_load(yaml, aliases: true)
       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?
 
-        Canon::YamlParsing.safe_load(input)
+        Canon::YamlParsing.safe_load(input, aliases: true)
       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.30"
+  VERSION = "0.3.32"
 end

data/lib/canon/xml/digest_gate.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Canon
+  module Xml
+    # Document-level Merkle-digest equivalence gate over leptris'
+    # content-defined subtree digests (libleptris #869, leptris-ruby
+    # Node#digest since 1.9.144).
+    #
+    # Equal root digests prove the root subtrees carry identical
+    # content (whitespace-only nodes dropped), and every canon match
+    # behavior is a relaxation of content identity — so equal digests
+    # imply equivalence under any option combination EXCEPT the two
+    # restrictions that compare things the digest deliberately
+    # ignores (attribute order, comments). The caller excludes those;
+    # this module answers the digest question only.
+    #
+    # A digest miss costs two readonly engine parses (no field
+    # materialization, no canon tree) — a fraction of the comparison
+    # it precedes. Any parse failure answers false and lets the full
+    # pipeline surface the error.
+    module DigestGate
+      module_function
+
+      def available?
+        return false if RUBY_ENGINE == "opal"
+        return false unless Canon::XmlBackend.moxml? &&
+          Canon::XmlParsing.moxml_adapter_name == :leptris
+
+        # Node#digest is the 1.9.144 surface; feature-detect it on a
+        # throwaway document rather than probing the class.
+        doc = Canon::XmlParsing.moxml_context.parse("<r/>", readonly: true,
+                                                            strict: false)
+        root = doc.root
+        digestable = !root.native.digest(drop_ws: true).nil?
+        doc.free
+        digestable
+      rescue StandardError
+        false
+      end
+
+      # True when both documents' root subtrees digest identically
+      # AND their document-level skeletons (prolog/epilog comments and
+      # PIs — the only doc-level nodes canon compares; doctype and
+      # whitespace-only text are excluded) serialize identically.
+      # Anything else — parse failure, missing root, digest
+      # unavailable — is false: the caller falls through to the full
+      # pipeline, which surfaces the real parse errors.
+      def equal?(xml1, xml2)
+        return false unless xml1.is_a?(String) && xml2.is_a?(String)
+
+        begin
+          # xml:space documents carry attribute-scoped whitespace canon
+          # makes normative and the digest cannot see — decline them.
+          # The scan also declines non-ASCII-compatible encodings
+          # (include? raises) — those are the full pipeline's to
+          # normalize.
+          return false if xml1.include?("xml:space") || xml2.include?("xml:space")
+        rescue Encoding::CompatibilityError
+          return false
+        end
+
+        context = Canon::XmlParsing.moxml_context
+        begin
+          left = fingerprint(context, xml1)
+          right = fingerprint(context, xml2)
+          !left.nil? && left == right
+        rescue StandardError
+          # Any engine-level surprise (encodings, broken input) is the
+          # full pipeline's domain — it normalizes and surfaces errors.
+          false
+        end
+      end
+
+      # [root digest, doc-level skeleton] or nil when unparseable.
+      def fingerprint(context, xml)
+        doc = context.parse(xml, readonly: true, strict: false)
+        root = doc.root
+        return nil unless root
+
+        skeleton = doc.children.filter_map do |child|
+          next if child.equal?(root)
+
+          case child
+          when Moxml::Comment, Moxml::ProcessingInstruction then child.to_s
+          when Moxml::Text then child.content.strip.empty? ? nil : child.to_s
+          end
+        end
+        [root.native.digest(drop_ws: true), skeleton]
+      ensure
+        doc&.free
+      end
+    end
+  end
+end

data/lib/canon/xml.rb

@@ -16,6 +16,7 @@ module Canon
   module Xml
     autoload :AttributeHandler, "canon/xml/attribute_handler"
     autoload :C14n, "canon/xml/c14n"
+    autoload :DigestGate, "canon/xml/digest_gate"
     autoload :CharacterEncoder, "canon/xml/character_encoder"
     autoload :DataModel, "canon/xml/data_model"
     autoload :ElementMatcher, "canon/xml/element_matcher"

data/lib/canon/yaml_backend.rb

@@ -6,12 +6,12 @@ module Canon
   # 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.
+  # YamlParsing owns the calls). yeptris loads 4.5–5x faster than Psych
+  # (0.1.28 Marshal materialization, 2,000-item document) and the
+  # Psych-safe_load parity spec runs clean — the former gate-blockers
+  # (yeptris-ruby#29/#30/#31) are all fixed upstream. The default
+  # therefore follows availability: yeptris when loadable, Psych
+  # otherwise. CANON_YAML_BACKEND=psych forces the stdlib engine.
   #
   # Only the namespaced API (Yeptris::YAML) is ever used — requiring
   # "yeptris/psych" rebinds the global ::Psych constant for the whole
@@ -22,7 +22,7 @@ module Canon
     class << self
       def active
         @active ||= begin
-          wanted = forced || :psych
+          wanted = forced || (yeptris_available? ? :yeptris : :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?

data/lib/canon/yaml_parsing.rb

@@ -14,18 +14,17 @@ module Canon
     # 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.
+    # engines. Canon always resolves anchors (aliases: true at every
+    # call site) — a canonicalizer treats anchors as content: yeptris
+    # resolves them unconditionally, so :true keeps both engines
+    # behavior-identical.
     def safe_load(yaml, permitted_classes: [Symbol, Date, Time],
-                  aliases: false)
+                  aliases: true)
       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,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: canon
 version: !ruby/object:Gem::Version
-  version: 0.3.30
+  version: 0.3.32
 platform: ruby
 authors:
 - Ribose Inc.
@@ -391,6 +391,7 @@ files:
 - lib/canon/xml/c14n.rb
 - lib/canon/xml/character_encoder.rb
 - lib/canon/xml/data_model.rb
+- lib/canon/xml/digest_gate.rb
 - lib/canon/xml/element_matcher.rb
 - lib/canon/xml/line_range_mapper.rb
 - lib/canon/xml/namespace_handler.rb