parsanol 1.3.14-arm-linux → 1.3.16-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee82309e5f5550d8b7e874fb457082c29e441044c21f0149108947c1908fc312
-  data.tar.gz: a58b979b3cca49c5fcc3ad04bbc592f2dc1995883500e13e1bdcab73fa3e41a9
+  metadata.gz: d8496db15cc90acf09d51ca06fb3fbeda98ed9a1cf010eee22177aef50d9b6e3
+  data.tar.gz: f11121252847374665e97bbe23881723c66314d960c7532246c3ed79f9ecd565
 SHA512:
-  metadata.gz: d2cd46409841355d16f45d29cbe1d87fc57107bef76de6ef85c7f6cf9b154e25a0f6cb5b05f62235319b8ece92f283f6da772f834fbc629a11e867d23fd90435
-  data.tar.gz: b44083dd31df4bde64bb04d319ef9ef605f5aca0c1f03302c284918e6779bc8c809b774d59ec92ec9acb44728a2b3acf00945dc5b9488c9f2f8627c4ff11b7c9
+  metadata.gz: 4d649379c1796c92079fe220dedc76fac3654805958fe956de43ee47f88099b0577621f219e51d052c35c2f0f063c919aaadfbd36789171e5dd709eac6babbba
+  data.tar.gz: d8e2af5697eb5d4cc745a71257d0c770d5b34dbd6e156e4da118e9516f16da348662575d8e892bb2ca466174e6abfed0c458b0658bb471c3a9b211159a4794f6

data/lib/parsanol/atoms/base.rb

@@ -30,9 +30,29 @@ module Parsanol
       # @return [Object] the parsed result
       # @raise [Parsanol::ParseFailed] on parse failure
       def parse(source, options = {})
-        input = normalize_input(source)
         must_consume_all = !options[:prefix]
 
+        # Compiled-VM fast path: String input, full-consumption semantics.
+        # On failure (or unsupported grammar / budget exhaustion) fall
+        # through to the interpreter, which also produces the exact
+        # cause-tree diagnostics. run_for memoizes heavy-backtracking
+        # grammars transparently.
+        if must_consume_all && source.is_a?(String) &&
+            (program = VM.program_for(self))
+          result = VM.run_for(self, program, source, true)
+          if result == VM::BAIL
+            # Internal bail: fall back to the interpreter and skip the VM
+            # for this grammar from now on.
+            VM.disable_for!(self)
+          elsif result.first
+            return finalize_result(result[1])
+          end
+          # Clean [false, nil]: the input does not parse — the interpreter
+          # reparse below produces the detailed cause tree.
+        end
+
+        input = normalize_input(source)
+
         # Initial parse attempt (no error collection)
         success, value = run_with_context(input, nil, must_consume_all)
         return finalize_result(value) if success
@@ -160,6 +180,11 @@ module Parsanol
       # Alias for ok (legacy compatibility)
       alias succ ok
 
+      # Finalizes result by flattening.
+      def finalize_result(value)
+        flatten(value)
+      end
+
       private
 
       # Converts raw input to Source if needed.
@@ -198,11 +223,6 @@ module Parsanol
 
         cause.raise
       end
-
-      # Finalizes result by flattening.
-      def finalize_result(value)
-        flatten(value)
-      end
     end
   end
 end

data/lib/parsanol/native/transformer.rb

@@ -132,9 +132,11 @@ module Parsanol
         # Transform the value
         transformed = transform(value, named: true)
 
-        # Check if value is a tagged repetition from native parser
+        # 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.
         is_tagged_repetition = value.is_a?(Array) && !value.empty? &&
-          value.first.is_a?(String) && value.first == REPETITION_TAG
+          [REPETITION_SYM, REPETITION_TAG].include?(value.first)
 
         # Check RAW value for repetition pattern BEFORE transformation
         # Array with items that all have the parent key
@@ -203,13 +205,12 @@ module Parsanol
           # Empty array from repetition stays as empty array
           if transformed.empty?
             { sym_key => EMPTY_ARRAY }
-          # Check if items already have the same key (avoid double-wrapping)
-          elsif transformed.all? do |item|
-            item.is_a?(Hash) && item.key?(sym_key)
-          end
+          # Hash items already carry their own capture names — a
+          # repetition of named captures keeps them as-is (parslet
+          # semantics); only unnamed items get the parent name per item.
+          elsif transformed.all?(Hash)
             { sym_key => transformed }
           else
-            # Wrap each item with the name
             { sym_key => transformed.map { |item| { sym_key => item } } }
           end
         elsif transformed.is_a?(::Parsanol::Slice) && transformed.empty?

data/lib/parsanol/native.rb

@@ -38,14 +38,14 @@ module Parsanol
       def parse(grammar, input)
         raise LoadError, "Native parser not available" unless available?
 
