parsanol 1.3.5-aarch64-linux → 1.3.7-aarch64-linux

data/lib/parsanol/native/batch_decoder.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'parsanol/native/transformer'
+require "parsanol/native/transformer"
 
 module Parsanol
   module Native
@@ -59,7 +59,7 @@ module Parsanol
         # @param slice_class [Class] The Slice class to use
         # @param grammar_atom [Parsanol::Atoms::Base] The grammar atom (unused, kept for API compat)
         # @return [Object] Transformed Ruby AST
-        def decode_and_flatten(data, input, slice_class, grammar_atom)
+        def decode_and_flatten(data, input, slice_class, _grammar_atom)
           # Check if data is batch data (flat u64 array) or already a Ruby value
           if data.is_a?(Integer) || (data.is_a?(Array) && data.first.is_a?(Integer))
             # Batch data (flat u64 array) - decode first, then transform
@@ -84,11 +84,13 @@ module Parsanol
           case value
           when Array
             # Recursively process array elements
-            processed = value.map { |v| join_consecutive_slices(v, slice_class, input) }
+            processed = value.map do |v|
+              join_consecutive_slices(v, slice_class, input)
+            end
 
             # Check if all non-nil elements are Slices
             non_nil = processed.compact
-            if non_nil.all? { |v| v.is_a?(slice_class) }
+            if non_nil.all?(slice_class)
               # Check if slices are consecutive
               if slices_consecutive?(non_nil)
                 # Join into single slice
@@ -129,7 +131,7 @@ module Parsanol
           last = slices.last
           total_length = last.offset + last.content.bytesize - first.offset
           content = input_bytes[first.offset, total_length]
-          content = content.force_encoding('UTF-8') if content
+          content = content.force_encoding("UTF-8") if content
           slice_class.new(first.offset, content, input)
         end
 
@@ -156,7 +158,7 @@ module Parsanol
             bits = @data[@pos]
             @pos += 1
             # Convert IEEE 754 bits to float
-            [bits].pack('Q').unpack1('D')
+            [bits].pack("Q").unpack1("D")
           when TAG_STRING
             offset = @data[@pos]
             length = @data[@pos + 1]
@@ -203,6 +205,7 @@ module Parsanol
 
             # Read key
             raise "Expected TAG_HASH_KEY, got #{tag}" unless tag == TAG_HASH_KEY
+
             @pos += 1
             key = decode_inline_string
 
@@ -228,22 +231,23 @@ module Parsanol
         def decode_inline_string_bytes(len)
           # Read u64 chunks
           chunks = (len + 7) / 8
-          bytes = String.new(encoding: 'ASCII-8BIT', capacity: len)
+          bytes = String.new(encoding: "ASCII-8BIT", capacity: len)
           chunks.times do
             chunk = @data[@pos]
             @pos += 1
             8.times do |byte_idx|
               break if bytes.bytesize >= len
+
               bytes << ((chunk >> (byte_idx * 8)) & 0xFF)
             end
           end
 
-          bytes.force_encoding('UTF-8')
+          bytes.force_encoding("UTF-8")
         end
 
         def create_slice(offset, length)
           content = @input_bytes[offset, length]
-          content = content.force_encoding('UTF-8') if content
+          content = content.force_encoding("UTF-8") if content
           @slice_class.new(offset, content, @input)
         end
       end

data/lib/parsanol/native/dynamic.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
 
 module Parsanol
   module Native
@@ -49,13 +49,14 @@ module Parsanol
         #
         def register(block, description: nil)
           # Register with Rust FFI
-          ffi_id = Native.register_callback(@next_id, description || "Ruby callback ##{@next_id}")
+          ffi_id = Native.register_callback(@next_id,
+                                            description || "Ruby callback ##{@next_id}")
 
           # Also keep a Ruby-side reference for GC safety
           @mutex.synchronize do
             @callbacks[ffi_id] = {
               block: block,
-              description: description || "Ruby callback ##{ffi_id}"
+              description: description || "Ruby callback ##{ffi_id}",
             }
           end
 
@@ -136,7 +137,7 @@ module Parsanol
           ctx = DynamicContext.new(
             context[:input],
             context[:pos],
-            context[:captures].transform_keys(&:to_sym)
+            context[:captures].transform_keys(&:to_sym),
           )
 
           # Call the block
