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

data/lib/parsanol/native.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'digest'
+require "json"
+require "digest"
 
-require 'parsanol/native/types'
-require 'parsanol/native/parser'
-require 'parsanol/native/serializer'
-require 'parsanol/native/batch_decoder'
+require "parsanol/native/types"
+require "parsanol/native/parser"
+require "parsanol/native/serializer"
+require "parsanol/native/batch_decoder"
 
 module Parsanol
   module Native
-    VERSION = '0.1.0'
+    VERSION = "0.1.0"
 
     class << self
       # Check if native extension is available
@@ -53,7 +53,8 @@ module Parsanol
         # The batch format doesn't preserve :repetition/:sequence tags, so we use
         # the direct FFI path. Apply the Ruby transformer to handle tags correctly.
         raw_ast = _parse_raw(grammar_json, input)
-        BatchDecoder.decode_and_flatten(raw_ast, input, Parsanol::Slice, grammar_atom)
+        BatchDecoder.decode_and_flatten(raw_ast, input, Parsanol::Slice,
+                                        grammar_atom)
       end
 
       # Parse and return RAW AST without transformation.
@@ -76,11 +77,11 @@ module Parsanol
         raise LoadError, "Native parser not available" unless available?
 
         # Handle both grammar atoms and pre-serialized JSON strings
-        if grammar.is_a?(String)
-          grammar_json = grammar
-        else
-          grammar_json = Parser.serialize_grammar(grammar)
-        end
+        grammar_json = if grammar.is_a?(String)
+                         grammar
+                       else
+                         Parser.serialize_grammar(grammar)
+                       end
 
         # Use batch_raw format for raw AST (no transformation)
         slice_class = Parsanol::Slice
@@ -112,11 +113,6 @@ module Parsanol
         BatchDecoder.decode(batch_data, input, slice_class)
       end
 
-      # Get the Slice class
-      private def get_slice_class
-        Parsanol::Slice
-      end
-
       # Serialize a Ruby grammar to JSON (cached).
       #
       # @param root_atom [Parsanol::Atoms::Base] Root atom of the grammar
@@ -139,6 +135,7 @@ module Parsanol
       # @return [nil]
       def clear_grammar_cache
         raise LoadError, "Native parser not available" unless available?
+
         _clear_grammar_cache
       end
 
@@ -147,6 +144,7 @@ module Parsanol
       # @return [Integer] Number of cached grammars
       def grammar_cache_size
         raise LoadError, "Native parser not available" unless available?
+
         _grammar_cache_size
       end
 
@@ -155,6 +153,7 @@ module Parsanol
       # @return [Integer] Maximum cache capacity
       def grammar_cache_capacity
         raise LoadError, "Native parser not available" unless available?
+
         _grammar_cache_capacity
       end
 
@@ -167,17 +166,24 @@ module Parsanol
         end
         stats
       end
+
+      private
+
+      # Get the Slice class
+      def get_slice_class
+        Parsanol::Slice
+      end
     end
   end
 end
 
 # Attempt to load native extension
 begin
-  ruby_version = RUBY_VERSION.split('.').take(2).join('.')
+  ruby_version = RUBY_VERSION.split(".").take(2).join(".")
   require "parsanol/#{ruby_version}/parsanol_native"
 rescue LoadError
   begin
-    require 'parsanol/parsanol_native'
+    require "parsanol/parsanol_native"
   rescue LoadError
     # Native extension not built yet
   end

data/lib/parsanol/optimizer.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'ast_visitor'
-require_relative 'optimizers/quantifier_optimizer'
-require_relative 'optimizers/sequence_optimizer'
-require_relative 'optimizers/choice_optimizer'
-require_relative 'optimizers/lookahead_optimizer'
-require_relative 'optimizers/cut_inserter'
+require_relative "ast_visitor"
+require_relative "optimizers/quantifier_optimizer"
+require_relative "optimizers/sequence_optimizer"
+require_relative "optimizers/choice_optimizer"
+require_relative "optimizers/lookahead_optimizer"
+require_relative "optimizers/cut_inserter"
 
 # Grammar-level optimizations for Parslet parsers
 # These optimizations transform the parser AST to reduce runtime overhead

data/lib/parsanol/optimizers/choice_optimizer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../ast_visitor'
+require_relative "../ast_visitor"
 
 module Parsanol
   module Optimizers

