parsanol 1.3.16 → 1.3.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82fd7d0cba94acf7ca4985c1616d8d7dbc17636f41af33fc2cad5c5cc36cfac2
-  data.tar.gz: 1a29b8de6b0e9b34ea68643958c775d460fec803425c002e848bc8fc620cc907
+  metadata.gz: 8c155ba9401ec5127188455f4411e52798b18b4647a7e0032aac8704f6390a4e
+  data.tar.gz: 6944ad7cafb74447a8822b88d6bbc6c2da5bce111da7dcbd3e75bb3facf09b14
 SHA512:
-  metadata.gz: 2e55df900cc9f2fc24e4f8c5ab0c2b08d56e4232e23178a2f77c1b64a5efca17c85c32bfc986c1a75e36252d1f7942d02b26499abc4d763cb3aaffcd01ed10e7
-  data.tar.gz: b81c35f7c1dfce8d4747e690e23329a98a91564430a95c43eb32fce4199b25082f9fd1617f4a8f25f998f1f594c6ab3c337298a561898e6b9e2505c6bd6c89e9
+  metadata.gz: 6b53a9d7cad648052f790dbd3577968e085652ae91dda58f095175e815c349182d9387fd897f141d2d41225226ad417594e6bdd18d0c352b574ca008759bf73a
+  data.tar.gz: 857eb89870d64a905b540237d694f0f991eb2e7665489a8bfc5f5225444a95fddb309b9749829869293f863a479c3dcf698a904596ecbda716b50d251c85bd54

data/Cargo.lock

@@ -253,7 +253,7 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 [[package]]
 name = "parsanol"
 version = "0.5.1"
