canon 0.3.31 → 0.3.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c7f349890b131b4280956b65c069369fee17b526db3ffacaa4560c3b3beb485
-  data.tar.gz: dc2179259f0a7212de6b6aaddd50e61a32fba4627d4b853d60e00172cb819c10
+  metadata.gz: 6094f49ebe4d3b32a5396a0db4d62dbc502156d277ed12115029d50eb36f37ff
+  data.tar.gz: 8cf4e6d0b0e1feaaddaed2b996d98f9fd36adb4b250c3460ac2ae20a5263689a
 SHA512:
-  metadata.gz: 6e3085a46f5ae85c542a419ae35b961529fc76d1f232d72f3599eb54b1f6588e0bbc9d8f1ffcdb6e31e61a5dcf4a3d8c884ddf0999f9a1f2062e22997640052a
-  data.tar.gz: 3573d0da07ad60bd4aac8a3e3ffb149d61c400a2708c10d8dcca9280abae0dc12ac7d442786fd12be62ea584345e67dd2807ca63bc598578a4013e9159cd0ad7
+  metadata.gz: 9b53fdc9296da8e354cbb99cc194f6dab11544a52c1cda09370a01f413ce57dc5b04d47d99d496d9a3dcb9558f934dd75a5124be10406de74106e6750b86f51a
+  data.tar.gz: b8cf46fd5d9380584db39732281d18e7186c33927518ac46e5a42fec09d7d3cc5aad167ca1a85c879f087a54a934e8a329b879c43b4cc3aade63512503d0fe80

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/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.31"
+  VERSION = "0.3.33"
 end

data/lib/canon/xml/element_matcher.rb

@@ -164,6 +164,21 @@ module Canon
         elems1 = children1.select { |n| n.node_type == :element }
         elems2 = children2.select { |n| n.node_type == :element }
 
+        # FAST PATH: pairwise-corresponding children. When both lists
+        # are the same length and every position pairs elements with
+        # equal name, namespace URI, and identity value, the full
+        # matcher's output is exactly the positional pairing: unique
+        # identity keys pair same-with-same, duplicate keys pair
+        # last-with-last in the identity phase and the rest pair in
+        # order in the positional phase. No deleted/inserted results
+        # either way. Skip the identity/positional/class machinery.
+        if !elems1.empty? && elems1.length == elems2.length &&
+            pairwise_corresponding?(elems1, elems2)
+          record_positional_matches(elems1, elems2, path,
+                                    recursive: recursive)
+          return
+        end
+
         # Positions by identity: elems.index(elem) was an O(n) scan per
         # recorded match — O(n²) per level on element-heavy parents.
         positions1 = {}
@@ -263,6 +278,48 @@ module Canon
         end
       end
 
+      # True when every position pairs elements with equal name,
+      # namespace URI, and identity value (nil-safe).
+      def pairwise_corresponding?(elems1, elems2)
+        elems1.each_index.all? do |i|
+          e1 = elems1[i]
+          e2 = elems2[i]
+          e1.name == e2.name && e1.namespace_uri == e2.namespace_uri &&
+            extract_identity(e1) == extract_identity(e2)
+        end
+      end
+
+      # Record the positional pairing as :matched MatchResults,
+      # descending per pair in recursive mode (match_trees' ordering
+      # contract).
+      def record_positional_matches(elems1, elems2, path, recursive:)
+        elems1.each_index do |i|
+          elem1 = elems1[i]
+          elem_path = element_path(path, elem1)
+          @matches << MatchResult.new(
+            status: :matched,
+            elem1: elem1,
+            elem2: elems2[i],
+            path: elem_path,
+            pos1: i,
+            pos2: i,
+          )
+          if recursive
+            match_children(elem1.children, elems2[i].children, elem_path)
+          end
+        end
+      end
+
+      # Path segment for an element: expanded under a namespace,
+      # bare otherwise.
+      def element_path(path, elem)
+        if elem.namespace_uri && !elem.namespace_uri.empty?
+          path + ["{#{elem.namespace_uri}}#{elem.name}"]
+        else
+          path + [elem.name]
+        end
+      end
+
       # Match remaining elements by name and position
       def match_by_position(elems1, elems2, path, matched1, matched2,
                             recursive:)

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,

data/lib/tasks/benchmark_runner.rb

@@ -225,6 +225,13 @@ compare_against: nil)
       failure_means: "Slow formatting affects serialization performance. C14N is critical for digital signatures and XML canonicalization.",
       compare_against: "Previous branch (main).",
     },
+    data_comparison: {
+      name: "Data Comparison",
+      icon: "🧮",
+      description: "JSON and YAML semantic comparison. Both formats load through their engine gateways (yeptris/stdlib), so this referees engine choice.",
+      failure_means: "Slow data comparison affects validation pipelines and test suites. A regression here can also signal an engine lane flip gone wrong.",
+      compare_against: "Previous branch (main). Inputs are freshly generated (different values), so the comparison does real work.",
+    },
   }.freeze
 
   # Test definitions
@@ -265,6 +272,12 @@ compare_against: nil)
       { name: "JSON", method: :json_format, desc: "JSON formatting" },
       { name: "YAML", method: :yaml_format, desc: "YAML formatting" },
     ],
+    data_comparison: [
+      { name: "JSON", method: :json_compare_equivalent,
+        desc: "JSON equivalence" },
+      { name: "YAML", method: :yaml_compare_equivalent,
+        desc: "YAML equivalence" },
+    ],
   }.freeze
 
   # Test data generators
@@ -555,6 +568,14 @@ compare_against: nil)
       yaml = DataGenerator.generate_yaml(items: @items)
       data = YAML.safe_load(yaml, permitted_classes: [Time])
       measure { Canon.format_yaml(data) }
+    when :json_compare_equivalent
+      json1 = DataGenerator.generate_json(items: @items)
+      json2 = DataGenerator.generate_json(items: @items)
+      measure { Canon::Comparison.equivalent?(json1, json2, format: :json) }
+    when :yaml_compare_equivalent
+      yaml1 = DataGenerator.generate_yaml(items: @items)
+      yaml2 = DataGenerator.generate_yaml(items: @items)
+      measure { Canon::Comparison.equivalent?(yaml1, yaml2, format: :yaml) }
     else
       raise "Unknown benchmark: #{method}"
     end

metadata

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