therubyracer 0.7.5 → 0.8.0.pre

data/History.txt

@@ -1,10 +1,10 @@
 === 0.7.5 1010-08-03
-* N major enhancements
+* 4 major enhancements
   * upgrade to V8 2.3.3
   * property interceptors from ruby via [] and []=
   * indexed property access via [] and []=
   * property
-* N minor enhancements
+* 3 minor enhancements
   * several bugfixes
   * stability: eliminate many segfaults
   * don't enumerate property setters such as foo= from javascript

data/README.rdoc

@@ -38,7 +38,7 @@ Embed the V8 Javascript interpreter into Ruby.
 # embed ruby code into your scope and call it from javascript
   
   cxt["say"] = lambda {|word, times| word * times}
-  context.eval("say("Hello", 3)") #=> HelloHelloHello
+  cxt.eval("say('Hello', 3)") #=> HelloHelloHello
   
 # embed a ruby object into your scope and access its properties/methods from javascript
 

data/Rakefile

@@ -7,7 +7,7 @@ manifest.exclude "lib/v8/*.bundle", "lib/v8/*.so", "ext/**/test/*", "ext/**/test
 Gem::Specification.new do |gemspec|
   $gemspec = gemspec
   gemspec.name = gemspec.rubyforge_project = "therubyracer"
-  gemspec.version = "0.7.5"
+  gemspec.version = "0.8.0.pre"
   gemspec.summary = "Embed the V8 Javascript interpreter into Ruby"
   gemspec.description = "Call javascript code and manipulate javascript objects from ruby. Call ruby code and manipulate ruby objects from javascript."
   gemspec.email = "cowboyd@thefrontside.net"
@@ -20,6 +20,8 @@ Gem::Specification.new do |gemspec|
   gemspec.files = manifest.to_a
 end
 
+task :default => :spec
+
 desc "Build gem"
 task :gem => :gemspec do
   Gem::Builder.new($gemspec).build
@@ -32,8 +34,8 @@ task :gemspec => :clean do
   end
 end
 
+desc "remove all generated artifacts except built v8 objects"
 task :clean do
-  sh "rm -rf pkg"
   sh "rm -rf *.gem"
   sh "rm -rf ext/v8/Makefile"
   sh "rm -rf ext/v8/*.bundle ext/v8/*.so"

data/ext/v8/rr.cpp

@@ -19,6 +19,12 @@ VALUE rr_define_class(const char *name, VALUE superclass) {
   return klass;
 }
 
