mini_racer-csim 0.21.1.0

data/lib/mini_racer/truffleruby.rb

@@ -0,0 +1,479 @@
+# frozen_string_literal: true
+
+require_relative 'shared'
+
+module MiniRacer
+  # GraalJS has no equivalent of V8's per-script bytecode cache reachable
+  # from Polyglot::InnerContext#eval, so the version tag is meaningless
+  # here. Define 0 as a sentinel callers can detect to skip cache logic.
+  V8_CACHED_DATA_VERSION_TAG = 0
+
+  class Context
+
+    class ExternalFunction
+      private
+
+      def notify_v8
+        name = @name.encode(::Encoding::UTF_8)
+        wrapped = lambda do |*args|
+          converted = @parent.send(:convert_js_to_ruby, args)
+          begin
+            result = @callback.call(*converted)
+          rescue Polyglot::ForeignException => e
+            e = RuntimeError.new(e.message)
+            e.set_backtrace(e.backtrace)
+            @parent.instance_variable_set(:@current_exception, e)
+            raise e
+          rescue => e
+            @parent.instance_variable_set(:@current_exception, e)
+            raise e
+          end
+          @parent.send(:convert_ruby_to_js, result)
+        end
+
+        if @parent_object.nil?
+          # set global name to proc
+          result = @parent.eval_in_context('this')
+          result[name] = wrapped
+        else
+          parent_object_eval = @parent_object_eval.encode(::Encoding::UTF_8)
+          begin
+            result = @parent.eval_in_context(parent_object_eval)
+          rescue Polyglot::ForeignException, StandardError => e
+            raise ParseError, "Was expecting #{@parent_object} to be an object", e.backtrace
+          end
+          result[name] = wrapped
+          # set evaluated object results name to proc
+        end
+      end
+    end
+
+    def heap_stats
+      raise ContextDisposedError if @disposed
+      {
+        total_physical_size: 0,
+        total_heap_size_executable: 0,
+        total_heap_size: 0,
+        used_heap_size: 0,
+        heap_size_limit: 0,
+      }
+    end
+
+    def stop
+      if @entered
+        @context.stop
+        @stopped = true
+        stop_attached
+      end
+    end
+
+    def low_memory_notification
+      GC.start
+    end
+
+    private
+
+    @context_initialized = false
+    @use_strict = false
+
+    def init_unsafe(isolate, snapshot)
+      unless defined?(Polyglot::InnerContext)
+        raise "TruffleRuby #{RUBY_ENGINE_VERSION} does not have support for inner contexts, use a more recent version"
+      end
+
+
+      if TruffleRuby.native?
+        raise "You need the TruffleRuby JVM Standalone for mini_racer because it is not possible to install the js component in the the Native standalone"
+      end
+
+      unless Polyglot.languages.include? "js"
+        raise "The language 'js' is not available, you need to install the 'js' component.\nSee https://github.com/oracle/truffleruby/blob/master/doc/user/polyglot.md#installing-other-languages"
+      end
+
+      @context = Polyglot::InnerContext.new(on_cancelled: -> { 
+        raise ScriptTerminatedError, 'JavaScript was terminated (either by timeout or explicitly)' 
+      })
+      Context.instance_variable_set(:@context_initialized, true)
+      @js_object = @context.eval('js', 'Object')
+      @isolate_mutex = Mutex.new
+      @stopped = false
+      @entered = false
+      @has_entered = false
+      @current_exception = nil
+      if isolate && snapshot
+        isolate.instance_variable_set(:@snapshot, snapshot)
+      end
+      if snapshot
+        @snapshot = snapshot
+      elsif isolate
+        @snapshot = isolate.instance_variable_get(:@snapshot)
+      else
+        @snapshot = nil
+      end
+
+      @is_object_or_array_func = eval_in_context "(x) => { return (x instanceof Object || x instanceof Array) && !(x instanceof Date) && !(x instanceof Function) }"
+      @is_map_func = eval_in_context "(x) => { return x instanceof Map }"
+      @is_map_iterator_func = eval_in_context "(x) => { return x[Symbol.toStringTag] === 'Map Iterator' }"
+      @is_time_func = eval_in_context "(x) => { return x instanceof Date }"
+      @is_symbol_func = eval_in_context "(x) => { return typeof x === 'symbol' }"
+      @is_uint8_array_func = eval_in_context "(x) => { return x instanceof Uint8Array }"
+
+      @js_date_to_time_func = eval_in_context "(x) => { return x.getTime(x) }"
+      @js_symbol_to_symbol_func = eval_in_context "(x) => { var r = x.description; return r === undefined ? 'undefined' : r }"
+      @js_new_date_func = eval_in_context "(x) => { return new Date(x) }"
+      @js_new_array_func = eval_in_context "(x) => { return new Array(x) }"
+      @js_new_uint8array_func = eval_in_context "(x) => { return new Uint8Array(x) }"
+    end
+
+    def dispose_unsafe
+      @context.close
+    end
+
+    def eval_unsafe(str, filename)
+      @entered = true
+      if !@has_entered && @snapshot
+        snapshot_src = encode(@snapshot.instance_variable_get(:@source))
+        begin
+          eval_in_context(snapshot_src, filename)
+        rescue Polyglot::ForeignException => e
+          raise RuntimeError, e.message, e.backtrace
+        end
+      end
+      @has_entered = true
+      raise RuntimeError, "TruffleRuby does not support eval after stop" if @stopped
+      raise TypeError, "wrong type argument #{str.class} (should be a string)" unless str.is_a?(String)
+      raise TypeError, "wrong type argument #{filename.class} (should be a string)" unless filename.nil? || filename.is_a?(String)
+
+      str = encode(str)
+      begin
+        translate do
+          eval_in_context(str, filename)
+        end
+      rescue Polyglot::ForeignException => e
+        raise RuntimeError, e.message, e.backtrace
+      rescue ::RuntimeError => e
+        if @current_exception
+          e = @current_exception
+          @current_exception = nil
+          raise e
+        else
+          raise e, e.message
+        end
+      end
+    ensure
+      @entered = false
+    end
+
+    def call_unsafe(function_name, *arguments)
+      @entered = true
+      if !@has_entered && @snapshot
+        src = encode(@snapshot.instance_variable_get(:source))
+        begin
+          eval_in_context(src)
+        rescue Polyglot::ForeignException => e
+          raise RuntimeError, e.message, e.backtrace
+        end
+      end
+      @has_entered = true
+      raise RuntimeError, "TruffleRuby does not support call after stop" if @stopped
+      begin
+        translate do
+          function = eval_in_context(function_name)
+          function.call(*convert_ruby_to_js(arguments))
+        end
+      rescue Polyglot::ForeignException => e
+        raise RuntimeError, e.message, e.backtrace
+      end
+    ensure
+      @entered = false
+    end
+
+    def create_isolate_value
+      # Returning a dummy object since TruffleRuby does not have a 1-1 concept with isolate.
+      # However, code and ASTs are shared between contexts.
+      Isolate.new
+    end
+
+    def isolate_mutex
+      @isolate_mutex
+    end
+
+    def translate
+      convert_js_to_ruby yield
+    rescue Object => e
+      message = e.message
+      if @current_exception
+        raise @current_exception
+      elsif e.message && e.message.start_with?('SyntaxError:')
+        error_class = MiniRacer::ParseError
+      elsif e.is_a?(MiniRacer::ScriptTerminatedError)
+        error_class = MiniRacer::ScriptTerminatedError
+      else
+        error_class = MiniRacer::RuntimeError
+      end
+
+      if error_class == MiniRacer::RuntimeError
+        bls = e.backtrace_locations&.select { |bl| bl&.source_location&.language == 'js' }
+        if bls && !bls.empty?
+          if '(eval)' != bls[0].path
+            message = "#{e.message}\n at #{bls[0]}\n" + bls[1..].map(&:to_s).join("\n")
+          else
+            message = "#{e.message}\n" + bls.map(&:to_s).join("\n")
+          end
+        end
+        raise error_class, message
+      else
+        raise error_class, message, e.backtrace
+      end
+    end
+
+    def convert_js_to_ruby(value)
+      case value
+      when true, false, Integer, Float
+        value
+      else
+        if value.nil?
+          nil
+        elsif value.respond_to?(:call)
+          MiniRacer::JavaScriptFunction.new
+        elsif value.respond_to?(:to_str)
+          value.to_str.dup
+        elsif value.respond_to?(:to_ary)
+          if uint8_array?(value)
+            return value.to_a.pack('C*')
+          end
+
+          value.to_ary.map do |e|
+            if e.respond_to?(:call)
+              nil
+            else
+              convert_js_to_ruby(e)
+            end
+          end
+        elsif time?(value)
+          js_date_to_time(value)
+        elsif symbol?(value)
+          js_symbol_to_symbol(value)
+        elsif map?(value)
+          js_map_to_hash(value)
+        elsif map_iterator?(value)
+          value.map { |e| convert_js_to_ruby(e) }
+        elsif Polyglot::ForeignException === value
+          exc = MiniRacer::ScriptError.new(value.message)
+          exc.set_backtrace(value.backtrace)
+          exc
+        else
+          object = value
+          h = {}
+          object.instance_variables.each do |member|
+            v = object[member]
+            unless v.respond_to?(:call)
+              h[member.to_s] = convert_js_to_ruby(v)
+            end
+          end
+          h
+        end
+      end
+    end
+
+    def object_or_array?(val)
+      @is_object_or_array_func.call(val)
+    end
+
+    def map?(value)
+      @is_map_func.call(value)
+    end
+
+    def map_iterator?(value)
+      @is_map_iterator_func.call(value)
+    end
+
+    def time?(value)
+      @is_time_func.call(value)
+    end
+
+    def symbol?(value)
+      @is_symbol_func.call(value)
+    end
+
+    def uint8_array?(value)
+      @is_uint8_array_func.call(value)
+    end
+
+    def js_date_to_time(value)
+      millis = @js_date_to_time_func.call(value)
+      Time.at(Rational(millis, 1000))
+    end
+
+    def js_symbol_to_symbol(value)
+      @js_symbol_to_symbol_func.call(value).to_s.to_sym
+    end
+
+    def js_map_to_hash(map)
+      map.to_a.to_h do |key, value|
+        [convert_js_to_ruby(key), convert_js_to_ruby(value)]
+      end
+    end
+
+    def js_new_date(value)
+      @js_new_date_func.call(value)
+    end
+
+    def js_new_array(size)
+      @js_new_array_func.call(size)
+    end
+
+    def convert_ruby_to_js(value)
+      case value
+      when nil, true, false, Integer, Float
+        value
+      when Array
+        ary = js_new_array(value.size)
+        value.each_with_index do |v, i|
+          ary[i] = convert_ruby_to_js(v)
+        end
+        ary
+      when Hash
+        h = @js_object.new
+        value.each_pair do |k, v|
+          h[convert_ruby_to_js(k.to_s)] = convert_ruby_to_js(v)
+        end
+        h
+      when String, Symbol
+        Truffle::Interop.as_truffle_string value
+      when Time
+        js_new_date(value.to_f * 1000)
+      when DateTime
+        js_new_date(value.to_time.to_f * 1000)
+      when MiniRacer::Binary
+        @js_new_uint8array_func.call(value.data.bytes)
+      else
+        "Undefined Conversion"
+      end
+    end
+
+    def encode(string)
+      raise ArgumentError unless string
+      string.encode(::Encoding::UTF_8)
+    end
+
+    class_eval <<-'RUBY', "(mini_racer)", 1
+        def eval_in_context(code, file = nil); code = ('"use strict";' + code) if Context.instance_variable_get(:@use_strict); @context.eval('js', code, file || '(mini_racer)'); end
+    RUBY
+
+  end
+
+  class Isolate
+    def init_with_snapshot(snapshot)
+      # TruffleRuby does not have a 1-1 concept with isolate.
+      # However, isolate can hold a snapshot, and code and ASTs are shared between contexts.
+      @snapshot = snapshot
+    end
+  end
+
+  class Platform
+    def self.set_flag_as_str!(flag)
+      raise TypeError, "wrong type argument #{flag.class} (should be a string)" unless flag.is_a?(String)
+      raise MiniRacer::PlatformAlreadyInitialized, "The platform is already initialized." if Context.instance_variable_get(:@context_initialized)
+      Context.instance_variable_set(:@use_strict, true) if "--use_strict" == flag
+    end
+  end
+
+  class Snapshot
+    def load(str)
+      raise TypeError, "wrong type argument #{str.class} (should be a string)" unless str.is_a?(String)
+      # Intentionally noop since TruffleRuby mocks the snapshot API
+    end
+
+    def warmup_unsafe!(src)
+      raise TypeError, "wrong type argument #{src.class} (should be a string)" unless src.is_a?(String)
+      # Intentionally noop since TruffleRuby mocks the snapshot API
+      # by replaying snapshot source before the first eval/call
+      self
+    end
+  end
+
+  # GraalJS has no per-script bytecode cache reachable from
+  # Polyglot::InnerContext#eval, so cached_data: is silently ignored and
+  # Script#run replays the source through Context#eval. compile_module +
+  # dynamic_import_resolver raise NotImplementedError because GraalJS has
+  # its own module-loading mechanism that doesn't map onto this
+  # handle-based API. The MiniRacer::Module class itself is stubbed so
+  # cross-engine code can reference it for is_a? / rescue without
+  # tripping NameError.
+  class Context
+    def compile(source, filename: nil, cached_data: nil, produce_cache: false)
+      raise(ContextDisposedError, 'attempted to call compile on a disposed context!') if @disposed
+      raise TypeError, "wrong type argument #{source.class} (should be a string)" unless source.is_a?(String)
+      raise TypeError, "wrong type argument #{filename.class} (should be a string)" unless filename.nil? || filename.is_a?(String)
+      if cached_data
+        raise TypeError, "wrong type argument #{cached_data.class} (should be a string)" unless cached_data.is_a?(String)
+        raise EncodingError, "cached_data must be ASCII-8BIT (binary), got #{cached_data.encoding}" if cached_data.encoding != Encoding::ASCII_8BIT
+      end
+      # produce_cache is accepted for API parity but has no effect — the shim
+      # has no per-script bytecode cache to produce.
+      Script.send(:new, self, source, filename)
+    end
+
+    def compile_module(*_args, **_opts)
+      raise NotImplementedError,
+            'Context#compile_module is not supported on TruffleRuby'
+    end
+
+    def load_module_graph(*_args, **_opts)
+      raise NotImplementedError,
+            'Context#load_module_graph is not supported on TruffleRuby'
+    end
+
+    # nil is the documented "disable" value; accept it as a no-op so that
+    # `ctx.dynamic_import_resolver ||= ...` style code doesn't crash on
+    # TruffleRuby. Any callable raises, mirroring `compile_module`.
+    def dynamic_import_resolver=(blk)
+      return blk if blk.nil?
+      raise NotImplementedError,
+            'Context#dynamic_import_resolver= is not supported on TruffleRuby'
+    end
+
+    def dynamic_import_resolver = nil
+  end
+
+  class Module
+    UNSUPPORTED = 'MiniRacer::Module is not supported on TruffleRuby'
+
+    def initialize(*)         = raise(NotImplementedError, UNSUPPORTED)
+    def instantiate(*, &_blk) = raise(NotImplementedError, UNSUPPORTED)
+    def evaluate              = raise(NotImplementedError, UNSUPPORTED)
+    def namespace             = raise(NotImplementedError, UNSUPPORTED)
+    def status                = raise(NotImplementedError, UNSUPPORTED)
+    def dispose               = raise(NotImplementedError, UNSUPPORTED)
+    def disposed?             = raise(NotImplementedError, UNSUPPORTED)
+  end
+
+  class Script
+    private_class_method :new
+
+    def initialize(ctx, source, filename)
+      @ctx = ctx
+      @source = source
+      @filename = filename
+      @disposed = false
+    end
+
+    def run
+      raise MiniRacer::RuntimeError, 'disposed script' if @disposed
+      @ctx.eval(@source, filename: @filename) # raises ContextDisposedError if @ctx is disposed
+    end
+
+    def cached_data; nil; end
+    def cache_rejected?; false; end
+
+    def dispose
+      @disposed = true
+      nil
+    end
+
+    def disposed?
+      @disposed
+    end
+  end
+end

