parsanol 1.3.4 → 1.3.7

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

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
@@ -128,11 +124,54 @@ module Parsanol
       # Clear grammar caches (call if grammar changes)
       def clear_cache
         Parser.clear_cache
+        clear_grammar_cache if available?
+      end
+
+      # Clear the Rust grammar cache to free memory.
+      #
+      # This is useful for batch processing scenarios where you want to
+      # limit memory usage by clearing unused grammars.
+      #
+      # @return [nil]
+      def clear_grammar_cache
+        raise LoadError, "Native parser not available" unless available?
+
+        _clear_grammar_cache
+      end
+
+      # Get the current number of cached grammars in Rust.
+      #
+      # @return [Integer] Number of cached grammars
+      def grammar_cache_size
+        raise LoadError, "Native parser not available" unless available?
+
+        _grammar_cache_size
+      end
+
+      # Get the grammar cache capacity.
+      #
+      # @return [Integer] Maximum cache capacity
+      def grammar_cache_capacity
+        raise LoadError, "Native parser not available" unless available?
+
+        _grammar_cache_capacity
       end
 
       # Get cache statistics
       def cache_stats
-        Parser.cache_stats
+        stats = Parser.cache_stats
+        if available?
+          stats[:rust_grammar_cache_size] = grammar_cache_size
+          stats[:rust_grammar_cache_capacity] = grammar_cache_capacity
+        end
+        stats
+      end
+
+      private
+
+      # Get the Slice class
+      def get_slice_class
+        Parsanol::Slice
       end
     end
   end
@@ -140,11 +179,11 @@ 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

@@ -83,17 +83,11 @@ module Parsanol
                 "Run `rake compile` to build the extension."
         end
 
-        # Try to use native parallel parsing
-        if respond_to?(:_parse_batch_parallel, true)
-          Parsanol::Native.parse_batch_parallel(
-            grammar_json,
-            inputs,
-            num_threads: config.num_threads
-          )
-        else
-          # Fallback to sequential if parallel not available
-          inputs.map { |input| Parsanol::Native.parse(grammar_json, input) }
-        end
+        Parsanol::Native.parse_batch_parallel(
+          grammar_json,
+          inputs,
+          num_threads: config.num_threads,
+        )
       end
 
       # Parse multiple inputs in parallel with transformation.
@@ -104,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
@@ -113,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

@@ -109,13 +109,24 @@ module Parsanol
     #   result[:name].to_s           # => "hello"
     #
     def parse(input, mode_or_opts = {}, **kwargs)
-      if mode_or_opts.is_a?(Hash)
+      if mode_or_opts.is_a?(Hash) && !kwargs.key?(:mode)
         # Legacy API: parse(input, options={})
         merged = mode_or_opts.merge(kwargs)
         super(input, merged)
       else
         # New API: parse(input, mode:, **options)
-        dispatch_parse(mode_or_opts, input, kwargs)
+        mode = kwargs.delete(:mode) || :ruby
+        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
 
@@ -130,6 +141,38 @@ module Parsanol
       inputs.map { |str| parse(str, mode: mode, **opts) }
     end
 
+    # Clear the Rust grammar cache to free memory.
+    #
+    # @return [nil]
+    # @raise [LoadError] if native parser is not available
+    def clear_grammar_cache
+      Parsanol::Native.clear_grammar_cache
+    end
+
+    # Get the current number of cached grammars in Rust.
+    #
+    # @return [Integer] number of cached grammars
+    # @raise [LoadError] if native parser is not available
+    def grammar_cache_size
+      Parsanol::Native.grammar_cache_size
+    end
+
+    # Get the grammar cache capacity.
+    #
+    # @return [Integer] maximum cache capacity
+    # @raise [LoadError] if native parser is not available
+    def grammar_cache_capacity
+      Parsanol::Native.grammar_cache_capacity
+    end
+
+    # Get cache statistics for both Ruby and Rust caches.
+    #
+    # @return [Hash] cache statistics including Ruby GRAMMAR_CACHE and Rust grammar cache
+    # @raise [LoadError] if native parser is not available for Rust stats
+    def cache_stats
+      Parsanol::Native.cache_stats
+    end
+
     private
 
     # Dispatches to the appropriate parsing backend based on mode.
@@ -142,23 +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
-    #
-
     # Native extension parsing with Ruby fallback.
     # Returns results with Slice objects containing position info.
     #
@@ -168,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