therubyracer 0.7.4 → 0.7.5

data/ext/v8/upstream/{2.1.10 → 2.3.3}/tools/visual_studio/v8_base.vcproj

@@ -144,6 +144,30 @@
 					/>
 				</FileConfiguration>
 			</File>
+    		<File
+				RelativePath="..\..\src\dtoa.cc"
+				>
+			</File>
+    		<File
+				RelativePath="..\..\src\dtoa.h"
+				>
+			</File>
+    		<File
+				RelativePath="..\..\src\fast-dtoa.cc"
+				>
+			</File>
+    		<File
+				RelativePath="..\..\src\fast-dtoa.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\fixed-dtoa.cc"
+				>
+			</File>
+    		<File
+				RelativePath="..\..\src\fixed-dtoa.h"
+				>
+			</File>
 		</Filter>
 		<Filter
 			Name="src"
@@ -204,6 +228,10 @@
 				RelativePath="..\..\src\assembler.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\ast-inl.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\ast.cc"
 				>
@@ -612,6 +640,10 @@
 				RelativePath="..\..\src\jump-target-heavy-inl.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\jump-target-heavy.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\jump-target.cc"
 				>
@@ -952,6 +984,14 @@
 				RelativePath="..\..\src\type-info.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\unbound-queue-inl.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\unbound-queue.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\unicode-inl.h"
 				>

data/ext/v8/upstream/{2.1.10 → 2.3.3}/tools/visual_studio/v8_base_arm.vcproj

@@ -204,6 +204,10 @@
 				RelativePath="..\..\src\assembler.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\ast-inl.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\ast.cc"
 				>
@@ -596,6 +600,10 @@
 				RelativePath="..\..\src\jump-target-light-inl.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\jump-target-light.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\jump-target.cc"
 				>
@@ -944,6 +952,14 @@
 				RelativePath="..\..\src\type-info.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\unbound-queue-inl.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\unbound-queue.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\unicode-inl.h"
 				>
@@ -1012,6 +1028,10 @@
 				RelativePath="..\..\src\virtual-frame.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\arm\virtual-frame-arm-inl.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\arm\virtual-frame-arm.h"
 				>

data/ext/v8/upstream/{2.1.10 → 2.3.3}/tools/visual_studio/v8_base_x64.vcproj

@@ -204,6 +204,10 @@
 				RelativePath="..\..\src\assembler.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\ast-inl.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\ast.cc"
 				>
@@ -589,6 +593,10 @@
 				RelativePath="..\..\src\jump-target-heavy-inl.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\jump-target-heavy.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\jump-target.cc"
 				>
@@ -929,6 +937,14 @@
 				RelativePath="..\..\src\type-info.h"
 				>
 			</File>
+			<File
+				RelativePath="..\..\src\unbound-queue-inl.h"
+				>
+			</File>
+			<File
+				RelativePath="..\..\src\unbound-queue.h"
+				>
+			</File>
 			<File
 				RelativePath="..\..\src\unicode-inl.h"
 				>

data/ext/v8/upstream/{2.1.10 → 2.3.3}/tools/visual_studio/v8_cctest.vcproj

@@ -247,6 +247,10 @@
 			RelativePath="..\..\test\cctest\test-strings.cc"
 			>
 		</File>
+		<File
+			RelativePath="..\..\test\cctest\test-unbound-queue.cc"
+			>
+		</File>
 		<File
 			RelativePath="..\..\test\cctest\test-utils.cc"
 			>

data/ext/v8/upstream/Makefile

@@ -23,7 +23,7 @@ $(SCONS): $(SCONSSRC)
 	python build/scons/setup.py install --prefix=install
 
 $(V8SRC): build
-	cp -r 2.1.10 build/v8
+	cp -r 2.3.3 build/v8
 	patch -td build/v8 -i ../../fpic-on-linux-amd64.patch
 
 $(SCONSSRC): build

data/ext/v8/v8_template.cpp

