parsanol 1.3.49 → 1.3.51

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ba1ff94687c90184c892c44b7d301e66edb31a2d945323efd2a0ad82a26be21
-  data.tar.gz: '05090e440ad8c351564c9effb8057f4bb4e96da3405eb3502eb72501328f8ff2'
+  metadata.gz: ee4e171a9217d66e90cc5c3cd51fb9af8d901ec7de75182e68e90caf3bbefb57
+  data.tar.gz: bb5e4f0391b98f79e86614f7a53158bdbe8cc12feb39a43ff94bcb553706bb75
 SHA512:
-  metadata.gz: 9259f394a917e14cb96f56d9b4de1bb7427231abe232dec3e469cfb777cf01482cb0263647cb6a7e64e66b344a1852b48b3d6fed959f736fc591075b091042b7
-  data.tar.gz: d094de19cb2781dcb69aecbbfd1c46d6c3307be63deb6f9979330427346e21b13573ee97ec2da04207f85c3b0027617e1cab4e94a46bfcaefa9644e18336058d
+  metadata.gz: c1cda8632038653dc853bece92e4f804c267fe43f8146cda3fc8481ad031c8087293f965274e12a173da881ad34ec370db71906ede1a1f89ebe52058e08440ba
+  data.tar.gz: f2f5c8f67bbd0c6d444593f41551c32f165d99725e17c37ee6475dfd858a4f6887f7185657f4c0c44b3a232a4b66795742a18ddd134b0afd757b0c7b6b0e181f

data/Cargo.lock

@@ -139,9 +139,9 @@ checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b"
 
 [[package]]
 name = "hashbrown"