@@ -207,7 +208,7 @@ module Parsanol
       # @return [String] The remaining input
       #
       def remaining
-        @input[@pos..] || ''
+        @input[@pos..] || ""
       end
 
       # Check if at end of input
@@ -229,7 +230,7 @@ module Parsanol
         if length
           @input[@pos + start, length]
         else
-          @input[@pos + start..]
+          @input[(@pos + start)..]
         end
       end
     end

data/lib/parsanol/native/parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest'
+require "digest"
 
 module Parsanol
   module Native
@@ -17,11 +17,11 @@ module Parsanol
 
           @cached_available = begin
             # Try versioned path first (released gem), then non-versioned (local dev)
-            ruby_version = RUBY_VERSION.split('.').take(2).join('.')
+            ruby_version = RUBY_VERSION.split(".").take(2).join(".")
             begin
               require "parsanol/#{ruby_version}/parsanol_native"
             rescue LoadError
-              require 'parsanol/parsanol_native'
+              require "parsanol/parsanol_native"
             end
             Parsanol::Native.is_available
           rescue LoadError
@@ -54,7 +54,7 @@ module Parsanol
         def cache_stats
           {
             hash_cache_size: GRAMMAR_HASH_CACHE.size,
-            grammar_cache_size: GRAMMAR_CACHE.size
+            grammar_cache_size: GRAMMAR_CACHE.size,
           }
         end
 
@@ -70,6 +70,7 @@ module Parsanol
           if visited[obj_id]
             return [:cycle, atom.class.name]
           end
+
           visited[obj_id] = true
 
           case atom
@@ -89,7 +90,8 @@ module Parsanol
           when ::Parsanol::Atoms::Named
             [:named, atom.name.to_s, atom_structure(atom.parslet, visited)]
           when ::Parsanol::Atoms::Lookahead
-            [:lookahead, atom.positive, atom_structure(atom.bound_parslet, visited)]
+            [:lookahead, atom.positive,
+             atom_structure(atom.bound_parslet, visited)]
           else
             [:unknown, atom.class.name]
           end

data/lib/parsanol/native/serializer.rb

@@ -78,9 +78,9 @@ module Parsanol
 
     def serialize_str(atom)
       {
-        'Str' => {
-          'pattern' => atom.str
-        }
+        "Str" => {
+          "pattern" => atom.str,
+        },
       }
     end
 
@@ -90,46 +90,46 @@ module Parsanol
       pattern = atom.match
       pattern = ::Regexp.last_match(1) if pattern =~ /^\(\?[-mix]*:(.+)\)$/
       {
-        'Re' => {
-          'pattern' => pattern
-        }
+        "Re" => {
+          "pattern" => pattern,
+        },
       }
     end
 
     def serialize_sequence(atom)
       atom_ids = atom.parslets.map { |p| serialize_atom(p) }
       {
-        'Sequence' => {
-          'atoms' => atom_ids
-        }
+        "Sequence" => {
+          "atoms" => atom_ids,
+        },
       }
     end
 
     def serialize_alternative(atom)
       atom_ids = atom.alternatives.map { |p| serialize_atom(p) }
       {
-        'Alternative' => {
-          'atoms' => atom_ids
-        }
+        "Alternative" => {
+          "atoms" => atom_ids,
+        },
       }
     end
 
     def serialize_repetition(atom)
       {
-        'Repetition' => {
-          'atom' => serialize_atom(atom.parslet),
-          'min' => atom.min,
-          'max' => atom.max
-        }
+        "Repetition" => {
+          "atom" => serialize_atom(atom.parslet),
+          "min" => atom.min,
+          "max" => atom.max,
+        },
       }
     end
 
     def serialize_named(atom)
       {
-        'Named' => {
-          'name' => atom.name.to_s,
-          'atom' => serialize_atom(atom.parslet)
-        }
+        "Named" => {
+          "name" => atom.name.to_s,
+          "atom" => serialize_atom(atom.parslet),
+        },
       }
     end
 
@@ -169,7 +169,7 @@ module Parsanol
                        serialize_named(parslet)
                      when Parsanol::Atoms::Entity
                        # Nested entity - just reference it via serialize_atom