@@ -66,12 +66,12 @@ namespace {
      * Returns a non-empty handle if the interceptor intercepts the request.
      * The result is true if the property exists and false otherwise.
      */
-    Handle<Boolean> RubyNamedPropertyQuery(Local<String> property, const AccessorInfo& info) {
+    Handle<Integer> RubyNamedPropertyQuery(Local<String> property, const AccessorInfo& info) {
       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));
       Handle<Value> intercepts = rr_rb2v8(result);
-      return intercepts.IsEmpty() ? Handle<Boolean>() : intercepts->ToBoolean();
+      return intercepts.IsEmpty() ? Handle<Integer>() : Integer::New(None);
     }
 
     /**
@@ -107,6 +107,73 @@ namespace {
       }
     }
 
+    /**
+     * Returns the value of the property if the getter intercepts the
+     * request.  Otherwise, returns an empty handle.
+     */
+    Handle<Value> RubyIndexedPropertyGetter(uint32_t index, const AccessorInfo& info) {
+      VALUE code = (VALUE)External::Unwrap(info.Data());
+      VALUE getter = rb_hash_lookup(code, "getter");
+      VALUE result = rb_funcall(getter, rb_intern("call"), 2, UINT2NUM(index), rr_v82rb(info));
+      return rr_rb2v8(result);
+    }
+
+    /**
+     * Returns the value if the setter intercepts the request.
+     * Otherwise, returns an empty handle.
+     */
+    Handle<Value> RubyIndexedPropertySetter(uint32_t index, Local<Value> value, const AccessorInfo& info) {
+      VALUE code = (VALUE)External::Unwrap(info.Data());
+      VALUE setter = rb_hash_lookup(code, "setter");
+      VALUE result = rb_funcall(setter, rb_intern("call"), 3, UINT2NUM(index), rr_v82rb(value), rr_v82rb(info));
+      return rr_rb2v8(result);
+    }
+
+    /**
+     * Returns a non-empty handle if the interceptor intercepts the request.
+     * The result is true if the property exists and false otherwise.
+     */
+     Handle<Boolean> RubyIndexedPropertyQuery(uint32_t index, const AccessorInfo& info) {
+       VALUE code = (VALUE)External::Unwrap(info.Data());
+       VALUE query = rb_hash_lookup(code, "query");
+       VALUE result = rb_funcall(query, rb_intern("call"), 2, UINT2NUM(index), rr_v82rb(info));
+       Handle<Value> intercepts = rr_rb2v8(result);
+       return intercepts.IsEmpty() ? Handle<Boolean>() : intercepts->ToBoolean();
+     }
+
+    /**
+     * Returns a non-empty handle if the deleter intercepts the request.
+     * The return value is true if the property could be deleted and false
+     * otherwise.
+     */
+     Handle<Boolean> RubyIndexedPropertyDeleter(uint32_t index, const AccessorInfo& info) {
+       VALUE code = (VALUE)External::Unwrap(info.Data());
+       VALUE deleter = rb_hash_lookup(code, "deleter");
+       VALUE result = rb_funcall(deleter, rb_intern("call"), 2, UINT2NUM(index), rr_v82rb(info));
+       Handle<Value> intercepts = rr_rb2v8(result);
+       return intercepts.IsEmpty() ? Handle<Boolean>() : intercepts->ToBoolean();
+     }
+
+    /**
+     * Returns an array containing the indices of the properties the
+     * indexed property getter intercepts.
+     */
+     Handle<Array> RubyIndexedPropertyEnumerator(const AccessorInfo& info) {
+       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));
+       Handle<Value> v(rr_rb2v8(result));
+       if (v.IsEmpty()) {
+         return Array::New();
+       } else if (!v->IsArray()) {
+         Local<Array> a = Array::New();
+         a->Set(Integer::New(0), v->ToString());
+         return a;
+       } else {
+         return (Handle<Array>)Array::Cast(*v);
+       }
+     }
+
     VALUE New(VALUE rbclass) {
       HandleScope handles;
       return rr_v8_ref_create(rbclass, ObjectTemplate::New());
@@ -147,6 +214,30 @@ namespace {
       );
       return Qnil;
     }
+    VALUE SetIndexedPropertyHandler(VALUE self, VALUE getter, VALUE setter, VALUE query, VALUE deleter, VALUE enumerator) {
+      HandleScope scope;
+      if (!RTEST(getter)) {
+        rb_raise(rb_eArgError, "you must supply at least a getter to V8::C::ObjectTemplate#SetNamedPropertyHandler()");
+        return Qnil;
+      }
+      VALUE data = rb_hash_new();
+      rb_hash_aset(data, "getter", getter);
+      rb_hash_aset(data, "setter", setter);
+      rb_hash_aset(data, "query", query);
+      rb_hash_aset(data, "deleter", deleter);
+      rb_hash_aset(data, "enumerator", enumerator);
+      //TODO: is this really necessary?
+      rr_v8_ref_setref(self, "data", data);
+      obj(self)->SetIndexedPropertyHandler(
+        RubyIndexedPropertyGetter,
+        RTEST(setter) ? RubyIndexedPropertySetter : 0,
+        RTEST(query) ? RubyIndexedPropertyQuery : 0,
+        RTEST(deleter) ? RubyIndexedPropertyDeleter : 0,
+        RTEST(enumerator) ? RubyIndexedPropertyEnumerator : 0,
+        rr_v8_external_create(data)
+      );
+      return Qnil;
+    }
   }
 
   namespace Func {
@@ -215,6 +306,7 @@ void rr_init_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);
+  rr_define_method(ObjectTemplateClass, "SetIndexedPropertyHandler", Obj::SetIndexedPropertyHandler, 5);
 
   FunctionTemplateClass = rr_define_class("FunctionTemplate", Template);
   rr_define_singleton_method(FunctionTemplateClass, "New", Func::New, 0);

