therubyracer 0.8.2 → 0.9.0beta1

data/ext/v8/v8_value.h

@@ -3,8 +3,8 @@
 
 #include "rr.h"
 
-extern VALUE rr_cV8_C_Value;
-extern VALUE rr_cV8_C_Empty;
 void rr_init_value();
 VALUE rr_wrap_v8_value(v8::Handle<v8::Value>& value);
+VALUE rr_v8_value_class();
+VALUE rr_v8_value_empty();
 #endif

data/ext/v8/v8_weakref.cpp

@@ -0,0 +1,51 @@
+#include "v8.h"
+#include "v8_weakref.h"
+
+using namespace v8;
+
+v8_weakref::v8_weakref(VALUE object) {
+  this->external = Persistent<External>::New(External::New((void *)this));
+  this->external.MakeWeak(this, v8_weakref_dispose);
+  this->set(object);
+}
+
+void v8_weakref::set(VALUE value) {
+  this->object_id = rb_obj_id(value);
+  VALUE data = Data_Wrap_Struct(rb_cObject, 0, 0, this);
+  VALUE finalizer = rb_proc_new((VALUE (*)(...))v8_weakref_finalize, data);
+  rb_funcall(v8_weakref_objectspace(), rb_intern("define_finalizer"), 2, value, finalizer);
+}
+
+VALUE v8_weakref::get() {
+  if (this->object_id) {
+    return rb_rescue((VALUE (*)(...))v8_weakref_id2ref, this->object_id, (VALUE (*)(...))v8_weakref_nil, Qnil);
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE v8_weakref_finalize(VALUE object_id, VALUE data) {
+  v8_weakref* weakref = 0;
+  Data_Get_Struct(data, struct v8_weakref, weakref);
+  weakref->object_id = Qnil;
+  return Qnil;
+}
+
+void v8_weakref_dispose(Persistent<Value> value, void* weakref) {
+  value.Dispose();
+  value.Clear();
+  delete (v8_weakref*)weakref;
+}
+
+VALUE v8_weakref_nil(VALUE nil, VALUE exception) {
+  return nil;
+}
+
+VALUE v8_weakref_objectspace() {
+  return rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
+}
+
+VALUE v8_weakref_id2ref(VALUE id) {
+  return rb_funcall(v8_weakref_objectspace(), rb_intern("_id2ref"), 1, id);
+}
+

data/ext/v8/v8_weakref.h

@@ -0,0 +1,30 @@
+#ifndef _RR_V8_WEAKREF_
+#define _RR_V8_WEAKREF_ 
+
+#include <v8.h>
+#include "ruby.h"
+#include "ruby/version.h"
+
+struct v8_weakref  {
+  v8_weakref(VALUE object);
+  VALUE get();
+  void set(VALUE object);
+  void retain();
+  void release();
+
+  VALUE object_id;
+  v8::Persistent<v8::External> external;
+};
+
+void  v8_weakref_dispose(v8::Persistent<v8::Value> value, void* weakref);
+VALUE v8_weakref_finalize(VALUE self, VALUE object_id);
+VALUE v8_weakref_objectspace();
+VALUE v8_weakref_nil(VALUE nil, VALUE exception);
+VALUE v8_weakref_id2ref(VALUE id);
+
+
+#if RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8
+extern "C" VALUE rb_proc_new(VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE);
+#endif
+
+#endif

data/lib/v8.rb

@@ -5,7 +5,12 @@ module V8
   require 'v8/version'
   require 'v8/v8' #native glue
   require 'v8/portal'
-  require 'v8/portal/functions'
+  require 'v8/portal/caller'
+  require 'v8/portal/proxies'
+  require 'v8/portal/templates'
+  require 'v8/portal/function'
+  require 'v8/portal/constructor'
+  require 'v8/portal/interceptors'
   require 'v8/context'
   require 'v8/object'
   require 'v8/array'

data/lib/v8/context.rb

@@ -7,11 +7,21 @@ module V8
     def initialize(opts = {})
       @access = Access.new
       @to = Portal.new(self, @access)
-      @native = opts[:with] ? C::Context::New(@to.rubytemplate) : C::Context::New()
+      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::New("TheRubyRacer::RubyObject"), C::External::New(opts[:with])) if opts[:with]
         @global.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyContext"), C::External::New(self))
       end
       yield(self) if block_given?
@@ -58,7 +68,7 @@ module V8
 
     def self.stack(limit = 99)
       if native = C::Context::GetEntered()
-        global = native.Global().instance_eval {@native}
+        global = native.Global()
         cxt = global.GetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyContext")).Value()
         cxt.instance_eval {@to.rb(C::StackTrace::CurrentStackTrace(limit))}
       else

data/lib/v8/error.rb

@@ -106,7 +106,7 @@ module V8
     #in these instances, we have to pull it out of the Message object
     #in the TryCatch. Is there a better way to detect a syntax error
     def syntax_error?(try)
-      ex = try.Exception()
+      ex = @to.rb(try.Exception())
       if ex && ex.kind_of?(V8::Object)
         type = ex["constructor"]
         type && type.kind_of?(V8::Function) && type.name == "SyntaxError"

data/lib/v8/portal.rb

@@ -1,73 +1,14 @@
 
 module V8
   class Portal
-    attr_reader :context
+    attr_reader :context, :access, :proxies, :templates, :interceptors, :caller
 
     def initialize(context, access)
       @context, @access = context, access
-      @named_property_getter = Interceptor(NamedPropertyGetter)
-      @named_property_setter = Interceptor(NamedPropertySetter)
-      @named_property_query = nil
-      @named_property_deleter = nil
-      @named_property_enumerator = Interceptor(NamedPropertyEnumerator)
-
-      @indexed_property_getter = Interceptor(IndexedPropertyGetter)
-      @indexed_property_setter = Interceptor(IndexedPropertySetter)
-      @indexed_property_query = nil
-      @indexed_property_deleter = nil
-      @indexed_property_enumerator = Interceptor(IndexedPropertyEnumerator)
-
-      @constructors = Hash.new do |h, cls|
-        h[cls] = template = C::FunctionTemplate::New() do |arguments|
-          unless arguments.Length() == 1 && arguments[0].kind_of?(C::External)
-            C::ThrowException(C::Exception::Error(C::String::New("cannot call native constructor from javascript")))
-          else
-            arguments.This().tap do |this|
-              this.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), arguments[0])              
-            end
-          end
-        end
-        template.tap do
-          setuptemplate(template.InstanceTemplate())
-          if cls != ::Object && cls.superclass != ::Object && cls.superclass != ::Class
-            template.Inherit(@constructors[cls.superclass])
-          end
-          if cls.name && cls.name =~ /(::)?(\w+?)$/
-            template.SetClassName(C::String::NewSymbol("rb::" + $2))
-          else
-            template.SetClassName("Ruby")
-          end
-        end
-      end
-
-      @instances = Hash.new do |h, obj|
-        args = C::Array::New(1)
-        args.Set(0, C::External::New(obj))
-        h[obj] = @constructors[obj.class].GetFunction().NewInstance(args)
-      end
-
-      @functions = Functions.new(self)
-
-      @embedded_constructors = Hash.new do |h, cls|
-        template = @constructors[cls]
-        template.SetCallHandler() do |arguments|
-          wrap = nil
-          if arguments.Length() > 0 && arguments[0].kind_of?(C::External)
-            wrap = arguments[0]
-          else
-            rbargs = []
-            for i in 0..arguments.Length() - 1
-              rbargs << rb(arguments[i])
-            end
-            instance = rubysend(cls, :new, *rbargs)
-            wrap = C::External::New(instance)
-          end
-          arguments.This().tap do |this|
-            this.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), wrap)
-          end
-        end
-        h[cls] = template
-      end
+      @proxies = Proxies.new
+      @templates = Templates.new(self)
+      @interceptors = Interceptors.new(self)
+      @caller = Caller.new(self)
     end
 
     def open