data/lib/parsanol/optimizers/cut_inserter.rb

@@ -84,7 +84,7 @@ module Parsanol
         Parsanol::Atoms::Repetition.new(
           optimized_parslet,
           rep.min,
-          rep.max
+          rep.max,
         )
       end
 
@@ -101,7 +101,10 @@ module Parsanol
         # For sequences, find the longest safe prefix
         if parslet.is_a?(Parsanol::Atoms::Sequence)
           prefix_parslets = find_deterministic_prefix(parslet)
-          return build_cut_sequence(parslet, prefix_parslets) if prefix_parslets && !prefix_parslets.empty?
+          if prefix_parslets && !prefix_parslets.empty?
+            return build_cut_sequence(parslet,
+                                      prefix_parslets)
+          end
         end
 
         # For other atoms, cut the whole thing if safe

data/lib/parsanol/optimizers/lookahead_optimizer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../ast_visitor'
+require_relative "../ast_visitor"
 
 module Parsanol
   module Optimizers
@@ -26,13 +26,19 @@ module Parsanol
           inner_positive = inner.positive
 
           # !(!x) => &x (double negation)
-          return Parsanol::Atoms::Lookahead.new(inner.bound_parslet, true) if !outer_positive && !inner_positive
+          if !outer_positive && !inner_positive
+            return Parsanol::Atoms::Lookahead.new(inner.bound_parslet,
+                                                  true)
+          end
 
           # &(&x) => &x (idempotent)
           return inner if outer_positive && inner_positive
 
           # !(&x) => !x (negative of positive)
-          return Parsanol::Atoms::Lookahead.new(inner.bound_parslet, false) if !outer_positive && inner_positive
+          if !outer_positive && inner_positive
+            return Parsanol::Atoms::Lookahead.new(inner.bound_parslet,
+                                                  false)
+          end
 
           # &(!x) => !x (positive of negative)
           return inner if outer_positive && !inner_positive

data/lib/parsanol/optimizers/quantifier_optimizer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../ast_visitor'
+require_relative "../ast_visitor"
 
 module Parsanol
   module Optimizers
@@ -26,19 +26,19 @@ module Parsanol
         if inner.is_a?(Parsanol::Atoms::Repetition)
           # repeat(0,1).repeat(0,1) => repeat(0,1) (idempotent)
           if parslet.min.zero? && parslet.max == 1 &&
-             inner.min.zero? && inner.max == 1
+              inner.min.zero? && inner.max == 1
             return inner
           end
 
           # repeat(n,n).repeat(m,m) => repeat(n*m,n*m) for exact counts
           if parslet.min == parslet.max && inner.min == inner.max &&
-             parslet.max && inner.max
+              parslet.max && inner.max
             new_count = parslet.min * inner.min
             return Parsanol::Atoms::Repetition.new(
               inner.parslet,
               new_count,
               new_count,
-              parslet.result_tag
+              parslet.result_tag,
             )
           end
         end
@@ -51,7 +51,7 @@ module Parsanol
             inner,
             parslet.min,
             parslet.max,
-            parslet.result_tag
+            parslet.result_tag,
           )
         end
       end

data/lib/parsanol/optimizers/sequence_optimizer.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../ast_visitor'
+require_relative "../ast_visitor"
 
 module Parsanol
   module Optimizers

data/lib/parsanol/options/zero_copy.rb

@@ -119,7 +119,7 @@ module Parsanol
     # @param type_map [Hash] Override type mapping for this parse
     # @return [Object] Direct Ruby object
     def parse_with_types(input, type_map)
-      raise LoadError, 'ZeroCopy mode requires native extension.' unless Parsanol::Native.available?
+      raise LoadError, "ZeroCopy mode requires native extension." unless Parsanol::Native.available?
 
       grammar_json = Parsanol::Native.serialize_grammar(root)
       Parsanol::Native.parse_to_objects(grammar_json, input, type_map)

data/lib/parsanol/options.rb

@@ -18,4 +18,4 @@
 # For standard parsing, use the Parse Modes API instead:
 #   parser.parse(input, mode: :native)  # or :ruby, :json
 
-require 'parsanol/options/zero_copy'
+require "parsanol/options/zero_copy"

data/lib/parsanol/parallel.rb