data/ext/v8/v8_try_catch.cpp

@@ -72,7 +72,7 @@ namespace {
     return tc ? rr_v82rb(tc->Exception()) : Qnil;
   }
   
-  VALUE StackTrace(VALUE self) {
+  VALUE _StackTrace(VALUE self) {
     TryCatch *tc = unwrap(self);
     return tc ? rr_v82rb(tc->StackTrace()) : Qnil;
   }    
@@ -93,7 +93,7 @@ void rr_init_v8_try_catch() {
   rr_define_singleton_method(TryCatchClass, "try", Try, -1);
   rr_define_method(TryCatchClass, "HasCaught", HasCaught, 0);
   rr_define_method(TryCatchClass, "Exception", _Exception, 0);
-  rr_define_method(TryCatchClass, "StackTrace", StackTrace, 0);
+  rr_define_method(TryCatchClass, "StackTrace", _StackTrace, 0);
   rr_define_method(TryCatchClass, "Message", _Message, 0);
   rr_define_method(TryCatchClass, "CanContinue", CanContinue, 0);
 }

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.4'
+  VERSION = '0.7.5'
   require 'v8/v8' #native glue
   require 'v8/to'
   require 'v8/context'

data/lib/v8/access.rb

@@ -25,13 +25,7 @@ module V8
         end
       else
         template(cls).tap do |t|
-          t.InstanceTemplate().SetNamedPropertyHandler(
-            NamedPropertyGetter,
-            NamedPropertySetter,
-            nil,
-            nil,
-            NamedPropertyEnumerator
-          )
+          Access.setuptemplate(t.InstanceTemplate())
           if cls.name && cls.name =~ /(::)?(\w+?)$/
             t.SetClassName(C::String::NewSymbol("rb::" + $2))
           else
@@ -56,15 +50,26 @@ module V8
 
     def self.rubyobject
       @rubyobject ||= C::ObjectTemplate::New().tap do |t|
-        t.SetNamedPropertyHandler(
-          NamedPropertyGetter,
-          NamedPropertySetter,
-          nil,
-          nil,
-        NamedPropertyEnumerator
-        )
+        setuptemplate(t)
       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
@@ -79,7 +84,7 @@ module V8
             for i in 0..arguments.Length() - 1
               rbargs << To.rb(arguments[i])
             end
-            instance = V8::Function.rubycall(cls.method(:new), *rbargs)
+            instance = V8::Function.rubysend(cls, :new, *rbargs)
             wrap = C::External::New(instance)
           end
           arguments.This().tap do |this|
@@ -90,24 +95,34 @@ module V8
     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 == "[]="}
+      end
+    end
+  end
+
   class NamedPropertyGetter
+    extend AccessibleMethods
     def self.call(property, info)
       name = To.rb(property)
       obj = To.rb(info.This())
-      perl_name = To.perl_case(name)
-      methods = obj.public_methods(false).map {|m| m.to_s}
-      method_name = if methods.include?(name)
-        name
-      elsif methods.include?(perl_name)
-        perl_name
-      end
-      if method_name
-        method = obj.method(method_name)
+      methods = accessible_methods(obj)
+      if methods.include?(name)
+        method = obj.method(name)
         if method.arity == 0
           Function.rubycall(method)
         else
           To.v8(method)
         end
+      elsif obj.respond_to?(:[])
+        Function.rubysend(obj, :[], name)
       else
         C::Empty
       end
@@ -115,35 +130,73 @@ module V8
   end
 
   class NamedPropertySetter
+    extend AccessibleMethods
     def self.call(property, value, info)
       obj = To.rb(info.This())
-      setter = To.rb(property) + "="
-      camel_name = To.camel_case(setter)
-      perl_name = To.perl_case(setter)
-      methods = obj.public_methods(false).map {|m| m.to_s}
-      if methods.include?(perl_name)
-        obj.send(perl_name, To.rb(value))
-      elsif methods.include?(camel_name)
-        obj.send(camel_name, To.rb(value))
+      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
       else
-         C::Empty
+        C::Empty
       end
     end
   end
 
   class NamedPropertyEnumerator
+    extend AccessibleMethods
     def self.call(info)
       obj = To.rb(info.This())
-      camel_methods = obj.public_methods(false).inject(Set.new) do |set, name|
-        set.tap do
-          set << To.camel_case(name)
-        end
-      end
-      names = V8::C::Array::New(camel_methods.length)
-      camel_methods.each_with_index do |name, i|
+      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
     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
+    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
+
+  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
+        end
+      else
+        C::Array::New()
+      end
+    end
+  end
 end