-source = "git+https://github.com/parsanol/parsanol-rs?branch=main#f6782c030b42aaa722357cd107fd56ed9853c4ea"
+source = "git+https://github.com/parsanol/parsanol-rs?branch=main#7357b1a1885355a7116cd9c4c58a2c9d2d559bee"
 dependencies = [
  "ahash",
  "getrandom 0.3.4",
@@ -270,7 +270,7 @@ dependencies = [
 [[package]]
 name = "parsanol-derive"
 version = "0.5.1"
-source = "git+https://github.com/parsanol/parsanol-rs?branch=main#f6782c030b42aaa722357cd107fd56ed9853c4ea"
+source = "git+https://github.com/parsanol/parsanol-rs?branch=main#7357b1a1885355a7116cd9c4c58a2c9d2d559bee"
 dependencies = [
  "proc-macro2",
  "quote",

data/lib/parsanol/atoms/base.rb

@@ -148,6 +148,13 @@ module Parsanol
         to_s(TOP)
       end
 
+      # Finalizes result by flattening. Public: the native error
+      # fallback (both extension and ffi tiers) calls it cross-object to
+      # finalize a recovered tree.
+      def finalize_result(value)
+        flatten(value)
+      end
+
       protected
 
       # Pre-allocated constant result tuples
@@ -180,11 +187,6 @@ 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.

data/lib/parsanol/native/ffi.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Parsanol
+  module Native
+    # Rust engine for runtimes that cannot load C-API extensions
+    # (JRuby, TruffleRuby, or an MRI whose platform gem is absent and
+    # cannot build one). Binds the parsanol cdylib's C ABI through the
+    # `ffi` gem: grammars register once into Rust-side handles keyed by
+    # serialized structure; results cross the boundary as flat-u64 batch
+    # arrays decoded by the same BatchDecoder used elsewhere.
+    module Ffi
+      class Error < StandardError
+      end
+
+      class << self
+        @available = nil
+
+        def available?
+          return @available unless @available.nil?
+
+          @available = begin
+            require "ffi"
+            lib = locate_library
+            lib && bind_library(lib)
+          rescue LoadError, StandardError
+            false
+          end
+        end
+
+        # Registers (once, cached) and parses. +grammar+ is a grammar
+        # atom or a pre-serialized JSON string. Mirrors Native.parse's
+        # contract, including the single reporter-pass fallback to the
+        # pure-Ruby engine for parslet-compatible failure errors.
+        def parse(grammar, input)
+          unless available? && @binding
+            raise Error, "parsanol FFI library not available"
+          end
+
+          if grammar.is_a?(String)
+            json = grammar
+            atom = nil
+          else
+            json = ::Parsanol::Native::Parser.serialize_grammar(grammar)
+            atom = grammar
+          end
+          handle = ((@handles ||= {})[json] ||= @binding.c_register(json))
+          raise Error, "grammar registration failed" if handle.zero?
+
+          written = parse_into(handle, input)
+          if written.positive?
+            return ::Parsanol::Native::BatchDecoder.decode_and_flatten(
+              @buffer.read_array_of_uint64(written), input, ::Parsanol::Slice
+            )
+          end
+
+          message = @binding.c_last_error.to_s
+          if atom
+            return ::Parsanol::Native.raise_native_parse_error(
+              RuntimeError.new(message), atom, input
+            )
+          end
+
+          raise Error, "parse failed: #{message}"
+        end
+
+        private
+
+        # Search order: explicit override, gem-vendored cdylib next to
+        # this file, then the system linker path.
+        def locate_library
+          candidates = []
+          env = ENV.fetch("PARSANOL_FFI_LIB", nil)
+          candidates << env if env && !env.empty?
+          here = File.dirname(__FILE__)
+          %w[libparsanol.dylib libparsanol.so parsanol.dll].each do |name|
+            path = File.expand_path(name, here)
+            candidates << path if File.file?(path)
+          end
+          candidates << "parsanol"
+          candidates.each do |cand|
+            return cand if File.file?(cand)
+
+            begin
+              FFI::DynamicLibrary.open(cand, FFI::DynamicLibrary::RTLD_NOW)
+              return cand
+            rescue StandardError
+              next
+            end
+          end
+          nil
+        end
+
+        def bind_library(path) # rubocop:disable Naming/PredicateMethod -- binds and reports success
+          binding_mod = Module.new do
+            extend FFI::Library
+
+            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
+            attach_function :c_last_error, :parsanol_c_last_error,
+                            [], :string
+            attach_function :c_release, :parsanol_c_release,
+                            %i[uint64], :void
+          end
+          # Probe the symbols now so a mismatched library fails loudly
+          # at availability time, not at first parse.
+          probe = binding_mod.c_last_error
+          @binding = binding_mod
+          @buffer = nil
+          !probe.nil? || true
+        end
+
+        # Two-call buffer protocol: cap=0 asks for the needed size, then
+        # one allocation carries the whole batch.
+        def parse_into(handle, input)
+          needed = @binding.c_parse(handle, input, nil, 0)
+          return needed unless needed.negative?
+
+          @buffer = FFI::MemoryPointer.new(:uint64, -needed)
+          @binding.c_parse(handle, input, @buffer, -needed)
+        end
+      end
+    end
+  end
+end

data/lib/parsanol/native/parser.rb

@@ -18,7 +18,7 @@ module Parsanol
         def available?
           return @cached_available unless @cached_available.nil?
 
-          @cached_available = begin
+          @ext_loaded = begin
             # Try versioned path first (released gem), then non-versioned (local dev)
             ruby_version = RUBY_VERSION.split(".").take(2).join(".")
             begin
@@ -30,6 +30,13 @@ module Parsanol
           rescue LoadError
             false
           end
+          @cached_available = @ext_loaded || Ffi.available?
+        end
+
+        # True when the MRI C-API extension is loaded; false when the
+        # engine runs through the ffi-gem cdylib tier instead.
+        def extension_loaded?
+          @ext_loaded ? true : false
         end
 
         # Parse input with a Ruby grammar, returning clean AST.

data/lib/parsanol/native.rb

@@ -10,6 +10,8 @@ require "parsanol/native/batch_decoder"
 
 module Parsanol
   module Native
+    # ffi-gem cdylib tier: lazy — only loaded when the MRI extension is absent.
+    autoload :Ffi, "parsanol/native/ffi"
     class << self
       # Check if native extension is available
       def available?
@@ -38,6 +40,10 @@ module Parsanol
       def parse(grammar, input)
         raise LoadError, "Native parser not available" unless available?
 
+        # ffi-gem tier (JRuby/TruffleRuby/no-binary MRI): same contract,
+        # batch-decoded results, single reporter-pass error fallback.
+        return Ffi.parse(grammar, input) unless Parser.extension_loaded?
+
         # 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.

data/lib/parsanol/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsanol
 version: !ruby/object:Gem::Version
-  version: 1.3.16
+  version: 1.3.18
 platform: ruby
 authors:
 - Ribose Inc.
@@ -215,6 +215,7 @@ files:
 - lib/parsanol/native.rb
 - lib/parsanol/native/batch_decoder.rb
 - lib/parsanol/native/dynamic.rb
+- lib/parsanol/native/ffi.rb
 - lib/parsanol/native/parser.rb
 - lib/parsanol/native/serializer.rb
 - lib/parsanol/native/transformer.rb