therubyracer 0.10.2 → 0.11.0beta1

data/lib/v8/access/indices.rb

@@ -0,0 +1,40 @@
+class V8::Access
+  module Indices
+
+    def indices(obj)
+      obj.respond_to?(:length) ? (0..obj.length).to_a : []
+    end
+
+    def iget(obj, index, &dontintercept)
+      if obj.respond_to?(:[])
+        obj.send(:[], index, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def iset(obj, index, value, &dontintercept)
+      if obj.respond_to?(:[]=)
+        obj.send(:[]=, index, value, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def iquery(obj, index, attributes, &dontintercept)
+      if obj.respond_to?(:[])
+        attributes.dont_delete
+        unless obj.respond_to?(:[]=)
+          attributes.read_only
+        end
+      else
+        yield
+      end
+    end
+
+    def idelete(obj, index, &dontintercept)
+      yield
+    end
+
+  end
+end

data/lib/v8/access/invocation.rb

@@ -0,0 +1,47 @@
+class V8::Access
+  module Invocation
+    def methodcall(code, this, args)
+      code.methodcall this, args
+    end
+
+    module Aritize
+      def aritize(args)
+        arity < 0 ? args : Array.new(arity).to_enum(:each_with_index).map {|item, i| args[i]}
+      end
+    end
+
+    module Proc
+      include Aritize
+      def methodcall(this, args)
+        call *aritize([this].concat(args))
+      end
+      ::Proc.send :include, self
+    end
+
+    module Method
+      include Aritize
+      def methodcall(this, args)
+        context = V8::Context.current
+        access = context.access
+        if this.equal? self.receiver
+          call *aritize(args)
+        elsif this.class <= self.receiver.class
+          access.methodcall(unbind, this, args)
+        elsif this.equal? context.scope
+          call *aritize(args)
+        else
+          fail TypeError, "cannot invoke #{self} on #{this}"
+        end
+      end
+      ::Method.send :include, self
+    end
+
+    module UnboundMethod
+      def methodcall(this, args)
+        access = V8::Context.current.access
+        access.methodcall bind(this), this, args
+      end
+      ::UnboundMethod.send :include, self
+    end
+  end
+end

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

@@ -1,17 +1,26 @@
+class V8::Array < V8::Object
 
-module V8
-  class Array < V8::Object
-    
-    def each
-      @portal.open do |to|
-        for i in 0..(@native.Length() - 1)
-          yield to.rb(@native.Get(i))
-        end
+  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 length
-      @native.Length()
+  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

@@ -1,111 +1,118 @@
 require 'stringio'
-
 module V8
   class Context
-    attr_reader :native, :scope, :access
+    include V8::Error::Try
+    attr_reader :native, :conversion, :access
 
-    def initialize(opts = {})
+    def initialize(options = {})
+      @conversion = Conversion.new
       @access = Access.new
-      @to = Portal.new(self, @access)
-      @to.lock do
-        with = opts[:with]
-        constructor = nil
-        template = if with
-          constructor = @to.templates.to_constructor(with.class)
-          constructor.disable()
-          constructor.template.InstanceTemplate()
-        else
-          C::ObjectTemplate::New()
-        end
-        @native = opts[:with] ? C::Context::New(template) : C::Context::New()
-        @native.enter do
-          @global = @native.Global()
-          @to.proxies.register_javascript_proxy @global, :for => with if with
-          constructor.enable() if constructor
-          @scope = @to.rb(@global)
-          @global.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyContext"), C::External::New(self))
+      if global = options[:with]
+        Context.new.enter do
+          global_template = global.class.to_template.InstanceTemplate()
+          @native = V8::C::Context::New(nil, global_template)
         end
-        yield(self) if block_given?
+        enter {link global, @native.Global()}
+      else
+        @native = V8::C::Context::New()
       end
+      yield self if block_given?
     end
 
-    def eval(javascript, filename = "<eval>", line = 1)
-      if IO === javascript || StringIO === javascript
-        javascript = javascript.read()
+    def eval(source, filename = '<eval>', line = 1)
+      if IO === source || StringIO === source
+        source = source.read
       end
-      err = nil
-      value = nil
-      @to.lock do
-        C::TryCatch.try do |try|
-          @native.enter do
-            script = C::Script::Compile(@to.v8(javascript.to_s), @to.v8(filename.to_s))
-            if try.HasCaught()
-              err = JSError.new(try, @to)
-            else
-              result = script.Run()
-              if try.HasCaught()
-                err = JSError.new(try, @to)
-              else
-                value = @to.rb(result)
-              end
-            end
-          end
-        end
-      end
-      raise err if err
-      return value
-    end
-
-    def load(filename)
-      File.open(filename) do |file|
-        self.eval file, filename, 1
+      enter do
+        script = try { V8::C::Script::New(source.to_s, filename.to_s) }
+        to_ruby try {script.Run()}
       end
     end
 
     def [](key)
-      @to.open do
-        @to.rb @global.Get(@to.v8(key))
+      enter do
+        to_ruby(@native.Global().Get(to_v8(key)))
       end
     end
 
     def []=(key, value)
-      @to.open do
-        @global.Set(@to.v8(key), @to.v8(value))
+      enter do
+        @native.Global().Set(to_v8(key), to_v8(value))
       end
       return value
     end
 
-    def self.stack(limit = 99)
-      if native = C::Context::GetEntered()
-        global = native.Global()
-        cxt = global.GetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyContext")).Value()
-        cxt.instance_eval {@to.rb(C::StackTrace::CurrentStackTrace(limit))}
+    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
+
+    def scope
+      enter { to_ruby @native.Global() }
+    end
+
+    def to_ruby(v8_object)
+      @conversion.to_ruby(v8_object)
+    end
+
+    def to_v8(ruby_object)
+      @conversion.to_v8(ruby_object)
+    end
+
+    def link(ruby_object, v8_object)
+      @conversion.equate ruby_object, v8_object
+    end
+
+    def self.link(*args)
+      current.link *args
+    end
+
+    def enter(&block)
+      if !entered?
+        lock_scope_and_enter(&block)
       else
-        []
+        yield
       end
     end
-    
-    def self.passes_this_argument?
-      true
+
+    def entered?
+      Context.current == self
     end
-  end
 
-  module C
-    class Context
-      def enter
-        if block_given?
-          if IsEntered()
-            yield(self)
-          else
-            Enter()
-            begin
-              yield(self)
-            ensure
-              Exit()
-            end
+    def self.current
+      Thread.current[:v8_context]
+    end
+
+    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
+
+    def load(filename)
+      File.open(filename) do |file|
+        self.eval file, filename
+      end
     end
   end
 end

data/lib/v8/conversion.rb

@@ -0,0 +1,35 @@
+
+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, Fixnum] do
+  type.class_eval do
+    include V8::Conversion::Primitive
+  end
+end
+
+for type in [Class, Object, Array, Hash, String, Symbol, Time, Proc, Method] do
+  type.class_eval do
+    include V8::Conversion.const_get(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,120 @@
+class V8::Conversion
+  module Class
+    include V8::Conversion::Code
+
+    def to_template
+      weakcell(:constructor) do
+        template = V8::C::FunctionTemplate::New(Constructor.new(self))
+        prototype = template.InstanceTemplate()
+        prototype.SetNamedPropertyHandler(Get, Set)
+        prototype.SetIndexedPropertyHandler(IGet, ISet)
+        if self != ::Object && superclass != ::Object && superclass != ::Class
+          template.Inherit(superclass.to_template)
+        end
+        template
+      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
+end