@@ -86,7 +86,7 @@ module Parsanol
         Parsanol::Native.parse_batch_parallel(
           grammar_json,
           inputs,
-          num_threads: config.num_threads
+          num_threads: config.num_threads,
         )
       end
 
@@ -98,7 +98,8 @@ module Parsanol
       # @param config [Config] Parallel configuration (optional)
       # @return [Array<Object>] Array of transformed results
       #
-      def parse_batch_with_transform(grammar_json, inputs, transform, config: Config.new)
+      def parse_batch_with_transform(grammar_json, inputs, transform,
+config: Config.new)
         results = parse_batch(grammar_json, inputs, config: config)
         results.map { |result| transform.apply(result) }
       end
@@ -107,7 +108,7 @@ module Parsanol
       #
       # @return [Integer] Number of available cores
       def available_cores
-        require 'etc'
+        require "etc"
         Etc.nprocessors
       rescue StandardError
         1

data/lib/parsanol/parser.rb

@@ -110,13 +110,23 @@ module Parsanol
     #
     def parse(input, mode_or_opts = {}, **kwargs)
       if mode_or_opts.is_a?(Hash) && !kwargs.key?(:mode)
-        # Legacy API: parse(input, options={}) or parse(input, mode: :ruby)
+        # Legacy API: parse(input, options={})
         merged = mode_or_opts.merge(kwargs)
         super(input, merged)
       else
         # New API: parse(input, mode:, **options)
         mode = kwargs.delete(:mode) || :ruby
-        dispatch_parse(mode, input, kwargs)
+        case mode
+        when :ruby
+          super(input, kwargs)
+        when :native
+          parse_native(input, kwargs)
+        when :json
+          parse_json(input, kwargs)
+        else
+          raise ArgumentError,
+                "Unknown mode: #{mode}. Valid modes: :ruby, :native, :json"
+        end
       end
     end
 
@@ -175,26 +185,19 @@ module Parsanol
     def dispatch_parse(mode, input, opts)
       case mode
       when :ruby
-        parse_ruby(input, opts)
+        # Call base class parse directly (send needed since parse is defined in parent)
+        Parsanol::Atoms::Base.instance_method(:parse).bind_call(self, input,
+                                                                opts)
       when :native
         parse_native(input, opts)
       when :json
         parse_json(input, opts)
       else
-        raise ArgumentError, "Unknown mode: #{mode}. Valid modes: :ruby, :native, :json"
+        raise ArgumentError,
+              "Unknown mode: #{mode}. Valid modes: :ruby, :native, :json"
       end
     end
 
-    # Pure Ruby parsing (delegates to Base implementation).
-    #
-    # @param input [String] input to parse
-    # @param opts [Hash] parsing options
-    # @return [Object] parse result
-    #
-    def parse_ruby(input, opts)
-      super
-    end
-
     # Native extension parsing with Ruby fallback.
     # Returns results with Slice objects containing position info.
     #
@@ -204,10 +207,9 @@ module Parsanol
     #
     def parse_native(input, opts)
       if Parsanol::Native.available?
-        # Parse with lazy line/column support
         Parsanol::Native.parse(root, input)
       else
-        parse_ruby(input, opts)
+        super
       end
     end
 

data/lib/parsanol/parslet.rb

@@ -35,7 +35,7 @@
 #           class MyParser < Parsanol::Parslet::Parser
 #           include Parsanol::Parslet
 
-require 'parsanol'
+require "parsanol"
 
 module Parsanol
   module Parslet
@@ -90,16 +90,16 @@ module Parsanol
       Parsanol.any
     end
 
-    def scope(&block)
-      Parsanol.scope(&block)
+    def scope(&)
+      Parsanol.scope(&)
     end
 
-    def dynamic(&block)
-      Parsanol.dynamic(&block)
+    def dynamic(&)
+      Parsanol.dynamic(&)
     end
 
-    def infix_expression(element, *operations, &reducer)
-      Parsanol.infix_expression(element, *operations, &reducer)
+    def infix_expression(element, *operations, &)
+      Parsanol.infix_expression(element, *operations, &)
     end
 
     # Parses a treetop-style expression string and returns the corresponding atom.

data/lib/parsanol/pattern/binding.rb

@@ -44,7 +44,7 @@ module Parsanol
         return class_match[1].downcase if class_match
 
         # Fallback for unexpected class names
-        'subtree'
+        "subtree"
       end
     end
   end