-                       { 'Entity' => { 'atom' => serialize_atom(parslet) } }
+                       { "Entity" => { "atom" => serialize_atom(parslet) } }
                      when Parsanol::Atoms::Lookahead
                        serialize_lookahead(parslet)
                      else
@@ -181,9 +181,9 @@ module Parsanol
       else
         # If the entity's block returns nil, create a placeholder that will fail
         @atoms[atom_id] = {
-          'Str' => {
-            'pattern' => "\x00__UNIMPLEMENTED_ENTITY_#{atom.name}__"
-          }
+          "Str" => {
+            "pattern" => "\x00__UNIMPLEMENTED_ENTITY_#{atom.name}__",
+          },
         }
       end
       atom_id
@@ -191,10 +191,10 @@ module Parsanol
 
     def serialize_lookahead(atom)
       {
-        'Lookahead' => {
-          'atom' => serialize_atom(atom.bound_parslet),
-          'positive' => atom.positive
-        }
+        "Lookahead" => {
+          "atom" => serialize_atom(atom.bound_parslet),
+          "positive" => atom.positive,
+        },
       }
     end
 
@@ -202,10 +202,10 @@ module Parsanol
       # Capture stores matched text for later reference by Dynamic atoms.
       # Now properly serialized for native parser support (parsanol-rs 0.3.0+).
       {
-        'Capture' => {
-          'name' => atom.capture_key.to_s,
-          'atom' => serialize_atom(atom.inner_atom)
-        }
+        "Capture" => {
+          "name" => atom.capture_key.to_s,
+          "atom" => serialize_atom(atom.inner_atom),
+        },
       }
     end
 
@@ -220,9 +220,9 @@ module Parsanol
       return serialize_unknown(atom) unless inner
 
       {
-        'Scope' => {
-          'atom' => serialize_atom(inner)
-        }
+        "Scope" => {
+          "atom" => serialize_atom(inner),
+        },
       }
     end
 
@@ -232,9 +232,9 @@ module Parsanol
       callback_id = Parsanol::Native::Dynamic.register(atom.block)
 
       {
-        'Dynamic' => {
-          'callback_id' => callback_id
-        }
+        "Dynamic" => {
+          "callback_id" => callback_id,
+        },
       }
     end
 
@@ -242,9 +242,9 @@ module Parsanol
       # For unsupported atom types, create a placeholder
       # This will cause a parse error at runtime
       {
-        'Str' => {
-          'pattern' => '' # Empty pattern that will never match
-        }
+        "Str" => {
+          "pattern" => "", # Empty pattern that will never match
+        },
       }
     end
   end

data/lib/parsanol/native/transformer.rb

@@ -18,9 +18,9 @@ module Parsanol
     #
     class AstTransformer
       # Frozen string constants for tag comparisons (avoid allocations)
-      SEQUENCE_TAG = ':sequence'
-      REPETITION_TAG = ':repetition'
-      EMPTY_STRING = ''
+      SEQUENCE_TAG = ":sequence"
+      REPETITION_TAG = ":repetition"
+      EMPTY_STRING = ""
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze
 
@@ -62,7 +62,7 @@ module Parsanol
         # Check if this is a tagged array from native parser
         # Native parser produces Symbol tags: [:sequence, item1, item2, ...]
         first = arr.first
-        if first == SEQUENCE_SYM || first == SEQUENCE_TAG
+        if [SEQUENCE_SYM, SEQUENCE_TAG].include?(first)
           # Optimized: transform items starting from index 1
           # Avoid creating arr[1..] slice
           len = arr.length
@@ -75,7 +75,7 @@ module Parsanol
             i += 1
           end
           flatten_sequence(items)
-        elsif first == REPETITION_SYM || first == REPETITION_TAG
+        elsif [REPETITION_SYM, REPETITION_TAG].include?(first)
           # Optimized: transform items starting from index 1
           len = arr.length
           return EMPTY_ARRAY if len == 1
@@ -87,7 +87,7 @@ module Parsanol
             i += 1
           end
           flatten_repetition(items)
-        elsif first.is_a?(Symbol) || (first.is_a?(String) && first.start_with?(':'))
+        elsif first.is_a?(Symbol) || (first.is_a?(String) && first.start_with?(":"))
           # Other tagged arrays - pass through
           arr.map { |item| transform(item) }
         else