@@ -77,16 +18,18 @@ module V8
     end
 
     def rb(value)
-      case value
-      when V8::C::Function    then peer(value) {V8::Function}
-      when V8::C::Array       then peer(value) {V8::Array}
-      when V8::C::Object      then peer(value) {V8::Object}
-      when V8::C::String      then value.Utf8Value.tap {|s| return s.respond_to?(:force_encoding) ? s.force_encoding("UTF-8") : s}
-      when V8::C::Date        then Time.at(value.NumberValue() / 1000)
-      when V8::C::StackTrace  then V8::StackTrace.new(self, value)
-      when V8::C::Value       then nil if value.IsEmpty()
-      else
-        value
+      @proxies.js2rb(value) do
+        case value
+          when V8::C::Function    then V8::Function.new(value, self)
+          when V8::C::Array       then V8::Array.new(value, self)
+          when V8::C::Object      then V8::Object.new(value, self)
+          when V8::C::String      then value.Utf8Value.tap {|s| return s.respond_to?(:force_encoding) ? s.force_encoding("UTF-8") : s}
+          when V8::C::Date        then Time.at(value.NumberValue() / 1000)
+          when V8::C::StackTrace  then V8::StackTrace.new(self, value)
+          when V8::C::Value       then nil if value.IsEmpty()
+        else
+          value
+        end
       end
     end
 
