parsanol 1.3.45 → 1.3.46

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f398d307a2ba1ef741d5d6b4667d40d3e80b90eba6024610816596c55840d778
-  data.tar.gz: 2523a3a5f0cdf0b378b879a6e87480635b921e0ba83308ef8a87ba59e38d31bf
+  metadata.gz: a69acb95360d14562fcea57597673c9fadb653c1b10688a6cd3b9324bc6b751a
+  data.tar.gz: fd3ee0db276a54c3aa13108747f4cb632a45fc8f53c7ffc01731c578d1b18b45
 SHA512:
-  metadata.gz: 627ac372929495048c804de63bb2e7975b37338c2c0f310d766fb584e5b44ad9957ebb625e9a936f4a949f6b4b1ff7251e967df570cbe9fcc4a3fd073b0b71da
-  data.tar.gz: 7f917a9c4a7221c69fba8ea32db5573e4be28e332188281aa5b98c3c7f04a3a17adabe19f11c9a49ae4500cff692b1fabe698d00a023fd0a71ba9b2e5a222736
+  metadata.gz: e20527cabb71ea4aecb84aa26b629d81e34f6d0d2dd46a2e33c874abb1c7bdeea2efe06add1bc8ed6c9d648cd837de15f7a6735dcbb7fdb84b3547ac2b573ec2
+  data.tar.gz: 2d9aad0fdb64fe5354b0a6fba463754b24b4bc8993f25fdf79b5ada6ffa52f02b1c87066979559f531b90c10acdbbf40e93009abcbbecb5e658cefd08140fd71

data/Cargo.lock