data/lib/mini_racer/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module MiniRacer
+  # mini_racer-csim fork: upstream version + a fork revision segment.
+  # 0.21.1.0 = first fork release on upstream 0.21.1; bump the 4th segment for
+  # fork-only changes, reset it when rebasing onto a new upstream version.
+  VERSION = "0.21.1.0"
+  LIBV8_NODE_VERSION = "~> 24.12.0.1"
+end

data/lib/mini_racer-csim.rb

@@ -0,0 +1,4 @@
+# This gem is published as `mini_racer-csim`, but its implementation lives in
+# `mini_racer` (it is a drop-in fork). This shim lets `require 'mini_racer-csim'`
+# — e.g. Bundler's autorequire for the gem name — load the library.
+require 'mini_racer'

data/lib/mini_racer.rb

@@ -0,0 +1,117 @@
+require "mini_racer/version"
+require "pathname"
+
+module MiniRacer
+  class Binary
+    attr_reader :data
+
+    def initialize(data)
+      raise TypeError, "wrong argument type #{data.class} (expected String)" unless data.is_a?(String)
+      @data = data
+    end
+  end
+end
+
+if RUBY_ENGINE == "truffleruby"
+  require "mini_racer/truffleruby"
+else
+  if ENV["LD_PRELOAD"].to_s.include?("malloc")
+    require "mini_racer_extension"
+  else
+    require "mini_racer_loader"
+    ext_filename = "mini_racer_extension.#{RbConfig::CONFIG["DLEXT"]}"
+    # This is the mini_racer-csim fork; fall back to the upstream name and then
+    # to the default require_paths so the extension is found however we're loaded.
+    spec = Gem.loaded_specs["mini_racer-csim"] || Gem.loaded_specs["mini_racer"]
+    ext_path =
+      (spec ? spec.require_paths : %w[lib ext]).map do |p|
+        (p = Pathname.new(p)).absolute? ? p : Pathname.new(__dir__).parent + p
+      end
+    ext_found = ext_path.map { |p| p + ext_filename }.find { |p| p.file? }
+
+    unless ext_found
+      raise LoadError,
+            "Could not find #{ext_filename} in #{ext_path.map(&:to_s)}"
+    end
+    MiniRacer::Loader.load(ext_found.to_s)
+  end
+end
+
+require "thread"
+require "json"
+require "io/wait"
+
+module MiniRacer
+  class Error < ::StandardError; end
+
+  class ContextDisposedError < Error; end
+  class PlatformAlreadyInitialized < Error; end
+
+  class EvalError < Error; end
+  class ParseError < EvalError; end
+  class ScriptTerminatedError < EvalError; end
+  class V8OutOfMemoryError < EvalError; end
+
+  class RuntimeError < EvalError
+    def initialize(message)
+      message, *@frames = message.split("\n")
+      @frames.map! { "JavaScript #{_1.strip}" }
+      super(message)
+    end
+
+    def backtrace
+      frames = super
+      @frames + frames unless frames.nil?
+    end
+  end
+
+  class ScriptError < EvalError
+    def initialize(message)
+      message, *@frames = message.split("\n")
+      @frames.map! { "JavaScript #{_1.strip}" }
+      super(message)
+    end
+
+    def backtrace
+      frames = super || []
+      @frames + frames
+    end
+  end
+
+  class SnapshotError < Error
+    def initialize(message)
+      message, *@frames = message.split("\n")
+      @frames.map! { "JavaScript #{_1.strip}" }
+      super(message)
+    end
+
+    def backtrace
+      frames = super
+      @frames + frames unless frames.nil?
+    end
+  end
+
+  class Context
+    def load(filename)
+      eval(File.read(filename))
+    end
+
+    def write_heap_snapshot(file_or_io)
+      f = nil
+      implicit = false
+
+      if String === file_or_io
+        f = File.open(file_or_io, "w")
+        implicit = true
+      else
+        f = file_or_io
+      end
+
+      raise ArgumentError, "file_or_io" unless File === f
+
+      f.write(heap_snapshot())
+    ensure
+      f.close if implicit
+    end
+  end
+end