data/lib/parsanol/pattern.rb

@@ -51,7 +51,10 @@ module Parsanol
     #
     def match(subtree, bindings = nil)
       current_bindings = bindings ? bindings.dup : {}
-      check_match(subtree, @pattern_def, current_bindings) ? current_bindings : nil
+      if check_match(subtree, @pattern_def,
+                     current_bindings)
+        current_bindings
+      end
     end
 
     private

data/lib/parsanol/pool.rb

@@ -67,7 +67,7 @@ module Parsanol
         created: 0,
         reused: 0,
         released: 0,
-        discarded: 0
+        discarded: 0,
       }
 
       # Pre-allocate objects for efficiency if requested
@@ -154,7 +154,7 @@ module Parsanol
         reused: @stats[:reused],
         released: @stats[:released],
         discarded: @stats[:discarded],
-        utilization: utilization.round(2)
+        utilization: utilization.round(2),
       }
     end
 
@@ -174,7 +174,7 @@ module Parsanol
         created: 0,
         reused: 0,
         released: 0,
-        discarded: 0
+        discarded: 0,
       }
     end
 

data/lib/parsanol/pools/buffer_pool.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../buffer'
+require_relative "../buffer"
 
 module Parsanol
   module Pools
@@ -124,7 +124,7 @@ module Parsanol
             reused: stats[:reused],
             released: stats[:released],
             discarded: stats[:discarded],
-            utilization: utilization.round(2)
+            utilization: utilization.round(2),
           }
         end
         result

data/lib/parsanol/pools/position_pool.rb

@@ -48,7 +48,7 @@ module Parsanol
         if @available.empty?
           @stats[:created] += 1
           # Create Position with default values since it requires arguments
-          Parsanol::Position.new('', 0, 0)
+          Parsanol::Position.new("", 0, 0)
         else
           @stats[:reused] += 1
           @available.pop
@@ -81,7 +81,7 @@ module Parsanol
         end
 
         # Reset position state with default values before returning to pool
-        pos.reset!('', 0, 0)
+        pos.reset!("", 0, 0)
 
         @stats[:released] += 1
         @available.push(pos)

data/lib/parsanol/position.rb

@@ -45,7 +45,7 @@ module Parsanol
 
     def calculate_charpos
       # Calculate it based on platform
