therubyracer-tmpfork 0.12.2

data/lib/v8/access/names.rb

@@ -0,0 +1,65 @@
+require 'set'
+class V8::Access
+  module Names
+    def names(obj)
+      accessible_names(obj)
+    end
+
+    def get(obj, name, &dontintercept)
+      methods = accessible_names(obj)
+      if methods.include?(name)
+        method = obj.method(name)
+        method.arity == 0 ? method.call : method.unbind
+      elsif obj.respond_to?(:[]) && !special?(name)
+        obj.send(:[], name, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def set(obj, name, value, &dontintercept)
+      setter = name + "="
+      methods = accessible_names(obj, true)
+      if methods.include?(setter)
+        obj.send(setter, value)
+      elsif obj.respond_to?(:[]=) && !special?(name)
+        obj.send(:[]=, name, value, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def query(obj, name, attributes, &dontintercept)
+      if obj.respond_to?(name)
+        attributes.dont_delete
+        unless obj.respond_to?(name + "=")
+          attributes.read_only
+        end
+      else
+        yield
+      end
+    end
+
+    def delete(obj, name, &dontintercept)
+      yield
+    end
+
+    def accessible_names(obj, special_methods = false)
+      obj.public_methods(false).map {|m| m.to_s}.to_set.tap do |methods|
+        ancestors = obj.class.ancestors.dup
+        while ancestor = ancestors.shift
+          break if ancestor == ::Object
+          methods.merge(ancestor.public_instance_methods(false).map {|m| m.to_s})
+        end
+        methods.reject!(&special?) unless special_methods
+      end
+    end
+
+    private
+
+    def special?(name = nil)
+      @special ||= lambda {|m| m == "[]" || m == "[]=" || m =~ /=$/}
+      name.nil? ? @special : @special[name]
+    end
+  end
+end

data/lib/v8/array.rb

@@ -0,0 +1,26 @@
+class V8::Array < V8::Object
+
+  def initialize(native_or_length = nil)
+    super do
+      if native_or_length.is_a?(Numeric)
+        V8::C::Array::New(native_or_length)
+      elsif native_or_length.is_a?(V8::C::Array)
+        native_or_length
+      else
+        V8::C::Array::New()
+      end
+    end
+  end
+
+  def each
+    @context.enter do
+      0.upto(@native.Length() - 1) do |i|
+        yield @context.to_ruby(@native.Get(i))
+      end
+    end
+  end
+
+  def length
+    @native.Length()
+  end
+end

data/lib/v8/context.rb

@@ -0,0 +1,258 @@
+# -*- coding: utf-8 -*-
+require 'stringio'
+module V8
+  # All JavaScript must be executed in a context. This context consists of a global scope containing the
+  # standard JavaScript objects¨and functions like Object, String, Array, as well as any objects or
+  # functions from Ruby which have been embedded into it from the containing enviroment. E.g.
+  #
+  #     V8::Context.new do |cxt|
+  #         cxt['num'] = 5
+  #         cxt.eval('num + 5') #=> 10
+  #     end
+  #
+  # The same object may appear in any number of contexts, but only one context may be executing JavaScript code
+  # in any given thread. If a new context is opened in a thread in which a context is already opened, the second
+  # context will "mask" the old context e.g.
+  #
+  #   six = 6
+  #   Context.new do |cxt|
+  #     cxt['num'] = 5
+  #     cxt.eval('num') # => 5
+  #     Context.new do |cxt|
+  #       cxt['num'] = 10
+  #       cxt.eval('num') # => 10
+  #       cxt.eval('++num') # => 11
+  #     end
+  #     cxt.eval('num') # => 5
+  #   end
+  class Context
+    include V8::Error::Try
+
+    # @!attribute [r] conversion
+    #   @return [V8::Conversion] conversion behavior for this context
+    attr_reader :conversion
+
+    # @!attrribute [r] access
+    #   @return [V8::Access] Ruby access behavior for this context
+    attr_reader :access
+
+    # @!attribute [r] native
+    #   @return [V8::C::Context] the underlying C++ object
+    attr_reader :native
+
+    # @!attribute [r] timeout
+    #   @return [Number] maximum execution time in milliseconds for scripts executed in this context
+    attr_reader :timeout
+
+    # Creates a new context.
+    #
+    # If passed the `:with` option, that object will be used as
+    # the global scope of the newly creating context. e.g.
+    #
+    #     scope = Object.new
+    #     def scope.hello; "Hi"; end
+    #     V8::Context.new(:with => scope) do |cxt|
+    #       cxt['hello'] #=> 'Hi'
+    #     end
+    #
+    # If passed the `:timeout` option, every eval will timeout once
+    #   N milliseconds elapse
+    #
+    # @param [Hash<Symbol, Object>] options initial context configuration
+    #  * :with scope serves as the global scope of the new context
+    # @yield [V8::Context] the newly created context
+    def initialize(options = {})
+      @conversion = Conversion.new
+      @access = Access.new
+      @timeout = options[:timeout]
+      if global = options[:with]
+        Context.new.enter do
+          global_template = global.class.to_template.InstanceTemplate()
+          @native = V8::C::Context::New(nil, global_template)
+        end
+        enter {link global, @native.Global()}
+      else
+        V8::C::Locker() do
+          @native = V8::C::Context::New()
+        end
+      end
+      yield self if block_given?
+    end
+
+    # Compile and execute a string of JavaScript source.
+    #
+    # If `source` is an IO object it will be read fully before being evaluated
+    #
+    # @param [String,IO] source the source code to compile and execute
+    # @param [String] filename the name to use for this code when generating stack traces
+    # @param [Integer] line the line number to start with
+    # @return [Object] the result of the evaluation
+    def eval(source, filename = '<eval>', line = 1)
+      if IO === source || StringIO === source
+        source = source.read
+      end
+      enter do
+        script = try { V8::C::Script::New(source.to_s, filename.to_s) }
+        if @timeout
+          to_ruby try {script.RunWithTimeout(@timeout)}
+        else
+          to_ruby try {script.Run()}
+        end
+      end
+    end
+
+    # Read a value from the global scope of this context
+    #
+    # @param [Object] key the name of the value to read
+    # @return [Object] value the value at `key`
+    def [](key)
+      enter do
+        to_ruby(@native.Global().Get(to_v8(key)))
+      end
+    end
+
+    # Binds `value` to the name `key` in the global scope of this context.
+    #
+    # @param [Object] key the name to bind to
+    # @param [Object] value the value to bind
+    def []=(key, value)
+      enter do
+        @native.Global().Set(to_v8(key), to_v8(value))
+      end
+      return value
+    end
+
+    # Destroy this context and release any internal references it may
+    # contain to embedded Ruby objects.
+    #
+    # A disposed context may never again be used for anything, and all
+    # objects created with it will become unusable.
+    def dispose
+      return unless @native
+      @native.Dispose()
+      @native = nil
+      V8::C::V8::ContextDisposedNotification()
+      def self.enter
+        fail "cannot enter a context which has already been disposed"
+      end
+    end
+
+    # Returns this context's global object. This will be a `V8::Object`
+    # if no scope was provided or just an `Object` if a Ruby object
+    # is serving as the global scope.
+    #
+    # @return [Object] scope the context's global scope.
+    def scope
+      enter { to_ruby @native.Global() }
+    end
+
+    # Converts a v8 C++ object into its ruby counterpart. This is method
+    # is used to translate all values passed to Ruby from JavaScript, either
+    # as return values or as callback parameters.
+    #
+    # @param [V8::C::Object] v8_object the native c++ object to convert.
+    # @return [Object] to pass to Ruby
+    # @see V8::Conversion for how to customize and extend this mechanism
+    def to_ruby(v8_object)
+      @conversion.to_ruby(v8_object)
+    end
+
+    # Converts a Ruby object into a native v8 C++ object. This method is
+    # used to translate all values passed to JavaScript from Ruby, either
+    # as return value or as callback parameters.
+    #
+    # @param [Object] ruby_object the Ruby object to convert
+    # @return [V8::C::Object] to pass to V8
+    # @see V8::Conversion for customizing and extending this mechanism
+    def to_v8(ruby_object)
+      @conversion.to_v8(ruby_object)
+    end
+
+    # Marks a Ruby object and a v8 C++ Object as being the same. In other
+    # words whenever `ruby_object` is passed to v8, the result of the
+    # conversion should be `v8_object`. Conversely, whenever `v8_object`
+    # is passed to Ruby, the result of the conversion should be `ruby_object`.
+    # The Ruby Racer uses this mechanism to maintain referential integrity
+    # between Ruby and JavaScript peers
+    #
+    # @param [Object] ruby_object the Ruby half of the object identity
+    # @param [V8::C::Object] v8_object the V8 half of the object identity.
+    # @see V8::Conversion::Identity
+    def link(ruby_object, v8_object)
+      @conversion.equate ruby_object, v8_object
+    end
+
+    # Links `ruby_object` and `v8_object` inside the currently entered
+    # context. This is an error if no context has been entered.
+    #
+    # @param [Object] ruby_object the Ruby half of the object identity
+    # @param [V8::C::Object] v8_object the V8 half of the object identity.
+    def self.link(ruby_object, v8_object)
+      current.link ruby_object, v8_object
+    end
+
+    # Run some Ruby code in the context of this context.
+    #
+    # This will acquire the V8 interpreter lock (possibly blocking
+    # until it is available), and prepare V8 for JavaScript execution.
+    #
+    # Only one context may be running at a time per thread.
+    #
+    # @return [Object] the result of executing `block`
+    def enter(&block)
+      if !entered?
+        lock_scope_and_enter(&block)
+      else
+        yield
+      end
+    end
+
+    # Indicates if this context is the currently entered context
+    #
+    # @return true if this context is currently entered
+    def entered?
+      Context.current == self
+    end
+
+    # Get the currently entered context.
+    #
+    # @return [V8::Context] currently entered context, nil if none entered.
+    def self.current
+      Thread.current[:v8_context]
+    end
+
+    # Compile and execute the contents of the file with path `filename`
+    # as JavaScript code.
+    #
+    # @param [String] filename path to the file to execute.
+    # @return [Object] the result of the evaluation.
+    def load(filename)
+      File.open(filename) do |file|
+        self.eval file, filename
+      end
+    end
+
+    private
+
+    def self.current=(context)
+      Thread.current[:v8_context] = context
+    end
+
+    def lock_scope_and_enter
+      current = Context.current
+      Context.current = self
+      V8::C::Locker() do
+        V8::C::HandleScope() do
+          begin
+            @native.Enter()
+            yield if block_given?
+          ensure
+            @native.Exit()
+          end
+        end
+      end
+    ensure
+      Context.current = current
+    end
+  end
+end

data/lib/v8/conversion.rb

@@ -0,0 +1,36 @@
+
+class V8::Conversion
+  include Fundamental
+  include Identity
+
+  def to_ruby(v8_object)
+    super v8_object
+  end
+
+  def to_v8(ruby_object)
+    super ruby_object
+  end
+end
+
+for type in [TrueClass, FalseClass, NilClass, Float] do
+  type.class_eval do
+    include V8::Conversion::Primitive
+  end
+end
+
+for type in [Class, Object, Array, Hash, String, Symbol, Time, Proc, Method, Fixnum] do
+  type.class_eval do
+    include V8::Conversion.const_get(type.name)
+  end
+end
+
+class UnboundMethod
+  include V8::Conversion::Method
+end
+
+for type in [:Object, :String, :Date] do
+  V8::C::const_get(type).class_eval do
+    include V8::Conversion::const_get("Native#{type}")
+  end
+end
+

data/lib/v8/conversion/array.rb

@@ -0,0 +1,11 @@
+class V8::Conversion
+  module Array
+    def to_v8
+      array = V8::Array.new(length)
+      each_with_index do |item, i|
+        array[i] = item
+      end
+      return array.to_v8
+    end
+  end
+end

data/lib/v8/conversion/class.rb

@@ -0,0 +1,119 @@
+class V8::Conversion
+  module Class
+    include V8::Conversion::Code
+
+    def to_template
+      weakcell(:constructor) do
+        template = V8::C::FunctionTemplate::New(V8::Conversion::Constructor.new(self))
+        prototype = template.InstanceTemplate()
+        prototype.SetNamedPropertyHandler(V8::Conversion::Get, V8::Conversion::Set)
+        prototype.SetIndexedPropertyHandler(V8::Conversion::IGet, V8::Conversion::ISet)
+        if self != ::Object && superclass != ::Object && superclass != ::Class
+          template.Inherit(superclass.to_template)
+        end
+        template
+      end
+    end
+  end
+
+  class Constructor
+    include V8::Error::Protect
+
+    def initialize(cls)
+      @class = cls
+    end
+
+    def call(arguments)
+      arguments.extend Args
+      protect do
+        if arguments.linkage_call?
+          arguments.link
+        else
+          arguments.construct @class
+        end
+      end
+      return arguments.This()
+    end
+
+    module Args
+      def linkage_call?
+        self.Length() == 1 && self[0].IsExternal()
+      end
+
+      def link
+        external = self[0]
+        This().SetHiddenValue("rr::implementation", external)
+        context.link external.Value(), This()
+      end
+
+      def construct(cls)
+        context.link cls.new(*to_args), This()
+      end
+
+      def context
+        V8::Context.current
+      end
+
+      def to_args
+        args = ::Array.new(Length())
+        0.upto(args.length - 1) do |i|
+          args[i] = self[i]
+        end
+        return args
+      end
+    end
+  end
+
+  module Accessor
+    include V8::Error::Protect
+    def intercept(info, key, &block)
+      context = V8::Context.current
+      access = context.access
+      object = context.to_ruby(info.This())
+      handles_property = true
+      dontintercept = proc do
+        handles_property = false
+      end
+      protect do
+        result = block.call(context, access, object, context.to_ruby(key), dontintercept)
+        handles_property ? context.to_v8(result) : V8::C::Value::Empty
+      end
+    end
+  end
+
+  class Get
+    extend Accessor
+    def self.call(property, info)
+      intercept(info, property) do |context, access, object, key, dontintercept|
+        access.get(object, key, &dontintercept)
+      end
+    end
+  end
+
+  class Set
+    extend Accessor
+    def self.call(property, value, info)
+      intercept(info, property) do |context, access, object, key, dontintercept|
+        access.set(object, key, context.to_ruby(value), &dontintercept)
+      end
+    end
+  end
+
+  class IGet
+    extend Accessor
+    def self.call(property, info)
+      intercept(info, property) do |context, access, object, key, dontintercept|
+        access.iget(object, key, &dontintercept)
+      end
+    end
+  end
+
+  class ISet
+    extend Accessor
+    def self.call(property, value, info)
+      intercept(info, property) do |context, access, object, key, dontintercept|
+        access.iset(object, key, context.to_ruby(value), &dontintercept)
+      end
+    end
+  end
+end