@@ -99,7 +42,9 @@ module V8
       when Symbol
         C::String::NewSymbol(value.to_s)
       when Proc,Method,UnboundMethod
-        @functions[value]
+        @proxies.rb2js(value) do
+          @templates.to_function(value).function
+        end
       when ::Array
         C::Array::New(value.length).tap do |a|
           value.each_with_index do |item, i|
@@ -115,212 +60,16 @@ module V8
       when ::Time
         C::Date::New(value.to_f * 1000)
       when ::Class
-        @embedded_constructors[value].GetFunction().tap do |f|
-          f.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), C::External::New(value))
-          #set the function's prototype object to the object that will have the named property handlers
-          prototype = rubytemplate.NewInstance()
-          #set *that* object's prototype to an empty function so that it will look and behave like a function.
-          prototype.SetPrototype(C::FunctionTemplate::New() {}.GetFunction())
-          f.SetPrototype(prototype)
+        @proxies.rb2js(value) do
+          constructor = @templates.to_constructor(value)
+          constructor.exposed = true
+          constructor.function
         end
       when nil,Numeric,TrueClass,FalseClass, C::Value
         value
       else
-        @instances[value]
-      end
-    end
-
-    def rubyprotect
-      begin
-        v8 yield
-      rescue Exception => e
-        case e
-        when SystemExit, NoMemoryError
-          raise e
-        else
-          error = V8::C::Exception::Error(V8::C::String::New(e.message))
-          error.SetHiddenValue("TheRubyRacer::Cause", C::External::New(e))
-          V8::C::ThrowException(error)
-        end
-      end
-    end
-
-    def rubycall(rubycode, *args, &block)
-      rubyprotect do
-        rubycode.call(*args, &block)
-      end
-    end
-
-    def rubysend(obj, message, *args, &block)
-      rubyprotect do
-        obj.send(message, *args, &block)
-      end
-    end
-    
-    def rubytemplate
-      C::ObjectTemplate::New().tap do |t|
-        setuptemplate(t)
-      end
-    end
-    
-    def setuptemplate(t)
-      t.SetNamedPropertyHandler(
-        @named_property_getter,
-        @named_property_setter,
-        nil,
-        nil,
-        @named_property_enumerator
-      )
-      t.SetIndexedPropertyHandler(
-        @indexed_property_getter,
-        @indexed_property_setter,
-        nil,
-        nil,
-        @indexed_property_enumerator
-      )
-    end
-
-    private
-
-    def peer(value)
-      external = value.GetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"))
-      if external && !external.IsEmpty()
-        external.Value()
-      else
-        yield.new(value, self).tap do |object|
-          value.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), C::External::New(object))
-        end
-      end
-    end
-
-    class Interceptor
-      def initialize(portal, access)
-        @to, @access = portal, access
-      end
-
-      def intercept(info, retval = nil, &code)
-        obj = @to.rb(info.This())
-        intercepts = true
-        result = @to.rubyprotect do
-          dontintercept = proc do
-            intercepts = false
-          end
-          code.call(obj, dontintercept)
-        end
-        intercepts ? (retval || result) : C::Empty
-      end
-
-    end
-
-    def Interceptor(cls)
-      cls.new self, @access
-    end
-
-    class PropertyAttributes
-      attr_reader :flags
-      def initialize
-        @flags = 0
-      end
-
-      def read_only
-        tap do
-          @flags |= V8::C::ReadOnly
-        end
-      end
-
-      def dont_enum
-        tap do
-          @flags |= V8::C::DontEnum
-        end
-      end
-
-      def dont_delete
-        tap do
-          @flags |= V8::C::DontDelete
-        end
-      end
-    end
-    
-    class NamedPropertyGetter < Interceptor
-      def call(property, info)
-        intercept(info) do |obj, dontintercept|
-          @access.get(obj, @to.rb(property), &dontintercept)
-        end
-      end
-    end
-
-    class NamedPropertySetter < Interceptor
-      def call(property, value, info)
-        intercept(info, value) do |obj, dontintercept|
-          @access.set(obj, @to.rb(property), @to.rb(value), &dontintercept)
-        end
-      end
-    end
-
-    class NamedPropertyQuery
-      def call(property, info)
-        attributes = PropertyAttributes.new
-        result = intercept(info) do |obj, dontintercept|
-          @access.query(obj, @to.rb(property), attributes, &dontintercept)
-        end
-        return result == C::Empty ? result : C::Integer::New(attributes.flags)
-      end
-    end
-
-    class NamedPropertyEnumerator < Interceptor
-      def call(info)
-        intercept(info) do |obj, dontintercept|
-          @access.names(obj, &dontintercept).to_a
-        end
-      end
-    end
-    
-    class NamedPropertyDeleter < Interceptor
-      def call(property, info)
-        intercept(info) do |obj, dontintercept|
-          @access.delete(obj, property, &dontintercept)
-        end
-      end
-    end
-
-    class IndexedPropertyGetter < Interceptor
-      def call(index, info)
-        intercept(info) do |obj, dontintercept|
-          @access.iget(obj, index, &dontintercept)
-        end
-      end
-    end
-
-    class IndexedPropertySetter < Interceptor
-      def call(index, value, info)
-        intercept(info, value) do |obj, dontintercept|
-          @access.iset(obj, index, @to.rb(value), &dontintercept)
-        end
-      end
-    end
-
-    class IndexedPropertyQuery < Interceptor
-      def call(property, info)
-        attributes = PropertyAttributes.new
-        result = intercept(info) do |obj, dontintercept|
-          @access.indices(obj, &dontintercept)
-        end
-        result == C::Empty ? C::Empty : C::Integer::New(attributes.flags)
-      end
-    end
-
-    class IndexedPropertyDeleter < Interceptor
-      def call(index, info)
-        intercept(info) do |obj, dontintercept|
-          @access.idelete(obj, index, &dontintercept)
-        end
-      end
-    end
-    
-    class IndexedPropertyEnumerator < Interceptor
-      def call(info)
-        intercept(info) do |obj, dontintercept|
-          @access.indices(obj, &dontintercept)
+        @proxies.rb2js(value) do
+          @templates.to_constructor(value.class).allocate(value)
         end
       end
     end