mini_racer_rs 1.0.0

data/lib/mini_racer/truffleruby.rb

@@ -0,0 +1,439 @@
+# frozen_string_literal: true
+
+require_relative "shared"
+
+module MiniRacer
+  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: -> do
+            raise ScriptTerminatedError,
+                  "JavaScript was terminated (either by timeout or explicitly)"
+          end
+        )
+      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
+      isolate.instance_variable_set(:@snapshot, snapshot) if isolate && snapshot
+      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) }"
+      # looks up a (dotted) function name as properties from globalThis,
+      # instead of evaluating the name as source code, so that names with
+      # embedded NUL bytes or other invalid syntax resolve correctly
+      @js_lookup_call_target_func = eval_in_context <<~JS
+        (name) => {
+          let target = globalThis;
+          for (const key of name.split(".")) {
+            if (target == null) {
+              throw new ReferenceError(name + " is not defined");
+            }
+            target = target[key];
+          }
+          if (target === undefined) {
+            throw new ReferenceError(name + " is not defined");
+          }
+          return target;
+        }
+      JS
+      @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
+      if @stopped
+        raise RuntimeError, "TruffleRuby does not support eval after stop"
+      end
+      unless str.is_a?(String)
+        raise TypeError, "wrong type argument #{str.class} (should be a string)"
+      end
+      unless filename.nil? || filename.is_a?(String)
+        raise TypeError,
+              "wrong type argument #{filename.class} (should be a string)"
+      end
+
+      str = encode(str)
+      begin
+        translate { eval_in_context(str, filename) }
+      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
+      if @stopped
+        raise RuntimeError, "TruffleRuby does not support call after stop"
+      end
+      begin
+        translate do
+          function =
+            @js_lookup_call_target_func.call(
+              convert_ruby_to_js(encode(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 do |bl|
+            bl&.source_location&.language == "js"
+          end
+        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
+        value
+      when Float
+        # match the C extension: integral doubles convert to Ruby Integers
+        value.finite? && value == value.truncate ? value.to_i : 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)
+          return value.to_a.pack("C*") if uint8_array?(value)
+
+          value.to_ary.map do |e|
+            e.respond_to?(:call) ? nil : convert_js_to_ruby(e)
+          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]
+            h[member.to_s] = convert_js_to_ruby(v) unless v.respond_to?(:call)
+          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 { |v, i| ary[i] = convert_ruby_to_js(v) }
+        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)
+      unless flag.is_a?(String)
+        raise TypeError,
+              "wrong type argument #{flag.class} (should be a string)"
+      end
+      raise ArgumentError, "flag contains NUL byte" if flag.include?("\0")
+      # the C extension normalizes flags into a 256 byte "--flag" buffer
+      normalized = flag.start_with?("--") ? flag : "--#{flag}"
+      raise ArgumentError, "flag too long" if normalized.bytesize >= 256
+      if Context.instance_variable_get(:@context_initialized)
+        raise MiniRacer::PlatformAlreadyInitialized,
+              "The platform is already initialized."
+      end
+      if "--use_strict" == flag
+        Context.instance_variable_set(:@use_strict, true)
+      end
+    end
+  end
+
+  class Snapshot
+    def load(str)
+      unless str.is_a?(String)
+        raise TypeError, "wrong type argument #{str.class} (should be a string)"
+      end
+      # Intentionally noop since TruffleRuby mocks the snapshot API
+    end
+
+    def warmup_unsafe!(src)
+      unless src.is_a?(String)
+        raise TypeError, "wrong type argument #{src.class} (should be a string)"
+      end
+      # Intentionally noop since TruffleRuby mocks the snapshot API
+      # by replaying snapshot source before the first eval/call
+      self
+    end
+  end
+end

data/lib/mini_racer/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module MiniRacer
+  VERSION = "0.22.1"
+  LIBV8_NODE_VERSION = "~> 24.12.0.1"
+end

data/lib/mini_racer.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "mini_racer_rs"

data/lib/mini_racer_rs/internal_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module MiniRacer
+  # mini_racer defines this in its C extension, so it exists only on CRuby.
+  class InternalError < EvalError
+  end
+end

data/lib/mini_racer_rs/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MiniRacerRs
+  VERSION = "1.0.0"
+end

data/lib/mini_racer_rs/vocabulary.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# The classes below reproduce mini_racer's Ruby vocabulary
+# (lib/mini_racer.rb, MIT, Copyright (c) 2016-2019 the mini_racer project authors).
+
+require "pathname"
+require "json"
+require "io/wait"
+require_relative "../mini_racer/version"
+
+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
+
+  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 file_or_io.is_a?(String)
+        f = File.open(file_or_io, "w")
+        implicit = true
+      else
+        f = file_or_io
+      end
+
+      raise ArgumentError, "file_or_io" unless f.is_a?(File)
+
+      f.write(heap_snapshot)
+    ensure
+      f.close if implicit
+    end
+  end
+end