-version = "0.16.1"
+version = "0.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
 dependencies = [
  "allocator-api2",
  "equivalent",
@@ -252,9 +252,9 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "parsanol"
-version = "0.8.5"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a57413139c7aacd6343dbcd65985eceaebcf9d61dfa73222e5d0d7b527a581b"
+checksum = "5709d5bc971fa4e28fccf401709ab1d275d180e447e3ab82fde7ebef2ecc787b"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -269,13 +269,20 @@ dependencies = [
 
 [[package]]
 name = "parsanol-derive"
-version = "0.8.5"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e33d7bd1f1644da4ee51892fc3289ec89826a59e692a4f7076a40dd8ba74672"
+checksum = "93258404b7032b85dffd9a60e3fb1ed003a268282b4f3385f1ab1aba98db34e5"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.119",
+ "syn 3.0.6",
+]
+
+[[package]]
+name = "parsanol_cdylib"
+version = "1.3.50"
+dependencies = [
+ "parsanol",
 ]
 
 [[package]]

data/Cargo.toml

@@ -1,6 +1,6 @@
 [workspace]
 resolver = "2"
-members = ["ext/parsanol_native"]
+members = ["ext/parsanol_native", "ext/parsanol_cdylib"]
 
 [profile.release]
 opt-level = 3

data/Rakefile

@@ -64,6 +64,25 @@ namespace :gem do
     sh "rake gem:platform:any gem"
   end
 
+  # Vendor the pure-portable cdylib into PLATFORM gems (TODO.perf/9):
+  # the ruby (source) gem stays binary-free; each cross-gem carries its
+  # own triple's libparsanol next to the extension for the ffi tier
+  # (MRI resilience fallback, TruffleRuby native).
+  desc "Build ext/parsanol_cdylib for the active cross target and vendor it"
+  task "vendor_cdylib" do
+    triplet = ENV["CARGO_BUILD_TARGET"] || ENV.fetch("RUST_TARGET", nil)
+    args = ["cargo", "build", "--release", "-p", "parsanol_cdylib"]
+    args += ["--target", triplet] if triplet
+    sh(*args)
+    dir = triplet ? "target/#{triplet}/release" : "target/release"
+    name = %w[libparsanol.so libparsanol.dylib parsanol.dll]
+      .map { |n| File.join(dir, n) }
+      .find { |f| File.file?(f) }
+    raise "cdylib not found under #{dir}" unless name
+
+    cp name, "lib/parsanol/native/"
+  end
+
   desc "Define the gem task to build on any platform (compile on install)"
   task "platform:any" do
     spec = Gem::Specification.load("parsanol.gemspec").dup

data/ext/parsanol_cdylib/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "parsanol_cdylib"
+version = "1.3.51"
+edition = "2021"
+description = "Vendored cdylib for parsanol platform gems: the pure-portable C ABI (no magnus) for the ffi tier"
+license = "MIT"
+publish = false
+
+[lib]
+name = "parsanol"
+crate-type = ["cdylib"]
+doc = false
+
+[dependencies]
+parsanol = { version = "0.8.8" }

data/ext/parsanol_cdylib/src/lib.rs

@@ -0,0 +1,12 @@
+//! Vendored cdylib twin of parsanol-rs's `parsanol-ffi` crate, living in
+//! the gem's ext workspace so the cross-gem build matrix can compile it
+//! per platform triple. Mirrors parsanol-ffi: linking the rlib publishes
+//! the `#[no_mangle] parsanol_c_*` exports; no wrappers.
+
+// Force the dependency into the link even under aggressive stripping.
+// Keep in sync with parsanol-rs parsanol-ffi/src/lib.rs.
+#[allow(unused_imports)]
+use parsanol::ffi::c::{
+    parsanol_c_last_error, parsanol_c_parse, parsanol_c_parse_len, parsanol_c_register,
+    parsanol_c_release,
+};

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.5", features = ["ruby"] }
+parsanol = { version = "0.8.8", features = ["ruby"] }
 
 # Logging
 log = "0.4"

data/lib/parsanol/native/ffi.rb

@@ -97,8 +97,13 @@ module Parsanol
             ffi_lib path
             attach_function :c_register, :parsanol_c_register,
                             %i[string], :uint64
-            attach_function :c_parse, :parsanol_c_parse,
-                            %i[uint64 string pointer size_t], :long_long
+            # Explicit-length entry point: interior NULs stay intact. The
+            # input crosses as a raw buffer (:string rejects NUL bytes by
+            # design); a cdylib without the symbol is stale relative to
+            # this binding and fails availability loudly (pure-Ruby
+            # fallback) instead of silently truncating at NULs.
+            attach_function :c_parse_len, :parsanol_c_parse_len,
+                            %i[uint64 buffer_in size_t pointer size_t], :long_long
             attach_function :c_last_error, :parsanol_c_last_error,
                             [], :string
             attach_function :c_release, :parsanol_c_release,
@@ -114,9 +119,10 @@ module Parsanol
 
         # Two-call buffer protocol: cap=0 asks for the needed size, then
         # the batch lands in a persistent buffer that only grows —
-        # steady-state parses allocate nothing.
+        # steady-state parses allocate nothing. The explicit-length call
+        # keeps interior NULs intact.
         def parse_into(handle, input)
-          needed = @binding.c_parse(handle, input, nil, 0)
+          needed = @binding.c_parse_len(handle, input, input.bytesize, nil, 0)
           return needed unless needed.negative?
 
           cap = -needed
@@ -124,7 +130,7 @@ module Parsanol
             @buffer&.free
             @buffer = FFI::MemoryPointer.new(:uint64, cap * 2)
           end
-          @binding.c_parse(handle, input, @buffer, cap)
+          @binding.c_parse_len(handle, input, input.bytesize, @buffer, cap)
         end
       end
     end

data/lib/parsanol/native/transformer.rb

@@ -18,8 +18,6 @@ module Parsanol
     #
     class AstTransformer
       # Frozen string constants for tag comparisons (avoid allocations)
-      SEQUENCE_TAG = ":sequence"
-      REPETITION_TAG = ":repetition"
       EMPTY_STRING = ""
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze
@@ -28,11 +26,12 @@ module Parsanol
       # This is a class variable to share across all transformations
       @@symbol_cache = {}
 
-      # Symbol tags from native parser
+      # Envelope tags. Both tiers (extension objects and the flat-u64
+      # batch wire) deliver Symbols — the encoder writes ':'-prefixed
+      # strings as TAG_SYMBOL — so there is exactly one tag form.
       SEQUENCE_SYM = :sequence
       REPETITION_SYM = :repetition
       MAYBE_SYM = :maybe
-      MAYBE_TAG = ":maybe"
 
       # `named` mirrors CanFlatten#flatten's named flag: inside a Named
       # result (.as), an absent maybe flattens to nil; unnamed it flattens
@@ -67,7 +66,8 @@ module Parsanol
         # Check if this is a tagged array from native parser
         # Native parser produces Symbol tags: [:sequence, item1, item2, ...]
         first = arr.first
-        if [SEQUENCE_SYM, SEQUENCE_TAG].include?(first)
+        case first
+        when SEQUENCE_SYM
           # Optimized: transform items starting from index 1
           # Avoid creating arr[1..] slice
           len = arr.length
@@ -80,7 +80,7 @@ module Parsanol
             i += 1
           end
           flatten_sequence(items)
-        elsif [REPETITION_SYM, REPETITION_TAG].include?(first)
+        when REPETITION_SYM
           # Optimized: transform items starting from index 1
           len = arr.length
           # Empty repetition: named → [], unnamed → "" (CanFlatten#flatten_repetition)
@@ -93,7 +93,7 @@ module Parsanol
             i += 1
           end
           flatten_repetition(items, named: named)
-        elsif [MAYBE_SYM, MAYBE_TAG].include?(first)
+        when MAYBE_SYM
           # Maybe flattens to nil-or-value (named) or ""-or-value (unnamed),
           # never to an array
           len = arr.length
@@ -103,7 +103,7 @@ module Parsanol
             flattened = transform(arr[1])
             named ? flattened : (flattened || EMPTY_STRING)
           end
-        elsif first.is_a?(Symbol) || (first.is_a?(String) && first.start_with?(":"))
+        when Symbol
           # Other tagged arrays - pass through
           arr.map { |item| transform(item) }
         else
@@ -123,59 +123,92 @@ module Parsanol
         transform_multi_key_hash(hash)
       end
 
-      # Optimized handling for single-key hashes (the common case)
+      # Optimized handling for single-key hashes (the common case).
+      # The shape scans below are fused into as few passes as possible:
+      # each predicate was previously its own `all?` walk with a lambda
+      # dispatch, and `item.keys.length` allocated a keys array per
+      # element (Hash#length is O(1)).
       def self.transform_single_key_hash(hash)
-        # Extract the single key-value pair without iteration
-        key = hash.keys.first
+        # Extract the single key-value pair without iterating (the hash
+        # is guaranteed single-key by the caller).
+        key, = hash.first
         value = hash[key]
         sym_key = cached_symbol(key)
 
         # Transform the value
         transformed = transform(value, named: true)
 
-        # Check if value is a tagged repetition from native parser.
-        # The Rust handle path tags with Symbols, the batch decoder with
-        # ":repetition" Strings — accept both.
+        # Tagged repetition from the native parser (Symbol tag; both
+        # tiers deliver the same form).
         is_tagged_repetition = value.is_a?(Array) && !value.empty? &&
-          [REPETITION_SYM, REPETITION_TAG].include?(value.first)
+          value.first.equal?(REPETITION_SYM)
 
         # Check RAW value for repetition pattern BEFORE transformation
-        # Array with items that all have the parent key
-        # e.g., [{x: 1}, {x: 2}] where parent key is :x
-        is_raw_array_repetition = value.is_a?(Array) && !value.empty? &&
-          value.all? do |item|
-            item.is_a?(Hash) && item.keys.length == 1 && item.key?(key)
-          end
+        # (bare repeated sibling captures, #36): array items that all
+        # carry the parent key, e.g. [{x: 1}, {x: 2}].
+        is_raw_array_repetition = false
+        if value.is_a?(Array) && !value.empty? && !is_tagged_repetition
+          is_raw_array_repetition = raw_items_all_named?(value, key)
+        end
 
         # Empty array from native parser is a repetition result (not a sequence)
         # Sequences produce arrays of arrays like [[], []], not empty arrays
         is_empty_repetition = value.is_a?(Array) && value.empty?
 
-        # Special handling for arrays that look like character repetitions
-        # (arrays of single-character Slices/strings should be joined)
-        if transformed.is_a?(Array) && !transformed.empty? &&
-            transformed.all? do |item|
-              slice_or_string?(item) && item_length(item) == 1
+        # Single fused pass over the transformed array: detect the
+        # single-character join shape AND the untagged repetition shape
+        # in one walk (an element cannot be both a Hash and a
+        # single-character stringlike, so the predicates share a loop).
+        joined = nil
+        is_transformed_repetition = false
+        if transformed.is_a?(Array) && !transformed.empty?
+          all_named = true
+          all_single_char = true
+          content = nil
+          first_slice = nil
+          transformed.each do |item|
+            if item.is_a?(Hash)
+              all_single_char = false
+              unless item.length == 1 && item.key?(sym_key)
+                all_named = false
+                break
+              end
+            elsif item.is_a?(::Parsanol::Slice) || item.is_a?(String)
+              all_named = false
+              all_single_char = false unless item.length == 1
+              break if !all_single_char && !all_named
+            else
+              all_named = false
+              all_single_char = false
+              break
             end
-          # Join preserving position from first Slice
-          first_slice = transformed.find { |i| i.is_a?(::Parsanol::Slice) }
-          content = transformed.map { |i| slice_content(i) }.join
-          transformed = if first_slice
-                          ::Parsanol::Slice.new(first_slice.offset, content,
-                                                first_slice.input)
-                        else
-                          content
-                        end
-        end
+          end
 
-        # Check for UNTAGGED repetition pattern (native output):
-        # If array items all have the same key as parent, it's a repetition
-        is_transformed_repetition = transformed.is_a?(Array) && !transformed.empty? &&
-          transformed.all? do |item|
-            item.is_a?(Hash) && item.keys.length == 1 && item.key?(sym_key)
+          if all_single_char
+            # Join preserving position from the first Slice
+            content = +""
+            transformed.each do |item|
+              if item.is_a?(::Parsanol::Slice)
+                first_slice ||= item
+                content << item.content
+              else
+                content << item.to_s
+              end
+            end
+            joined = if first_slice
+                       ::Parsanol::Slice.new(first_slice.offset,
+                                             content, first_slice.input)
+                     else
+                       content
+                     end
+          elsif all_named
+            is_transformed_repetition = true
           end
+        end
 
-        is_repetition = is_tagged_repetition || is_raw_array_repetition || is_transformed_repetition || is_empty_repetition
+        transformed = joined if joined
+        is_repetition = is_tagged_repetition || is_raw_array_repetition ||
+          is_transformed_repetition || is_empty_repetition
 
         # Handle based on type
         if is_repetition
@@ -190,6 +223,14 @@ module Parsanol
         end
       end
 
+      # Alloc-free raw repetition scan: Hash#length instead of
+      # item.keys.length (which allocated per element).
+      def self.raw_items_all_named?(value, key)
+        value.all? do |item|
+          item.is_a?(Hash) && item.length == 1 && item.key?(key)
+        end
+      end
+
       # Get content from Slice or string
       def self.slice_content(value)
         value.is_a?(::Parsanol::Slice) ? value.content : value.to_s
@@ -255,7 +296,7 @@ module Parsanol
           sym_key = cached_symbol(key)
 
           is_repetition = value.is_a?(Array) && !value.empty? &&
-            value.first.is_a?(String) && value.first == REPETITION_TAG
+            value.first.equal?(REPETITION_SYM)
 
           transformed = transform(value, named: true)
 
@@ -313,12 +354,26 @@ module Parsanol
           return list.reduce { |acc, hash| acc.merge(hash) }
         end
 
-        # Hot path: all stringlike (String/Slice). Build one Slice
-        # from the first Slice's offset, joining contents in place.
-        if list.all? { |x| x.is_a?(::Parsanol::Slice) || x.is_a?(String) }
-          first_slice = list.find { |x| x.is_a?(::Parsanol::Slice) }
-          content = list.map { |x| x.is_a?(::Parsanol::Slice) ? x.content : x.to_s }.join
-          return first_slice ? ::Parsanol::Slice.new(first_slice.offset, content, first_slice.input) : content
+        # Hot path: all stringlike (String/Slice). One fused pass detects
+        # the shape and joins contents in place (no per-item lambda
+        # dispatch, no intermediate map array).
+        content = +""
+        first_slice = nil
+        all_stringlike = list.all? do |x|
+          if x.is_a?(::Parsanol::Slice)
+            first_slice ||= x
+            content << x.content
+            true
+          elsif x.is_a?(String)
+            content << x
+            true
+          else
+            false
+          end
+        end
+        if all_stringlike
+          return first_slice ? ::Parsanol::Slice.new(first_slice.offset, content,
+                                                     first_slice.input) : content
         end
 
         # Cold path: parslet's exact fold (Hash/Slice/String/Array
@@ -372,14 +427,29 @@ module Parsanol
 
         return EMPTY_ARRAY if named && items.empty?
 
-        # Hot path: all-stringlike repetition → foldl via concat.
+        # Hot path: all-stringlike repetition → fused single-pass concat.
         # Cold path: parslet's exact fold.
-        if items.all? { |x| x.is_a?(::Parsanol::Slice) || x.is_a?(String) }
-          return EMPTY_STRING if items.empty?
+        if items.empty?
+          return EMPTY_STRING
+        end
 
-          first_slice = items.find { |x| x.is_a?(::Parsanol::Slice) }
-          content = items.map { |x| x.is_a?(::Parsanol::Slice) ? x.content : x.to_s }.join
-          return first_slice ? ::Parsanol::Slice.new(first_slice.offset, content, first_slice.input) : content
+        content = +""
+        first_slice = nil
+        all_stringlike = items.all? do |x|
+          if x.is_a?(::Parsanol::Slice)
+            first_slice ||= x
+            content << x.content
+            true
+          elsif x.is_a?(String)
+            content << x
+            true
+          else
+            false
+          end
+        end
+        if all_stringlike
+          return first_slice ? ::Parsanol::Slice.new(first_slice.offset, content,
+                                                     first_slice.input) : content
         end
 
         foldl(items.compact) { |acc, item| acc + item }

data/lib/parsanol/version.rb

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

data/parsanol.gemspec

@@ -39,7 +39,17 @@ Gem::Specification.new do |spec|
     Cargo.lock
   ]
   spec.files.reject! { |f| File.directory?(f) }