-        raw_ast =
-          if grammar.is_a?(String)
-            parse_json_grammar(grammar, input)
-          else
-            parse_atom_grammar(grammar, input)
-          end
-
-        BatchDecoder.decode_and_flatten(raw_ast, input, Parsanol::Slice)
+        # Both sub-methods return the final decoded tree; on native failure
+        # they fall back to the pure-Ruby parser, whose result is already
+        # final and must not be transformed again.
+        if grammar.is_a?(String)
+          parse_json_grammar(grammar, input)
+        else
+          parse_atom_grammar(grammar, input)
+        end
       end
 
       # Memory-bounded parsing without packrat cache.
@@ -65,12 +65,14 @@ module Parsanol
                          Parser.serialize_grammar(grammar)
                        end
 
+        # Decode here, not around the fallback: raise_native_parse_error
+        # returns the Ruby parser's already-final tree on success.
         begin
-          raw_ast = _parse_fresh_raw(grammar_json, input)
+          BatchDecoder.decode_and_flatten(_parse_fresh_raw(grammar_json, input),
+                                          input, Parsanol::Slice)
         rescue RuntimeError => e
           raise_native_parse_error(e, grammar, input)
         end
-        BatchDecoder.decode_and_flatten(raw_ast, input, Parsanol::Slice)
       end
 
       # Parse and return RAW AST without transformation.
@@ -192,7 +194,20 @@ module Parsanol
       # pre-serialized JSON grammars the native message is wrapped in a
       # Parsanol::ParseFailed directly.
       def raise_native_parse_error(error, grammar, input)
-        return grammar.parse(input) if grammar.respond_to?(:parse)
+        if grammar.respond_to?(:parse)
+          # One interpreter pass with the error reporter attached covers
+          # both jobs: a success means the native backend could not
+          # express the grammar (recover the tree), a failure raises the
+          # parslet-compatible cause tree. The native backend has
+          # already failed, so a separate plain attempt first would be a
+          # wasted parse.
+          reporter = Parsanol::ErrorReporter::Tree.new
+          source = Parsanol::Source.new(input)
+          success, value = grammar.run_with_context(source, reporter, true)
+          return grammar.finalize_result(value) if success
+
+          value.raise
+        end
 
         source = Parsanol::Source.new(input)
         cause = Parsanol::Cause.new(error.message, source, source.bytepos)
@@ -201,7 +216,8 @@ module Parsanol
 
       # Pre-serialized JSON grammar path (library authors with cached JSON).
       def parse_json_grammar(grammar_json, input)
-        _parse_raw(grammar_json, input)
+        BatchDecoder.decode_and_flatten(_parse_raw(grammar_json, input),
+                                        input, Parsanol::Slice)
       rescue RuntimeError => e
         raise_native_parse_error(e, grammar_json, input)
       end
@@ -212,12 +228,16 @@ module Parsanol
         handle = Parser.grammar_handle(grammar)
 
         begin
-          _parse_handle(handle, input)
+          BatchDecoder.decode_and_flatten(_parse_handle(handle, input),
+                                          input, Parsanol::Slice)
         rescue ArgumentError
           # Handle dropped Rust-side (e.g. cache cleared): re-register once.
           Parser.invalidate_handle(handle)
           begin
-            _parse_handle(Parser.grammar_handle(grammar), input)
+            BatchDecoder.decode_and_flatten(
+              _parse_handle(Parser.grammar_handle(grammar), input),
+              input, Parsanol::Slice
+            )
           rescue RuntimeError => e
             raise_native_parse_error(e, grammar, input)
           end

data/lib/parsanol/parser.rb

@@ -109,32 +109,36 @@ module Parsanol
     #   result[:name].to_s           # => "hello"
     #
     def parse(input, mode_or_opts = {}, **kwargs)
-      if mode_or_opts.is_a?(Hash) && !kwargs.key?(:mode)
-        # Legacy API: parse(input, options={})
-        merged = mode_or_opts.merge(kwargs)
-        if Parsanol::Native.available? && !merged.key?(:prefix) &&
-            !merged.key?(:reporter)
-          # Native backend by default; falls back to pure Ruby inside
-          # parse_native when the extension is missing.
-          parse_native(input, merged)
+      opts =
+        if mode_or_opts.is_a?(Hash)
+          mode_or_opts.merge(kwargs)
+        elsif mode_or_opts.nil?
+          kwargs
         else
-          super(input, merged)
+          # New API: parse(input, :mode, **options)
+          kwargs[:mode] = mode_or_opts
+          kwargs
         end
+      # parse(input, {mode: :ruby, ...}) is the same call shape a subclass
+      # forwarding options via super produces; :mode must be honored
+      # wherever it appears, or those callers silently get the native path.
+      mode = opts.delete(:mode) ||
+        (if Parsanol::Native.available? && !opts.key?(:prefix) &&
+              !opts.key?(:reporter)
+           :native
+         else
+           :ruby
+         end)
+      case mode
+      when :ruby
+        super(input, opts)
+      when :native
+        parse_native(input, opts)
+      when :json
+        parse_json(input, opts)
       else
-        # New API: parse(input, mode:, **options)
-        mode = kwargs.delete(:mode) ||
-          (Parsanol::Native.available? ? :native : :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
+        raise ArgumentError,
+              "Unknown mode: #{mode}. Valid modes: :ruby, :native, :json"
       end
     end
 

data/lib/parsanol/version.rb

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