-      if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'opal'
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == "opal"
         # In Opal, convert byte position to character position.
         # We need to calculate how many characters occupy the first @bytepos bytes.
         `

data/lib/parsanol/result_builder.rb

@@ -27,14 +27,14 @@ module Parsanol
     # @param options [Hash] Builder options
     # @return [ResultBuilder] Appropriate builder instance
     #
-    def self.for(type, context, **options)
+    def self.for(type, context, **)
       case type
       when :repetition
-        RepetitionBuilder.new(context, **options)
+        RepetitionBuilder.new(context, **)
       when :sequence
-        SequenceBuilder.new(context, **options)
+        SequenceBuilder.new(context, **)
       when :hash
-        HashBuilder.new(context, **options)
+        HashBuilder.new(context, **)
       else
         raise ArgumentError, "Unknown builder type: #{type}"
       end

data/lib/parsanol/result_stream.rb

@@ -86,10 +86,10 @@ module Parsanol
     #   enum = stream.each  # Returns Enumerator
     #   enum.next           # Get next node
     #
-    def each(&block)
+    def each(&)
       return enum_for(:each) unless block_given?
 
-      traverse(@tree, &block)
+      traverse(@tree, &)
       self
     end
 
@@ -206,7 +206,10 @@ module Parsanol
     # @return [Enumerator]
     #
     def depth_traverse(node, current_depth, target_depth, &block)
-      return enum_for(:depth_traverse, node, current_depth, target_depth) unless block_given?
+      unless block
+        return enum_for(:depth_traverse, node, current_depth,
+                        target_depth)
+      end
 
       # Check if we're at target depth
       return [node].to_enum if current_depth == target_depth && yield(node)
@@ -217,13 +220,15 @@ module Parsanol
         case node
         when Array
           node.each do |item|
-            depth_traverse(item, current_depth + 1, target_depth, &block).each do |result|
+            depth_traverse(item, current_depth + 1, target_depth,
+                           &block).each do |result|
               results << result
             end
           end
         when Hash
           node.each_value do |value|
-            depth_traverse(value, current_depth + 1, target_depth, &block).each do |result|
+            depth_traverse(value, current_depth + 1, target_depth,
+                           &block).each do |result|
               results << result
             end
           end

data/lib/parsanol/slice.rb

@@ -12,14 +12,14 @@ module Parsanol
 
     attr_reader :content, :input
 
-    def initialize(byte_offset = 0, string_content = '', input = nil)
+    def initialize(byte_offset = 0, string_content = "", input = nil)
       @byte_position = byte_offset
       @content = string_content
       @input = input
       @line_and_column = nil
     end
 
-    def reset!(new_offset = 0, new_content = '', new_input = nil)
+    def reset!(new_offset = 0, new_content = "", new_input = nil)
       @byte_position = new_offset
       @content = new_content
       @input = new_input
@@ -44,6 +44,7 @@ module Parsanol
     def ==(other)
       return content == other if other.is_a?(String)
       return content == other.content if other.is_a?(Parsanol::Slice)
+
       content == other
     end
 
@@ -72,7 +73,8 @@ module Parsanol
 
     # Lazy line/column — computed once and cached.
     def line_and_column
-      raise ArgumentError, 'Line/column requires input' unless @input
+      raise ArgumentError, "Line/column requires input" unless @input
+
       @line_and_column ||= compute_line_and_column
     end
 
@@ -109,11 +111,11 @@ module Parsanol
     end
 
     def as_json(_options = {})
-      result = { 'value' => content, 'offset' => offset, 'length' => length }
+      result = { "value" => content, "offset" => offset, "length" => length }
       if @input
         line, column = line_and_column
-        result['line'] = line
-        result['column'] = column
+        result["line"] = line
+        result["column"] = column
       end
       result
     end
@@ -123,7 +125,8 @@ module Parsanol
       line, column = line_and_column
       end_line, end_column = line_and_column_at(offset + length)
       start_pos = SourcePosition.new(offset: offset, line: line, column: column)
-      end_pos = SourcePosition.new(offset: offset + length, line: end_line, column: end_column)
+      end_pos = SourcePosition.new(offset: offset + length, line: end_line,
+                                   column: end_column)
       SourceSpan.new(start_pos: start_pos, end_pos: end_pos)
     end
 
@@ -142,7 +145,7 @@ module Parsanol
         @input.line_and_column(pos)
       else
         # String input
-        prefix = @input.byteslice(0, pos) || ''
+        prefix = @input.byteslice(0, pos) || ""
         line = 1 + prefix.count("\n")
         last_nl = prefix.rindex("\n")
         column = last_nl ? pos - last_nl : pos + 1

data/lib/parsanol/source.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'stringio'
-require 'strscan'
+require "stringio"
+require "strscan"
 
-require 'parsanol/position'
-require 'parsanol/source/line_cache'
-require 'parsanol/pools/slice_pool'
-require 'parsanol/pools/position_pool'
+require "parsanol/position"
+require "parsanol/source/line_cache"
+require "parsanol/pools/slice_pool"
+require "parsanol/pools/position_pool"
 
 module Parsanol
   # Encapsulates input source for parsing operations. Provides position tracking,
@@ -33,14 +33,19 @@ module Parsanol
     # @raise [ArgumentError] if input doesn't respond to to_str
     #
     def initialize(input)
-      raise ArgumentError, 'Source requires a string-like object (responds to to_str)' unless input.respond_to?(:to_str)
+      unless input.respond_to?(:to_str)
+        raise ArgumentError,
+              "Source requires a string-like object (responds to to_str)"
+      end
 
       # Core scanner for input traversal
       @scanner = StringScanner.new(input)
       @raw_string = input.to_str
 
       # Regex cache: maps count n to /(.|$){n}/m pattern
-      @regex_cache = Hash.new { |h, count| h[count] = Regexp.new("(.|$){#{count}}", Regexp::MULTILINE) }
+      @regex_cache = Hash.new do |h, count|
+        h[count] = Regexp.new("(.|$){#{count}}", Regexp::MULTILINE)
+      end
 
       # Line ending cache for position-to-line/column mapping
       @line_data = LineCache.new
@@ -173,7 +178,7 @@ module Parsanol
       @position_pool.acquire_with(
         string: @raw_string,
         bytepos: effective,
-        charpos: char_pos
+        charpos: char_pos,
       )
     end
   end