@@ -119,13 +119,15 @@ module Parsanol
 
         # Check if value is a tagged repetition from native parser
         is_tagged_repetition = value.is_a?(Array) && !value.empty? &&
-                               value.first.is_a?(String) && value.first == REPETITION_TAG
+          value.first.is_a?(String) && 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? { |item| item.is_a?(Hash) && item.keys.length == 1 && item.key?(key) }
+          value.all? do |item|
+            item.is_a?(Hash) && item.keys.length == 1 && item.key?(key)
+          end
 
         # Empty array from native parser is a repetition result (not a sequence)
         # Sequences produce arrays of arrays like [[], []], not empty arrays
@@ -134,12 +136,15 @@ module Parsanol
         # 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? { |item| slice_or_string?(item) && item_length(item) == 1 }
+            transformed.all? do |item|
+              slice_or_string?(item) && item_length(item) == 1
+            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)
+                          ::Parsanol::Slice.new(first_slice.offset, content,
+                                                first_slice.input)
                         else
                           content
                         end
@@ -148,9 +153,9 @@ module Parsanol
         # 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)
-                                    end
+          transformed.all? do |item|
+            item.is_a?(Hash) && item.keys.length == 1 && item.key?(sym_key)
+          end
 
         is_repetition = is_tagged_repetition || is_raw_array_repetition || is_transformed_repetition || is_empty_repetition
 
@@ -184,7 +189,9 @@ module Parsanol
           if transformed.empty?
             { sym_key => EMPTY_ARRAY }
           # Check if items already have the same key (avoid double-wrapping)
-          elsif transformed.all? { |item| item.is_a?(Hash) && item.key?(sym_key) }
+          elsif transformed.all? do |item|
+            item.is_a?(Hash) && item.key?(sym_key)
+          end
             { sym_key => transformed }
           else
             # Wrap each item with the name
@@ -207,7 +214,9 @@ module Parsanol
           # We can't tell from the value alone, so we return empty Slice (sequence semantics)
           # The repetition detection in transform_single_key_hash will handle the other case
           { sym_key => ::Parsanol::Slice.new(0, EMPTY_STRING, nil) }
-        elsif transformed.all? { |v| v.is_a?(Hash) && v.keys.length == 1 && v.key?(sym_key) }
+        elsif transformed.all? do |v|
+          v.is_a?(Hash) && v.keys.length == 1 && v.key?(sym_key)
+        end
           # Items already have the parent key (repetition pattern) - keep as-is
           { sym_key => transformed }
         elsif transformed.all?(Hash)
@@ -229,13 +238,15 @@ 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.is_a?(String) && value.first == REPETITION_TAG
 
           transformed = transform(value)
 
           result[sym_key] = if is_repetition
                               if transformed.is_a?(Array)
-                                if transformed.all? { |item| item.is_a?(Hash) && item.key?(sym_key) }
+                                if transformed.all? do |item|
+                                  item.is_a?(Hash) && item.key?(sym_key)
+                                end
                                   transformed
                                 else
                                   transformed.map { |item| { sym_key => item } }
@@ -308,7 +319,7 @@ module Parsanol
             else
               # Check if array contains only hashes (repetition wrapper pattern)
               # In this case, merge the inner hashes into merged_hash
-              non_hash_items = item.reject { |sub| sub.is_a?(Hash) }
+              non_hash_items = item.grep_v(Hash)
               all_items_are_hashes = non_hash_items.empty?
 
               if all_items_are_hashes
@@ -399,12 +410,16 @@ module Parsanol
               # REPETITION pattern (same keys like entity_decl): keep as array
               # WRAPPER pattern (different keys like spaces vs schemaDecl): merge
               first_inner_keys = items.first[wrapper_key].keys.to_set
-              all_same_keys = items.all? { |item| item[wrapper_key].keys.to_set == first_inner_keys }
+              items.all? do |item|
+                item[wrapper_key].keys.to_set == first_inner_keys
+              end
 
               # Check if items have single keys or multiple keys
               # - Single key items with repeated outer key = true repetition (keep array)
               # - Multiple key items with repeated outer key = duplicate labels in sequence (merge)
