therubyracer 0.7.1 → 0.7.2.pre

data/ext/v8/v8_obj.h

@@ -7,6 +7,5 @@ extern VALUE rr_cV8_C_Object;
 
 void rr_init_obj();
 VALUE rr_reflect_v8_object(v8::Handle<v8::Value> value);
-v8::Handle<v8::Value> rr_reflect_rb_object(VALUE value);
 
 #endif

data/ext/v8/v8_ref.cpp

@@ -2,9 +2,8 @@
 #include "stdio.h"
 using namespace v8;
 
-v8_ref::v8_ref(Handle<void> object, VALUE ref) : handle(Persistent<void>::New(object)) {
+v8_ref::v8_ref(Handle<void> object) : handle(Persistent<void>::New(object)) {
   this->references = rb_hash_new();
-  this->set("default", ref);
 }
 
 v8_ref::~v8_ref() {  
@@ -27,10 +26,6 @@ namespace {
   }
 }
 
-VALUE V8_Ref_Create(VALUE ruby_class, v8::Handle<void> handle, VALUE ref) {
-  return Data_Wrap_Struct(ruby_class, gc_mark, gc_free, new v8_ref(handle, ref));
-}
-
 VALUE rr_v8_ref_create(VALUE rbclass, v8::Handle<void> handle) {
   return Data_Wrap_Struct(rbclass, gc_mark, gc_free, new v8_ref(handle));
 }

data/ext/v8/v8_ref.h

@@ -9,7 +9,7 @@
 struct v8_ref  {
   //takes a handle object and adds a new persistent handle for 
   //the referenced object
-  v8_ref(v8::Handle<void> object, VALUE ref = 0);
+  v8_ref(v8::Handle<void> object);
   virtual ~v8_ref();
   void set(const char *name, VALUE ref);
   v8::Persistent<void> handle;
@@ -17,7 +17,6 @@ struct v8_ref  {
 };
 
 void rr_v8_ref_setref(VALUE handle, const char *name, VALUE ref);
-VALUE V8_Ref_Create(VALUE ruby_class, v8::Handle<void> handle, VALUE ref = 0);
 VALUE rr_v8_ref_create(VALUE rbclass, v8::Handle<void> handle);
 
 template <class T> v8::Local<T> V8_Ref_Get(VALUE object) {

data/ext/v8/v8_script.cpp

@@ -1,7 +1,6 @@
 #include "v8.h"
 #include "v8_ref.h"
 #include "v8_script.h"
-#include "converters.h"
 
 using namespace v8;
 
@@ -32,5 +31,4 @@ void rr_init_script() {
   rr_define_singleton_method(ScriptClass, "New", New, 2);
   rr_define_singleton_method(ScriptClass, "Compile", Compile, 2);
   rr_define_method(ScriptClass, "Run", Run, 0);
-  rb_funcall(ScriptClass, rb_intern("private_class_method"), 1, rb_str_new2("new"));
 }

data/ext/v8/v8_str.cpp

@@ -12,10 +12,15 @@ namespace {
   Handle<String> unwrap(VALUE value) {
     return V8_Ref_Get<String>(value);
   }
-  VALUE New(VALUE klazz, VALUE data) {
+  VALUE New(VALUE string_class, VALUE data) {
     HandleScope handles;
     VALUE str = rb_funcall(data, rb_intern("to_s"), 0);
-    return V8_Ref_Create(StringClass, String::New(RSTRING_PTR(str), RSTRING_LEN(str)));
+    return rr_v8_ref_create(string_class, String::New(RSTRING_PTR(str), RSTRING_LEN(str)));
+  }
+  VALUE NewSymbol(VALUE string_class, VALUE data) {
+    HandleScope scope;
+    VALUE str = rb_funcall(data, rb_intern("to_s"), 0);
+    return rr_v8_ref_create(string_class, String::NewSymbol(RSTRING_PTR(str), RSTRING_LEN(str)));
   }
   VALUE Utf8Value(VALUE self) {
     HandleScope handles;
@@ -34,12 +39,13 @@ namespace {
 VALUE rr_reflect_v8_string(Handle<Value> value) {
   HandleScope handles;
   Local<String> string = String::Cast(*value);
-  return V8_Ref_Create(StringClass, string);
+  return rr_v8_ref_create(StringClass, string);
 }
 
 void rr_init_str() {
   StringClass = rr_define_class("String", rr_cV8_C_Value);
   rr_define_singleton_method(StringClass, "New", New, 1);
+  rr_define_singleton_method(StringClass, "NewSymbol", NewSymbol, 1);
   rr_define_method(StringClass, "Utf8Value", Utf8Value, 0);
   rr_define_method(StringClass, "Utf16Value", Utf16Value, 0);
   rr_define_method(StringClass, "AsciiValue", AsciiValue, 0);

data/ext/v8/v8_str.h

@@ -5,7 +5,5 @@
 
 void rr_init_str();
 
-VALUE v8_str_new(VALUE clazz, VALUE str);
-VALUE v8_str_to_s(VALUE self);
 VALUE rr_reflect_v8_string(v8::Handle<v8::Value> value);
 #endif

data/ext/v8/v8_template.cpp

@@ -1,17 +1,17 @@
-#include <ruby.h>
-#include <v8.h>
+#include "rr.h"
 #include "v8_ref.h"
 #include "v8_func.h"
 #include "v8_template.h"
 #include "v8_external.h"
 #include "v8_callbacks.h"
-#include "callbacks.h"
-#include "converters.h"
 
 using namespace v8;
 
 namespace {
 
+  VALUE ObjectTemplateClass;
+  VALUE FunctionTemplateClass;
+
   VALUE rb_hash_lookup(VALUE hash, const char *key) {
     return rb_funcall(hash, rb_intern("[]"), 1, rb_str_new2(key));
   }
@@ -55,7 +55,6 @@ namespace {
      * Otherwise, returns an empty handle.
      */
     Handle<Value> RubyNamedPropertySetter(Local<String> property, Local<Value> value, const AccessorInfo& info) {
-      HandleScope handles;
       VALUE code = (VALUE)External::Unwrap(info.Data());
       VALUE setter = rb_hash_lookup(code, "setter");
       VALUE result = rb_funcall(setter, rb_intern("call"), 3, rr_v82rb(property), rr_v82rb(value), rr_v82rb(info));
@@ -68,7 +67,6 @@ namespace {
      * The result is true if the property exists and false otherwise.
      */
     Handle<Boolean> RubyNamedPropertyQuery(Local<String> property, const AccessorInfo& info) {
-      HandleScope handles;
       VALUE code = (VALUE)External::Unwrap(info.Data());
       VALUE query = rb_hash_lookup(code, "query");
       VALUE result = rb_funcall(query, rb_intern("call"), 2, rr_v82rb(property), rr_v82rb(info));
@@ -82,7 +80,6 @@ namespace {
      * otherwise.
      */
     Handle<Boolean> RubyNamedPropertyDeleter(Local<String> property, const AccessorInfo& info) {
-      HandleScope handles;
       VALUE code = (VALUE)External::Unwrap(info.Data());
       VALUE deleter = rb_hash_lookup(code, "deleter");
       VALUE result = rb_funcall(deleter, rb_intern("call"), 2, rr_v82rb(property), rr_v82rb(info));
@@ -95,7 +92,6 @@ namespace {
      * property getter intercepts.
      */
     Handle<Array> RubyNamedPropertyEnumerator(const AccessorInfo& info) {
-      HandleScope handles;
       VALUE code = (VALUE)External::Unwrap(info.Data());
       VALUE enumerator = rb_hash_lookup(code, "enumerator");
       VALUE result = rb_funcall(enumerator, rb_intern("call"), 1, rr_v82rb(info));
@@ -111,9 +107,9 @@ namespace {
       }
     }
 
-    VALUE New(VALUE clazz) {
+    VALUE New(VALUE rbclass) {
       HandleScope handles;
-      return V8_Ref_Create(clazz, ObjectTemplate::New());
+      return rr_v8_ref_create(rbclass, ObjectTemplate::New());
     }
     VALUE NewInstance(VALUE self) {
       HandleScope scope;
@@ -156,7 +152,6 @@ namespace {
   namespace Func {
 
     Handle<Value> RubyInvocationCallback(const Arguments& args) {
-      HandleScope handles;
       VALUE code = (VALUE)External::Unwrap(args.Data());
       VALUE rb_args = rr_v82rb(args);
       VALUE result = rb_funcall(code, rb_intern("call"), 1, rb_args);
@@ -165,13 +160,41 @@ namespace {
 
     VALUE New(VALUE function_template) {
       HandleScope handles;
-      rb_need_block();
       VALUE code = rb_block_proc();
       if (NIL_P(code)) {
         return Qnil;
       }
       Local<FunctionTemplate> templ = FunctionTemplate::New(RubyInvocationCallback, rr_v8_external_create(code));
-      return V8_Ref_Create(function_template,templ,code);
+      VALUE ref = rr_v8_ref_create(function_template,templ);
+      rr_v8_ref_setref(ref, "code", code);
+      return ref;
+    }
+    VALUE SetCallHandler(VALUE self) {
+      HandleScope handles;
+      VALUE code = rb_block_proc();
+      if (NIL_P(code)) {
+        return Qnil;
+      }
+      func(self)->SetCallHandler(RubyInvocationCallback, rr_v8_external_create(code));
+      return Qnil;
+    }
+    VALUE PrototypeTemplate(VALUE self) {
+      HandleScope scope;
+      return rr_v8_ref_create(ObjectTemplateClass, func(self)->PrototypeTemplate());
+    }
+    VALUE InstanceTemplate(VALUE self) {
+      HandleScope scope;
+      return rr_v8_ref_create(ObjectTemplateClass, func(self)->InstanceTemplate());
+    }
+    VALUE Inherit(VALUE self, VALUE function_template) {
+      HandleScope scope;
+      func(self)->Inherit(func(function_template));
+      return Qnil;
+    }
+    VALUE SetClassName(VALUE self, VALUE name) {
+      HandleScope scope;
+      func(self)->SetClassName(rr_rb2v8(name)->ToString());
+      return Qnil;
     }
     VALUE GetFunction(VALUE self) {
       HandleScope handles;
@@ -188,28 +211,17 @@ void rr_init_template() {
   VALUE Template = rr_define_class("Template");
   rr_define_method(Template, "Set", Set, 2);
 
-  VALUE ObjectTemplate = rr_define_class("ObjectTemplate", Template);
-  rr_define_singleton_method(ObjectTemplate, "New", Obj::New, 0);
-  rr_define_method(ObjectTemplate, "NewInstance", Obj::NewInstance, 0);
-  rr_define_method(ObjectTemplate, "SetNamedPropertyHandler", Obj::SetNamedPropertyHandler, 5);
-
-  VALUE FunctionTemplate = rr_define_class("FunctionTemplate", Template);
-  rr_define_singleton_method(FunctionTemplate, "New", Func::New, 0);
-  rr_define_method(FunctionTemplate, "GetFunction", Func::GetFunction, 0);
-
-
-}
-
-Local<ObjectTemplate> Racer_Create_V8_ObjectTemplate(VALUE value) {
-    Local<ObjectTemplate> tmpl = ObjectTemplate::New();
-  // tmpl->SetInternalFieldCount(2);
-  tmpl->SetNamedPropertyHandler(
-    RacerRubyNamedPropertyGetter,
-    RacerRubyNamedPropertySetter,
-    0, // RacerRubyNamedPropertyQuery,
-    0, // RacerRubyNamedPropertyDeleter,
-    RacerRubyNamedPropertyEnumerator,
-    rr_v8_external_create(value)
-  );
-  return tmpl;
+  ObjectTemplateClass = rr_define_class("ObjectTemplate", Template);
+  rr_define_singleton_method(ObjectTemplateClass, "New", Obj::New, 0);
+  rr_define_method(ObjectTemplateClass, "NewInstance", Obj::NewInstance, 0);
+  rr_define_method(ObjectTemplateClass, "SetNamedPropertyHandler", Obj::SetNamedPropertyHandler, 5);
+
+  FunctionTemplateClass = rr_define_class("FunctionTemplate", Template);
+  rr_define_singleton_method(FunctionTemplateClass, "New", Func::New, 0);
+  rr_define_method(FunctionTemplateClass, "SetCallHandler", Func::SetCallHandler, 0);
+  rr_define_method(FunctionTemplateClass, "PrototypeTemplate", Func::PrototypeTemplate, 0);
+  rr_define_method(FunctionTemplateClass, "InstanceTemplate", Func::InstanceTemplate, 0);
+  rr_define_method(FunctionTemplateClass, "Inherit", Func::Inherit, 1);
+  rr_define_method(FunctionTemplateClass, "SetClassName", Func::SetClassName, 1);
+  rr_define_method(FunctionTemplateClass, "GetFunction", Func::GetFunction, 0);
 }

data/ext/v8/v8_template.h

@@ -5,8 +5,4 @@
 
 void rr_init_template();
 
-v8::Local<v8::ObjectTemplate> Racer_Create_V8_ObjectTemplate(VALUE object);
-
-VALUE v8_ObjectTemplate_New(VALUE clazz);
-
 #endif

data/ext/v8/v8_try_catch.cpp

@@ -96,5 +96,4 @@ void rr_init_v8_try_catch() {
   rr_define_method(TryCatchClass, "StackTrace", StackTrace, 0);
   rr_define_method(TryCatchClass, "Message", _Message, 0);
   rr_define_method(TryCatchClass, "CanContinue", CanContinue, 0);
-  rb_funcall(TryCatchClass, rb_intern("private_class_method"), 1, rb_str_new2("new"));
 }

data/ext/v8/v8_value.cpp

@@ -1,6 +1,5 @@
 #include "v8_value.h"
 #include "v8_ref.h"
-#include "converters.h"
 
 using namespace v8;
 namespace {
@@ -164,5 +163,5 @@ void rr_init_value() {
 }
 
 VALUE rr_wrap_v8_value(Handle<Value>& value) {
-  return V8_Ref_Create(rr_cV8_C_Value, value);
+  return rr_v8_ref_create(rr_cV8_C_Value, value);
 }

data/lib/v8.rb

@@ -2,7 +2,7 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module V8
-  VERSION = '0.7.1'
+  VERSION = '0.7.2.pre'
   require 'v8/v8' #native glue
   require 'v8/to'
   require 'v8/context'
@@ -11,4 +11,5 @@ module V8
   require 'v8/function'
   require 'v8/tap'
   require 'v8/access'
+  require 'v8/error'
 end

data/lib/v8/access.rb

@@ -1,6 +1,95 @@
 require 'set'
 module V8
   
+  #TODO each context should get its own access rules instead of sharing them across
+  #     contetxts
+  ###### --cowboyd 07/07/2010
+  class Access
+    def self.[](cls)
+      @access ||= Access.new
+      @access[cls]
+    end
+
+    def initialize
+      @classes = {}
+    end
+
+    def [](cls)
+      @classes ||= {}
+      if ref = @classes[cls.object_id]
+        if ref.weakref_alive?
+          ref.__getobj__
+        else
+          @classes.delete(cls.object_id)
+          self[cls]
+        end
+      else
+        template(cls).tap do |t|
+          t.InstanceTemplate().SetNamedPropertyHandler(
+            NamedPropertyGetter,
+            NamedPropertySetter,
+            nil,
+            nil,
+            NamedPropertyEnumerator
+          )
+          if cls.name && cls.name =~ /(::)?(\w+?)$/
+            t.SetClassName(C::String::NewSymbol("rb::" + $2))
+          else
+            t.SetClassName("Ruby")
+          end
+          @classes[cls.object_id] = WeakRef.new(t)
+        end
+      end
+    end
+
+    def template(cls)
+      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
+    end
+
+    def self.rubyobject
+      @rubyobject ||= C::ObjectTemplate::New().tap do |t|
+        t.SetNamedPropertyHandler(
+          NamedPropertyGetter,
+          NamedPropertySetter,
+          nil,
+          nil,
+        NamedPropertyEnumerator
+        )
+      end
+    end
+  end
+
+  class Constructors < Access
+    def self.[](cls)
+      Access[cls].tap do |template|
+        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 << To.rb(arguments[i])
+            end
+            instance = V8::Function.rubycall(cls.method(:new), *rbargs)
+            wrap = C::External::New(instance)
+          end
+          arguments.This().tap do |this|
+            this.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), wrap)
+          end
+        end
+      end
+    end
+  end
+
   class NamedPropertyGetter
     def self.call(property, info)
       name = To.rb(property)
@@ -41,7 +130,7 @@ module V8
       end
     end
   end
-  
+
   class NamedPropertyEnumerator
     def self.call(info)
       obj = To.rb(info.This())

data/lib/v8/array.rb

@@ -5,7 +5,7 @@ module V8
     def each
       @context.enter do
         for i in 0..(@native.Length() - 1)
-          yield To.ruby(@native.Get(i))
+          yield To.rb(@native.Get(i))
         end
       end
     end

data/lib/v8/context.rb

@@ -4,8 +4,11 @@ module V8
   class Context    
     attr_reader :native, :scope
     def initialize(opts = {})
-      @native = C::Context::New(opts[:with])
-      @scope = V8::Object.new(@native.Global(), @native)
+      @native = opts[:with] ? C::Context::New(Access.rubyobject) : C::Context::New()
+      @native.enter do
+        @native.Global().SetHiddenValue(C::String::New("TheRubyRacer::RubyObject"), C::External::New(opts[:with])) if opts[:with]
+        @scope = To.rb(@native.Global())
+      end
       yield(self) if block_given?
     end
     
@@ -19,13 +22,13 @@ module V8
         @native.enter do
           script = C::Script::Compile(To.v8(javascript.to_s), To.v8(filename.to_s))
           if try.HasCaught()
-            err = JavascriptError.new(try)
+            err = JSError.new(try)
           else
             result = script.Run()
             if try.HasCaught()
-              err = JavascriptError.new(try)
+              err = JSError.new(try)
             else
-              value = To.ruby(result)
+              value = To.rb(result)
             end
           end
         end
@@ -60,25 +63,7 @@ module V8
       V8::Context.eval(*args)
     end
   end
-    
-  class JavascriptError < StandardError
-    attr_reader :source_name, :source_line, :line_number, :javascript_stacktrace
-    
-    def initialize(try)
-      msg = try.Message()
-      @source_name = To.ruby(msg.GetScriptResourceName())
-      @source_line = To.ruby(msg.GetSourceLine())
-      @line_number = To.ruby(msg.GetLineNumber())
-      @javascript_stacktrace = To.ruby(try.StackTrace())
-      super("#{To.ruby(msg.Get())}: #{@source_name}:#{@line_number}")
-    end
-    
-    def self.check(try)
-      raise JavascriptError.new(try) if try.HasCaught()
-    end
 
-  end
-  
   module C
     class Context
       def enter