+VALUE rr_define_module(const char *name) {
+  VALUE V8 = rb_define_module("V8");
+  VALUE V8_C = rb_define_module_under(V8, "C");
+  return rb_define_module_under(V8_C, name);
+}
+
 VALUE rr_define_const(const char *name, VALUE value) {
   VALUE V8 = rb_define_module("V8");
   VALUE V8_C = rb_define_module_under(V8, "C");
@@ -100,7 +106,7 @@ VALUE rr_v82rb(double value) {
   return rb_float_new(value);
 }
 VALUE rr_v82rb(int64_t value) {
-  return INT2FIX(value);
+  return LONG2NUM(value);
 }
 VALUE rr_v82rb(uint32_t value) {
   return UINT2NUM(value);
@@ -112,7 +118,8 @@ VALUE rr_v82rb(int32_t value) {
 Handle<Value> rr_rb2v8(VALUE value) {
   switch (TYPE(value)) {
   case T_FIXNUM:
-    return Integer::New(FIX2INT(value));
+    // TODO: use this conversion if value will fit in 32 bits.
+    // return Integer::New(FIX2LONG(value));
   case T_FLOAT:
     return Number::New(NUM2DBL(value));    
   case T_STRING:

data/ext/v8/rr.h

@@ -8,6 +8,7 @@
 #define rr_define_singleton_method(object, name, impl, argc) rb_define_singleton_method(object, name, (VALUE(*)(...))impl, argc)
 
 VALUE rr_define_class(const char *name, VALUE superclass = rb_cObject);
+VALUE rr_define_module(const char *name);
 VALUE rr_define_const(const char *name, VALUE value);
 
 VALUE rr_v82rb(v8::Handle<v8::Value> value);

data/ext/v8/v8.cpp

@@ -12,6 +12,7 @@
 #include "v8_callbacks.h"
 #include "v8_external.h"
 #include "v8_exception.h"
+#include "v8_locker.h"
 
 #include <stdio.h>
 
@@ -35,5 +36,6 @@ extern "C" {
         rr_init_v8_callbacks();
         rr_init_v8_external();
         rr_init_v8_exception();
+        rr_init_v8_locker();
     }
 }

data/ext/v8/v8_cxt.cpp

@@ -66,6 +66,15 @@ namespace {
       return Qfalse;
     }
   }
+  VALUE GetData(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->GetData());
+  }
+  VALUE SetData(VALUE self, VALUE data) {
+    HandleScope scope;
+    unwrap(self)->SetData(rr_rb2v8(data)->ToString());
+    return Qnil;
+  }
 }
 
 void rr_init_cxt() {
@@ -77,5 +86,7 @@ void rr_init_cxt() {
   rr_define_method(ContextClass, "Enter", Enter, 0);
   rr_define_method(ContextClass, "Exit", Exit, 0);
   rr_define_method(ContextClass, "IsEntered", IsEntered, 0);
+  rr_define_method(ContextClass, "GetData", GetData, 0);
+  rr_define_method(ContextClass, "SetData", SetData, 1);
 }
 

data/ext/v8/v8_locker.cpp

@@ -0,0 +1,41 @@
+#include "rr.h"
+#include "v8_locker.h"
+
+using namespace v8;
+
+namespace {
+  VALUE Lock(VALUE self) {
+    Locker locker;
+    return rb_yield(Qnil);
+  }
+  VALUE Unlock(VALUE self) {
+    Unlocker unlocker;
+    return rb_yield(Qnil);
+  }
+  VALUE StartPreemption(VALUE self, VALUE thread_id) {
+    Locker::StartPreemption(NUM2INT(rb_to_int(thread_id)));
+    return Qnil;
+  }
+  VALUE StopPreemption(VALUE self) {
+    Locker::StopPreemption();
+    return Qnil;
+  }
+  VALUE IsLocked(VALUE self) {
+    return rr_v82rb(Locker::IsLocked());
+  }
+  VALUE IsActive(VALUE self) {
+    return rr_v82rb(Locker::IsActive());
+  }
+}
+
+void rr_init_v8_locker() {
+  VALUE V8 = rb_define_module("V8");
+  VALUE V8_C = rb_define_module_under(V8, "C");
+  VALUE LockerModule = rb_define_module_under(V8_C, "Locker");
+  rr_define_singleton_method(V8_C, "Locker", Lock, 0);
+  rr_define_singleton_method(V8_C, "Unlocker", Unlock, 0);
+  rr_define_singleton_method(LockerModule, "StartPreemption", StartPreemption, 1);
+  rr_define_singleton_method(LockerModule, "StopPreemption", StopPreemption, 0);
+  rr_define_singleton_method(LockerModule, "IsLocked", IsLocked, 0);
+  rr_define_singleton_method(LockerModule, "IsActive", IsActive, 0);
+}

data/ext/v8/v8_locker.h

@@ -0,0 +1,6 @@
+#ifndef _RUBY_V8_LOCKER
+#define _RUBY_V8_LOCKER
+
+void rr_init_v8_locker();
+
+#endif

data/ext/v8/v8_obj.cpp

@@ -64,6 +64,16 @@ namespace {
     HandleScope scope;
     return rr_v82rb(unwrap(self)->GetHiddenValue(rr_rb2v8(key)->ToString()));
   }
+  VALUE GetPrototype(VALUE self) {
+    HandleScope scope;
+    return rr_v82rb(unwrap(self)->GetPrototype());
+  }
+  VALUE SetPrototype(VALUE self, VALUE prototype) {
+    HandleScope scope;
+    Handle<Value> proto = rr_rb2v8(prototype);
+    Local<Object> me = unwrap(self);
+    return rr_v82rb(unwrap(self)->SetPrototype(rr_rb2v8(prototype)));
+  }
 }
 
 void rr_init_obj() {
@@ -74,6 +84,8 @@ void rr_init_obj() {
   rr_define_method(rr_cV8_C_Object, "GetPropertyNames", GetPropertyNames, 0);
   rr_define_method(rr_cV8_C_Object, "GetHiddenValue", GetHiddenValue, 1);
   rr_define_method(rr_cV8_C_Object, "SetHiddenValue", SetHiddenValue, 2);
+  rr_define_method(rr_cV8_C_Object, "GetPrototype", GetPrototype, 0);
+  rr_define_method(rr_cV8_C_Object, "SetPrototype", SetPrototype, 1);
 }
 
 VALUE rr_reflect_v8_object(Handle<Value> value) {

data/ext/v8/v8_script.cpp

@@ -14,12 +14,14 @@ namespace {
   }
 
   VALUE Compile(VALUE self, VALUE source, VALUE source_name) {
+    HandleScope scope;
     Local<String> src(rr_rb2v8(source)->ToString());
     Local<String> src_name(rr_rb2v8(source_name)->ToString());
     return rr_v8_ref_create(self, Script::Compile(src, src_name));
   }
 
   VALUE Run(VALUE self) {
+    HandleScope scope;
     Local<Script> script(V8_Ref_Get<Script>(self));
     Local<Value> result(script->Run());
     return result.IsEmpty() ? Qnil : rr_v82rb(result);

data/ext/v8/v8_template.cpp

@@ -38,6 +38,13 @@ namespace {
     return Qnil;
   }
 
+  Handle<Value> RubyInvocationCallback(const Arguments& args) {
+    VALUE code = (VALUE)External::Unwrap(args.Data());
+    VALUE rb_args = rr_v82rb(args);
+    VALUE result = rb_funcall(code, rb_intern("call"), 1, rb_args);
+    return rr_rb2v8(result);
+  }
+
   namespace Obj {
 
     /**
@@ -238,17 +245,19 @@ namespace {
       );
       return Qnil;
     }
+    VALUE SetCallAsFunctionHandler(VALUE self) {
+      HandleScope scope;
+      VALUE code = rb_block_proc();
+      if (NIL_P(code)) {
+        return Qnil;
+      }
+      obj(self)->SetCallAsFunctionHandler(RubyInvocationCallback, rr_v8_external_create(code));
+      return Qnil;
+    }
   }
 
   namespace Func {
 
-    Handle<Value> RubyInvocationCallback(const Arguments& args) {
-      VALUE code = (VALUE)External::Unwrap(args.Data());
-      VALUE rb_args = rr_v82rb(args);
-      VALUE result = rb_funcall(code, rb_intern("call"), 1, rb_args);
-      return rr_rb2v8(result);
-    }
-
     VALUE New(VALUE function_template) {
       HandleScope handles;
       VALUE code = rb_block_proc();
@@ -307,6 +316,7 @@ void rr_init_template() {
   rr_define_method(ObjectTemplateClass, "NewInstance", Obj::NewInstance, 0);
   rr_define_method(ObjectTemplateClass, "SetNamedPropertyHandler", Obj::SetNamedPropertyHandler, 5);
   rr_define_method(ObjectTemplateClass, "SetIndexedPropertyHandler", Obj::SetIndexedPropertyHandler, 5);
+  rr_define_method(ObjectTemplateClass, "SetCallAsFunctionHandler", Obj::SetCallAsFunctionHandler, 0);
 
   FunctionTemplateClass = rr_define_class("FunctionTemplate", Template);
   rr_define_singleton_method(FunctionTemplateClass, "New", Func::New, 0);

data/lib/v8.rb

@@ -2,9 +2,10 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 module V8
-  VERSION = '0.7.5'
+  VERSION = '0.8.0.pre'
   require 'v8/v8' #native glue
-  require 'v8/to'
+  require 'v8/portal'
+  require 'v8/portal/functions'
   require 'v8/context'
   require 'v8/object'
   require 'v8/array'

data/lib/v8/access.rb

@@ -1,202 +1,87 @@
 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
+    def get(obj, name, &dontintercept)
+      methods = accessible_methods(obj)
+      if methods.include?(name)
+        method = obj.method(name)
+        method.arity == 0 ? method.call : method.unbind
+      elsif obj.respond_to?(:[])
+        obj.send(:[], name, &dontintercept)
       else
-        template(cls).tap do |t|
-          Access.setuptemplate(t.InstanceTemplate())
-          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
+        yield
       end
     end
 
-    def self.rubyobject
-      @rubyobject ||= C::ObjectTemplate::New().tap do |t|
-        setuptemplate(t)
+    def iget(obj, index, &dontintercept)
+      if obj.respond_to?(:[])
+        obj.send(:[], index, &dontintercept)
+      else
+        yield
       end
     end
 
-    def self.setuptemplate(t)
-      t.SetNamedPropertyHandler(
-        NamedPropertyGetter,
-        NamedPropertySetter,
-        nil,
-        nil,
-        NamedPropertyEnumerator
-      )
-      t.SetIndexedPropertyHandler(
-        IndexedPropertyGetter,
-        IndexedPropertySetter,
-        nil,
-        nil,
-        IndexedPropertyEnumerator
-      )
-    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.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
+    def set(obj, name, value, &dontintercept)
+      setter = name + "="
+      methods = accessible_methods(obj, true)
+      if methods.include?(setter)
+        obj.send(setter, value)
+      elsif obj.respond_to?(:[]=)
+        obj.send(:[]=, name, value, &dontintercept)
+      else
+        yield
       end
     end
-  end
 
-  module AccessibleMethods
-    def accessible_methods(obj)
-      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! {|m| m == "[]" || m == "[]="}
+    def iset(obj, index, value, &dontintercept)
+      if obj.respond_to?(:[]=)
+        obj.send(:[]=, index, value, &dontintercept)
+      else
+        yield
       end
     end
-  end
 
-  class NamedPropertyGetter
-    extend AccessibleMethods
-    def self.call(property, info)
-      name = To.rb(property)
-      obj = To.rb(info.This())
-      methods = accessible_methods(obj)
-      if methods.include?(name)
-        method = obj.method(name)
-        if method.arity == 0
-          Function.rubycall(method)
-        else
-          To.v8(method)
+    def query(obj, name, attributes)
+      if obj.respond_to?(name)
+        attributes.dont_delete
+        unless obj.respond_to?(name + "=")
+          attributes.read_only
         end
-      elsif obj.respond_to?(:[])
-        Function.rubysend(obj, :[], name)
       else
-        C::Empty
+        yield
       end
     end
-  end
 
-  class NamedPropertySetter
-    extend AccessibleMethods
-    def self.call(property, value, info)
-      obj = To.rb(info.This())
-      name = To.rb(property)
-      setter = name + "="
-      methods = accessible_methods(obj)
-      if methods.include?(setter)
-        Function.rubysend(obj, setter, To.rb(value))
-        value
-      elsif obj.respond_to?(:[]=)
-        Function.rubysend(obj, :[]=, name, To.rb(value))
-        value
+    def iquery(obj, index, attributes)
+      if obj.respond_to?(:[])
+        attributes.dont_delete
+        unless obj.respond_to?(:[]=)
+          attributes.read_only
+        end
       else
-        C::Empty
+        yield
       end
     end
-  end
 
-  class NamedPropertyEnumerator
-    extend AccessibleMethods
-    def self.call(info)
-      obj = To.rb(info.This())
-      methods = accessible_methods(obj).reject! {|m| m.to_s =~ /=$/}
-      names = V8::C::Array::New(methods.length)
-      methods.each_with_index do |name, i|
-        names.Set(i, C::String::New(name))
-      end
-      return names
+    def names(obj)
+      accessible_methods(obj)
     end
-  end
 
-  class IndexedPropertyGetter
-    def self.call(index, info)
-      obj = To.rb(info.This())
-      if obj.respond_to?(:[])
-        Function.rubysend(obj, :[], index)
-      else
-        C::Empty
-      end
+    def indices(obj)
+      obj.respond_to?(:length) ? (0..obj.length).to_a : yield
     end
-  end
 
-  class IndexedPropertySetter
-    def self.call(index, value, info)
-      obj = To.rb(info.This())
-      if obj.respond_to?(:[]=)
-        Function.rubysend(obj, :[]=, index, To.rb(value))
-        value
-      else
-        C::Empty
-      end
-    end
-  end
+    private
 
-  class IndexedPropertyEnumerator
-    def self.call(info)
-      obj = To.rb(info.This())
-      if obj.respond_to?(:length)
-        C::Array::New(obj.length).tap do |indices|
-          for index in 0..obj.length - 1
-            rputs "index: #{index}"
-            indices.Set(index,index)
-          end
+    def accessible_methods(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
-      else
-        C::Array::New()
+        methods.reject! {|m| m == "[]" || m == "[]=" || m =~ /=$/} unless special_methods
       end
     end
   end
-end
+end