-              max_keys_per_item = items.map { |item| item.is_a?(Hash) ? item.keys.length : 0 }.max || 0
+              max_keys_per_item = items.map do |item|
+                item.is_a?(Hash) ? item.keys.length : 0
+              end.max || 0
 
               # Check if inner values are hashes with different keys
               # This distinguishes:
@@ -412,9 +427,13 @@ module Parsanol
               # - Duplicate labels: [{group: {char: 'a'}}, {group: {digit: '5'}}] - inner is hash with different keys
               inner_keys_all_same = true
               first_inner_keys = nil
-              if items.all? { |item| item.is_a?(Hash) && item[wrapper_key].is_a?(Hash) }
+              if items.all? do |item|
+                item.is_a?(Hash) && item[wrapper_key].is_a?(Hash)
+              end
                 first_inner_keys = items.first[wrapper_key].keys.to_set
-                inner_keys_all_same = items.all? { |item| item[wrapper_key].keys.to_set == first_inner_keys }
+                inner_keys_all_same = items.all? do |item|
+                  item[wrapper_key].keys.to_set == first_inner_keys
+                end
               end
 
               # DUPLICATE LABELS IN SEQUENCE: multiple keys per item with repeated outer key
@@ -426,7 +445,9 @@ module Parsanol
 
               # Check if inner hashes have the same keys or different keys
               first_inner_keys ||= items.first[wrapper_key].keys.to_set
-              all_same_keys = items.all? { |item| item[wrapper_key].keys.to_set == first_inner_keys }
+              all_same_keys = items.all? do |item|
+                item[wrapper_key].keys.to_set == first_inner_keys
+              end
 
               if has_duplicate_labels
                 # DUPLICATE LABELS PATTERN: items have multiple keys with repeated outer key
@@ -436,7 +457,7 @@ module Parsanol
                 merged = {}
                 items.each do |item|
                   item.each do |k, v|
-                    merged[k] = v  # Last value wins
+                    merged[k] = v # Last value wins
                   end
                 end
                 # Return only the wrapper key with its last value
@@ -475,11 +496,14 @@ module Parsanol
         if slice_or_string_parts.any?
           # Join Slices/strings, preserving position from first Slice
           first_slice = slice_or_string_parts.find { |i| i.is_a?(::Parsanol::Slice) }
-          content = slice_or_string_parts.map { |i| i.is_a?(::Parsanol::Slice) ? i.content : i }.join
+          content = slice_or_string_parts.map do |i|
+            i.is_a?(::Parsanol::Slice) ? i.content : i
+          end.join
 
           if first_slice
             # Create new Slice with combined content, preserving position from first
-            return ::Parsanol::Slice.new(first_slice.offset, content, first_slice.input)
+            return ::Parsanol::Slice.new(first_slice.offset, content,
+                                         first_slice.input)
           else
             # All plain strings (shouldn't happen with new decode_flat, but handle it)
             return slice_or_string_parts.length == 1 ? slice_or_string_parts.first : content
@@ -520,11 +544,14 @@ module Parsanol
         # If all Slices or strings, join them preserving position from first Slice
         if all_slices_or_strings
           first_slice = flat_items.find { |i| i.is_a?(::Parsanol::Slice) }
-          content = flat_items.map { |i| i.is_a?(::Parsanol::Slice) ? i.content : i }.join
+          content = flat_items.map do |i|
+            i.is_a?(::Parsanol::Slice) ? i.content : i
+          end.join
 
           if first_slice
             # Create new Slice with combined content, preserving position from first
-            ::Parsanol::Slice.new(first_slice.offset, content, first_slice.input)
+            ::Parsanol::Slice.new(first_slice.offset, content,
+                                  first_slice.input)
           else
             # All plain strings (shouldn't happen with new decode_flat, but handle it)
             content

data/lib/parsanol/native/types.rb

@@ -19,9 +19,9 @@ module Parsanol
       TAG_INLINE_STRING = 0x0A
 
       # Frozen string constants for transformer (avoid allocations)
-      SEQUENCE_TAG = ':sequence'
-      REPETITION_TAG = ':repetition'
-      EMPTY_STRING = ''
+      SEQUENCE_TAG = ":sequence"
+      REPETITION_TAG = ":repetition"
+      EMPTY_STRING = ""
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze
     end