@@ -252,9 +252,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.8.3"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47ac4243cfccfaaa7d00f06979dea23ed94fdd9a3eb7f14543234797344a4932"
+checksum = "3a57413139c7aacd6343dbcd65985eceaebcf9d61dfa73222e5d0d7b527a581b"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -269,9 +269,9 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.8.3"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ee574e76f50d3d0e60b77363550ad9b679df6033be57db09b40eae07f8ac7a2"
+checksum = "5e33d7bd1f1644da4ee51892fc3289ec89826a59e692a4f7076a40dd8ba74672"
 dependencies = [
  "proc-macro2",
  "quote",

data/ext/parsanol_native/Cargo.toml

@@ -28,7 +28,7 @@ rb-sys = { version = "0.9.124", features = ["global-allocator"] }
 magnus = { version = "0.9" }
 
 # parsanol parser library (from git for latest features)
-parsanol = { version = "0.8.3", features = ["ruby"] }
+parsanol = { version = "0.8.5", features = ["ruby"] }
 
 # Logging
 log = "0.4"

data/ext/parsanol_native/src/lib.rs

@@ -11,6 +11,11 @@ use magnus::{Error, Ruby};
 /// functions from parsanol-rs.
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
+    // The native surface is Ractor-callable (parsanol-ruby#59): parse
+    // state lives in per-thread caches and Mutex-guarded plain-data
+    // registries, no shared Ruby objects cross the boundary.
+    unsafe { rb_sys::rb_ext_ractor_safe(true) };
+
     // Initialize the parsanol-rs ffi::ruby module
     // This sets up Parsanol::Native with all the functions
     parsanol::ffi::ruby::init(ruby)

data/lib/parsanol/tree_diff.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Parsanol
+  # Explains the first difference between two parse trees.
+  #
+  # Built for engine-parity debugging (parsanol-ruby#83): when
+  # `tree_ruby != tree_native`, `TreeDiff.why` pinpoints the first
+  # divergent node instead of leaving you to eyeball two inspect
+  # dumps.
+  #
+  # @example
+  #   Parsanol::TreeDiff.why(ruby_tree, native_tree)
+  #   # => { path: "paragraph.lines",
+  #   #      why: "kind mismatch: Array vs Hash",
+  #   #      ruby: "Array(1)",
+  #   #      native: "Hash{text, line_break}" }
+  #
+  # Returns nil when the trees are equal.
+  module TreeDiff
+    module_function
+
+    def why(left, right, max_depth: 200)
+      step(left, right, [], 0, max_depth)
+    end
+
+    def step(left, right, path, depth, max_depth)
+      if depth > max_depth
+        return { path: format_path(path), why: "depth limit exceeded", ruby: kind(left),
+                 native: kind(right) }
+      end
+      containers = (left.is_a?(Hash) && right.is_a?(Hash)) ||
+        (left.is_a?(Array) && right.is_a?(Array))
+      # Containers always descend: Hash#== would short-circuit equal via
+      # Slice's content-only ==, hiding offset drift.
+      return nil if !containers && equal_values?(left, right)
+
+      if left.is_a?(Hash) && right.is_a?(Hash)
+        only_left = left.keys - right.keys
+        only_right = right.keys - left.keys
+        if only_left.any? || only_right.any?
+          return { path: format_path(path),
+                   why: "key mismatch: ruby-only #{only_left.inspect}, " \
+                        "native-only #{only_right.inspect}",
+                   ruby: kind(left), native: kind(right) }
+        end
+        left.each do |key, value|
+          if right.key?(key)
+            found = step(value, right[key], path + [key], depth + 1, max_depth)
+            return found if found
+          end
+        end
+        nil
+      elsif left.is_a?(Array) && right.is_a?(Array)
+        if left.length != right.length
+          return { path: format_path(path),
+                   why: "size mismatch: ruby #{left.length} vs native #{right.length}",
+                   ruby: "Array(#{left.length})", native: "Array(#{right.length})" }
+        end
+        left.each_with_index do |value, index|
+          found = step(value, right[index], path + ["[#{index}]"], depth + 1, max_depth)
+          return found if found
+        end
+        nil
+      elsif left.is_a?(::Parsanol::Slice) && right.is_a?(::Parsanol::Slice)
+        if left.content == right.content
+          { path: format_path(path),
+            why: "offset drift: #{left.offset} vs #{right.offset}",
+            ruby: kind(left), native: kind(right) }
+        else
+          { path: format_path(path),
+            why: "content mismatch: #{left.content.inspect} vs #{right.content.inspect}",
+            ruby: kind(left), native: kind(right) }
+        end
+      else
+        { path: format_path(path), why: "kind mismatch: #{kind(left)} vs #{kind(right)}",
+          ruby: kind(left), native: kind(right) }
+      end
+    end
+
+    # Equality for parity purposes: Slices must match on content AND
+    # offset (position drift is a real divergence), and a Slice never
+    # equals a plain String here even though Slice#== would allow it —
+    # engines that disagree on type disagree on the tree.
+    def equal_values?(left, right)
+      left_is_slice = left.is_a?(::Parsanol::Slice)
+      right_is_slice = right.is_a?(::Parsanol::Slice)
+      if left_is_slice || right_is_slice
+        left_is_slice && right_is_slice &&
+          left.content == right.content && left.offset == right.offset
+      else
+        left == right
+      end
+    end
+
+    def kind(item)
+      case item
+      when ::Parsanol::Slice then "Slice(#{item.content.inspect}@#{item.offset})"
+      when Hash then "Hash{#{item.keys.join(', ')}}"
+      when Array then "Array(#{item.length})"
+      when String then "String(#{item.inspect})"
+      when nil then "nil"
+      else item.class.name
+      end
+    end
+
+    def format_path(path)
+      path.each_with_index.inject(+"") do |acc, (part, i)|
+        if i.zero? || part.to_s.start_with?("[")
+          acc << part.to_s
+        else
+          acc << "." << part.to_s
+        end
+      end
+    end
+  end
+end

data/lib/parsanol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Parsanol
-  VERSION = "1.3.45"
+  VERSION = "1.3.46"
 end

data/lib/parsanol.rb

@@ -266,6 +266,7 @@ module Parsanol
 
   autoload :Expression, "parsanol/expression"
   autoload :IncrementalSession, "parsanol/incremental"
+  autoload :TreeDiff, "parsanol/tree_diff"
 end
 
 require "parsanol/version"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.45
+  version: 1.3.46
 platform: ruby
 authors:
 - Ribose Inc.
@@ -129,6 +129,7 @@ files:
 - lib/parsanol/streaming_parser.rb
 - lib/parsanol/string_view.rb
 - lib/parsanol/transform.rb
+- lib/parsanol/tree_diff.rb
 - lib/parsanol/version.rb
 - lib/parsanol/vm.rb
 - lib/parsanol/wasm/README.md