parsanol 1.3.49 → 1.3.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ba1ff94687c90184c892c44b7d301e66edb31a2d945323efd2a0ad82a26be21
-  data.tar.gz: '05090e440ad8c351564c9effb8057f4bb4e96da3405eb3502eb72501328f8ff2'
+  metadata.gz: 88619cb26e9e27d9a68e8bef60cc387a3d49bb0452d7dde483e35288965a9d31
+  data.tar.gz: 66565201383cac8685a5607e864fc09f2f0baacee46a734169adadefe9976663
 SHA512:
-  metadata.gz: 9259f394a917e14cb96f56d9b4de1bb7427231abe232dec3e469cfb777cf01482cb0263647cb6a7e64e66b344a1852b48b3d6fed959f736fc591075b091042b7
-  data.tar.gz: d094de19cb2781dcb69aecbbfd1c46d6c3307be63deb6f9979330427346e21b13573ee97ec2da04207f85c3b0027617e1cab4e94a46bfcaefa9644e18336058d
+  metadata.gz: bffa5d597bb727763303af4dd72ad3394809fbe68a4fafeebb4dc520028ac836eea366a42548f8f02c1a76158207ecfbe52ddb9b6ce627328f32b8d61a22724d
+  data.tar.gz: bd4a8e1daf6e626d4626b90fe59c0703bab00c3a78e593f69d3e46d24b68376b5bf6002108a6d4302fc158e72ba3fd804e9df70338c46291702ce0d51aa93764

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

@@ -123,10 +123,15 @@ 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)
 
@@ -137,45 +142,74 @@ module Parsanol
         # The Rust handle path tags with Symbols, the batch decoder with
         # ":repetition" Strings — accept both.
         is_tagged_repetition = value.is_a?(Array) && !value.empty? &&
-          [REPETITION_SYM, REPETITION_TAG].include?(value.first)
+          (value.first.equal?(REPETITION_SYM) || value.first == REPETITION_TAG)
 
         # 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 +224,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
@@ -313,12 +355,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 +428,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.50"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.49
+  version: 1.3.50
 platform: ruby
 authors:
 - Ribose Inc.