-  spec.files.reject! { |f| f =~ /\.(dll|so|dylib|lib|bundle)\Z/ }
+  # Cargo build trees are never gem content (a dirty local
+  # ext/parsanol_native/target once inflated a build to 218 MB).
+  spec.files.reject! { |f| f.include?("/target/") || f.start_with?("target/") }
+  # Binaries are never tracked in git, and the ruby (source) gem stays
+  # slim: the pure-portable cdylib is vendored ONLY into platform gems
+  # by the cross-gem build (rake gem:vendor_cdylib), never by a plain
+  # `gem build`.
+  spec.files.reject! do |f|
+    f =~ /\.(dll|so|dylib|lib|bundle)\Z/ &&
+      !(ENV["PARSANOL_VENDOR_CDYLIB"] == "1" && f.start_with?("lib/parsanol/native/"))
+  end
   spec.require_paths = ["lib"]
 
   spec.required_ruby_version = ">= 3.2.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.49
+  version: 1.3.51
 platform: ruby
 authors:
 - Ribose Inc.
@@ -40,6 +40,8 @@ files:
 - LICENSE
 - README.adoc
 - Rakefile
+- ext/parsanol_cdylib/Cargo.toml
+- ext/parsanol_cdylib/src/lib.rs
 - ext/parsanol_native/Cargo.toml
 - ext/parsanol_native/extconf.rb
 - ext/parsanol_native/src/lib.rs