data/lib/mini_racer_rs.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+if (spec = Gem.loaded_specs["mini_racer"]) && spec.metadata["mini_racer_rs_shim"] != "true"
+  raise LoadError,
+        "mini_racer_rs and the mini_racer #{spec.version} gem are both active; " \
+        "remove mini_racer from the bundle, or use the shim gemspec from mini_racer_rs"
+end
+
+upstream_ext = %r{/mini_racer_(?:extension|loader)\.#{Regexp.escape(RbConfig::CONFIG["DLEXT"])}\z}o
+if $LOADED_FEATURES.any? { upstream_ext.match?(_1) }
+  raise LoadError, "the mini_racer gem's native extension is already loaded; mini_racer_rs cannot replace it"
+end
+
+require_relative "mini_racer_rs/version"
+require_relative "mini_racer_rs/vocabulary"
+
+if RUBY_ENGINE == "truffleruby"
+  require_relative "mini_racer/truffleruby"
+else
+  require_relative "mini_racer_rs/internal_error"
+  native = ["#{RUBY_VERSION[/\A\d+\.\d+/]}/mini_racer_rs", "mini_racer_rs"].find do |name|
+    File.file?(File.join(__dir__, "mini_racer_rs", "#{name}.#{RbConfig::CONFIG["DLEXT"]}"))
+  end
+  raise LoadError, "mini_racer_rs native extension not found; run `rake compile`" unless native
+
+  require_relative "mini_racer_rs/#{native}"
+
+  unless MiniRacerRs::NATIVE_VERSION == MiniRacerRs::VERSION
+    raise LoadError,
+          "mini_racer_rs native extension #{MiniRacerRs::NATIVE_VERSION} does not match " \
+          "the gem #{MiniRacerRs::VERSION}; run `rake compile`"
+  end
+end

data/licenses/mini_racer.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-2019, the mini_racer project authors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/licenses/rust/SOURCES.tsv

@@ -0,0 +1,6 @@
+# rust 1.99.1
+# component	file	source	sha256
+std	COPYRIGHT	https://raw.githubusercontent.com/rust-lang/rust/1.99.1/COPYRIGHT	172020dbfd5b53a226dfde77616190a48dcff519b0bc0e6deb91a8450782c4af
+std	LICENSE-APACHE	https://raw.githubusercontent.com/rust-lang/rust/1.99.1/LICENSE-APACHE	62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a
+std	LICENSE-MIT	https://raw.githubusercontent.com/rust-lang/rust/1.99.1/LICENSE-MIT	b71bd43a069ca0641a9ecfe585ca7b3c53b5cc1608f8b68321168698e28b5ea1
+std	COPYRIGHT-library.html	rustc 1.99.1: share/doc/rust/COPYRIGHT-library.html	5647be074c8edf7339fd863055923a8fc80bc5610a8d4661ec3b767b9d392c27

data/licenses/rust/std/COPYRIGHT

@@ -0,0 +1,34 @@
+Short version for non-lawyers:
+
+The Rust Project is dual-licensed under Apache 2.0 and MIT
+terms.
+
+It is Copyright (c) The Rust Project Contributors.
+
+Longer version:
+
+Copyrights in the Rust project are retained by their contributors. No
+copyright assignment is required to contribute to the Rust project.
+
+Some files include explicit copyright notices and/or license notices.
+For full authorship information, see the version control history or
+<https://thanks.rust-lang.org>
+
+Except as otherwise noted, Rust is licensed under the Apache License, Version
+2.0 <LICENSE-APACHE> or <http://www.apache.org/licenses/LICENSE-2.0> or the MIT
+license <LICENSE-MIT> or <http://opensource.org/licenses/MIT>, at your option.
+
+We track licenses for third-party materials in two ways:
+
+* We use [REUSE](https://reuse.software) to track license information for
+  in-tree source files - both those authored by the Rust project and those
+  authored by third parties. See `REUSE.toml`, and our cached output of the
+  `reuse` tool which is committed to `license-metadata.json`.
+* We use `cargo` to track license information for out-of-tree dependencies.
+
+These two sources of information are collected by the tool `generate-copyright`
+into a file called `COPYRIGHT.html`, which is shipped with each binary release
+of Rust. Please refer to that file for detailed information as to the components of
+any given Rust release. We also produce a `COPYRIGHT-library.html` file which only
+covers the subset of source code used in the Rust Standard Library, as opposed
+to the toolchain as a whole.