therubyracer 0.4.4 → 0.4.5

data/History.txt

@@ -1,4 +1,12 @@
-=== 0.X.X 2010-01-14
+=== 0.4.5 2010-01-18
+* 3 major enhancements
+  * case munging so that ruby methods(perl_case) are accessed through javascript in camelCase.
+  * access 0-arity ruby methods as javascript properties
+  * invoke ruby setters from javascript as properties
+* 1 minor enhancements
+  * contexts detect whether they are open or not and open when needed
+
+=== 0.4.4 2010-01-14
 * 2 major enhancements:
   * Ruby objects embedded into javascript are passed back to ruby as themselves and not a wrapped V8 object wrapping a ruby object.
   * Use any ruby object as the scope of eval().

data/Manifest.txt

@@ -48,5 +48,6 @@ spec/redjs/jsapi_spec.rb
 spec/redjs_helper.rb
 spec/spec.opts
 spec/spec_helper.rb
+spec/v8/to_spec.rb
 tasks/rspec.rake
 therubyracer.gemspec

data/ext/v8/callbacks.cpp

@@ -5,6 +5,39 @@
 
 using namespace v8;
 
+namespace {
+  VALUE unwrap(const AccessorInfo& info) {
+    return (VALUE)External::Unwrap(info.Data());
+  }
+  
+  Local<Array> TO_ARRAY(Arguments& args) {
+    Local<Array> array = Array::New(args.Length());
+    for (int i = 0; i < args.Length(); i++) {
+      array->Set(Integer::New(i), args[i]);
+    }
+  }
+  
+  Local<Value> Racer_Call_Ruby_Method(VALUE object, VALUE method, Local<Array> args) {
+    VALUE * arguments = new VALUE[args->Length()];
+    for (unsigned int i = 0; i < args->Length(); i++) {
+      Handle<Value> val = args->Get(Integer::New(i));
+      arguments[i] = V82RB(val);
+    }
+    VALUE result = rb_funcall2(object, rb_to_id(method), args->Length(), arguments);
+    Local<Value> converted = RB2V8(result);
+    return converted;
+  }
+  
+  Local<Value> Racer_Access_Ruby_Property(VALUE object, VALUE name) {
+    VALUE method = rb_obj_method(object, name);
+    if (FIX2INT(rb_funcall(method, rb_intern("arity"), 0)) == 0) {
+      return Racer_Call_Ruby_Method(object, name, Array::New(0));      
+    } else {
+      return RB2V8(method);
+    }        
+  }
+}
+
 Handle<Value> RacerRubyInvocationCallback(const Arguments& args) {
   VALUE code = (VALUE)External::Unwrap(args.Data());
   if (NIL_P(code)) {
@@ -22,4 +55,106 @@ Handle<Value> RacerRubyInvocationCallback(const Arguments& args) {
     Handle<Value> convertedResult = RB2V8(result);
     return convertedResult  ;
   }
-}
+}
+
+
+
+
+/**
+ * NamedProperty[Getter|Setter] are used as interceptors on object.
+ * See ObjectTemplate::SetNamedPropertyHandler.
+ */
+
+Handle<Value> RacerRubyNamedPropertyGetter(Local<String> property, const AccessorInfo& info) {
+  // printf("Getter '%s'<br/>", *String::AsciiValue(property));
+  if (property->Length() == 0) {
+    return Handle<Value>();
+  }
+  VALUE object = unwrap(info);
+  VALUE camel_name = V82RB((Local<Value>&)property);
+  VALUE perl_name = rb_funcall(V8_To, rb_intern("perl_case"), 1, camel_name);
+  VALUE methods = rb_funcall(object, rb_intern("public_methods"), 1, Qfalse);
+  
+  if (RTEST(rb_ary_includes(methods, perl_name))) {
+    return Racer_Access_Ruby_Property(object, perl_name);
+  }
+  if (RTEST(rb_ary_includes(methods, camel_name))) {
+    return Racer_Access_Ruby_Property(object, camel_name);
+  }
+  return Handle<Value>();
+}
+
+/**
+ * Returns the value if the setter intercepts the request.
+ * Otherwise, returns an empty handle.
+ */
+Handle<Value> RacerRubyNamedPropertySetter(Local<String> property, Local<Value> value, const AccessorInfo& info) {
+  if (property->Length() == 0) {
+    return Handle<Value>();
+  }
+  // printf("Setter: '%s'<br/>", *String::AsciiValue(property));
+  std::string setter = V82String((Handle<Value>&)property);
+  setter += "=";
+  Local<String> setter_name = String::New(setter.c_str());
+  VALUE object = unwrap(info);
+  VALUE camel_name = V82RB((Local<Value>&)setter_name);
+  VALUE perl_name = rb_funcall(V8_To, rb_intern("perl_case"), 1, camel_name);
+  VALUE methods = rb_funcall(object, rb_intern("public_methods"), 1, Qfalse);
+  Local<Array> args = Array::New(1);
+  args->Set(Integer::New(0), value);
+  if (RTEST(rb_ary_includes(methods, perl_name))) {    
+    Racer_Call_Ruby_Method(object, perl_name, args);
+    return value;
+  }
+  if (RTEST(rb_ary_includes(methods, camel_name))) {
+    Racer_Call_Ruby_Method(object, camel_name, args);
+    return value;
+  }    
+  return Handle<Value>();
+}
+
+/**
+ * Returns a non-empty handle if the interceptor intercepts the request.
+ * The result is true if the property exists and false otherwise.
+ */
+Handle<Boolean> RacerRubyNamedPropertyQuery(Local<String> property, const AccessorInfo& info) {
+  printf("Query: '%s'<br/>", *String::AsciiValue(property));
+  if (property->Length() == 0) {
+    return False();
+  }
+  VALUE object = unwrap(info);
+  VALUE methods = rb_funcall(object, rb_intern("public_methods"), 1, Qfalse);
+  VALUE attr_name = V82RB((Local<Value>&)property);
+  VALUE perl_name = rb_funcall(V8_To, rb_intern("perl_case"), 1, attr_name);
+  
+  if (RTEST(rb_ary_includes(methods, attr_name)) || RTEST(rb_ary_includes(methods, perl_name))) {
+    return True();
+  } else {
+    return Handle<Boolean>();
+  }
+}
+
+/**
+ * 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> RacerRubyNamedPropertyDeleter(Local<String> property, const AccessorInfo& info) {
+  return False();
+}
+
+/**
+ * Returns an array containing the names of the properties the named
+ * property getter intercepts.
+ */
+Handle<Array> RacerRubyNamedPropertyEnumerator(const AccessorInfo& info) {
+  VALUE object = unwrap(info);
+  VALUE methods = rb_funcall(object, rb_intern("public_methods"), 1, Qfalse);
+  int length = RARRAY_LEN(methods);
+  Local<Array> properties = Array::New(length);
+  for (int i = 0; i < length; i++) {
+    VALUE camel_name = rb_funcall(V8_To, rb_intern("camel_case"), 1, rb_ary_entry(methods, i));
+    properties->Set(Integer::New(i), RB2V8(camel_name));
+  }
+  return properties;
+}

data/ext/v8/callbacks.h

@@ -5,4 +5,10 @@
 
 v8::Handle<v8::Value> RacerRubyInvocationCallback(const v8::Arguments& args); 
 
+v8::Handle<v8::Value> RacerRubyNamedPropertyGetter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+v8::Handle<v8::Value> RacerRubyNamedPropertySetter(v8::Local<v8::String> property, v8::Local<v8::Value> value, const v8::AccessorInfo& info);
+v8::Handle<v8::Boolean> RacerRubyNamedPropertyQuery(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+v8::Handle<v8::Boolean> RacerRubyNamedPropertyDeleter(v8::Local<v8::String> property, const v8::AccessorInfo& info);
+v8::Handle<v8::Array> RacerRubyNamedPropertyEnumerator(const v8::AccessorInfo& info);
+
 #endif /* end of include guard: CALLBACKS_H_8VK3LWBG */

data/ext/v8/converters.cpp

@@ -3,6 +3,7 @@
 #include "v8_ref.h"
 #include "v8_obj.h"
 #include "v8_cxt.h"
+#include "v8_template.h"
 
 using namespace v8;
 
@@ -32,8 +33,10 @@ VALUE V82RB(Handle<Value>& value) {
   if (value->IsObject()) {
     Local<Object> object(Object::Cast(*value));
     Local<Value> peer = object->GetHiddenValue(String::New("TheRubyRacer::RubyObject"));
+    // Local<Value> peer = object->GetInternalField(0);
     if (peer.IsEmpty()) {
       VALUE context_ref = V8_Ref_Create(V8_C_Context, Context::GetCurrent());
+      // object->SetPointerInInternalField(1, (void *)context_ref);
       object->SetHiddenValue(String::New("TheRubyRacer::Context"), External::Wrap((void *)context_ref));
       return V8_Ref_Create(V8_C_Object, value, context_ref);
     } else {      
@@ -55,10 +58,10 @@ Local<Value> RB2V8(VALUE value) {
   if (convert(value, result)) {
     return result;
   }
-  Local<ObjectTemplate> tmpl = RB_VALUE_2_V8_ObjectTemplate(value);
-  Local<Object> object = tmpl->NewInstance();
-  object->SetHiddenValue(String::New("TheRubyRacer::RubyObject"), External::Wrap((void *)value));
-  return object;
+  Local<Object> o = Racer_Create_V8_ObjectTemplate(value)->NewInstance();
+  o->SetHiddenValue(String::New("TheRubyRacer::RubyObject"), External::Wrap((void *) value));
+  // o->SetPointerInInternalField(0, (void*)value);
+  return o;
 }
 
 std::string V82String(Handle<Value>& value) {
@@ -77,21 +80,4 @@ std::string V82String(Handle<Value>& value) {
   }  
   
   return UNDEFINED_STR;
-}
-
-Local<ObjectTemplate> RB_VALUE_2_V8_ObjectTemplate(VALUE value) {
-  Local<ObjectTemplate> tmpl = ObjectTemplate::New();
-  VALUE methods = rb_funcall(value, rb_intern("public_methods"), 1, Qfalse);
-  int len = RARRAY_LEN(methods);
-  for (int i = 0; i < len; i++) {
-    VALUE method_name = RARRAY_PTR(methods)[i];
-    VALUE camel_method_name = rb_funcall(V8_To, rb_intern("camelcase"), 1, method_name);
-    VALUE method = rb_funcall(value, rb_intern("method"), 1, method_name);
-    Local<String> keystr = (String *)*RB2V8(method_name);
-    Local<String> camelstr = (String *)*RB2V8(camel_method_name);
-    Local<FunctionTemplate> fun = FunctionTemplate::New(RacerRubyInvocationCallback, External::Wrap((void *)method));
-    tmpl->Set(keystr, fun);
-    tmpl->Set(camelstr, fun);
-  }
-  return tmpl;
-}
+}

data/ext/v8/converters.h

@@ -20,6 +20,4 @@ v8::Local<v8::Value> RB2V8(VALUE value);
 std::string RB2String(VALUE value);
 std::string V82String(v8::Handle<v8::Value>& value);
 
-v8::Local<v8::ObjectTemplate> RB_VALUE_2_V8_ObjectTemplate(VALUE value);
-
 #endif

data/ext/v8/v8_cxt.cpp

@@ -1,5 +1,6 @@
 #include "v8_cxt.h"
 #include "v8_msg.h"
+#include "v8_template.h"
 #include "converters.h"
 
 using namespace v8;
@@ -16,9 +17,10 @@ VALUE v8_Context_New(int argc, VALUE *argv, VALUE self) {
   if (NIL_P(scope)) {
     return V8_Ref_Create(self, Context::New());
   } else {
-    Persistent<Context> context = Context::New(0, RB_VALUE_2_V8_ObjectTemplate(scope));
+    Persistent<Context> context = Context::New(0, Racer_Create_V8_ObjectTemplate(scope));
     Context::Scope enter(context);
     context->Global()->SetHiddenValue(String::New("TheRubyRacer::RubyObject"), External::Wrap((void *)scope));
+    // context->Global()->SetPointerInInternalField(0, (void*)scope);
     VALUE ref = V8_Ref_Create(self, context, scope);
     context.Dispose();
     return ref;

data/ext/v8/v8_obj.cpp

@@ -47,5 +47,6 @@ VALUE v8_Object_context(VALUE self) {
   HandleScope handles;
   Local<Object> object = unwrap(self);
   Local<Value> cxt = object->GetHiddenValue(String::New("TheRubyRacer::Context"));
+  // Local<Value> cxt = object->GetInternalField(1);
   return cxt.IsEmpty() ? Qnil : (VALUE)External::Unwrap(cxt);
 }

data/ext/v8/v8_template.cpp

@@ -7,6 +7,22 @@
 #include "callbacks.h"
 
 using namespace v8;
+
+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,
+    External::Wrap((void *)value)
+  );
+  return tmpl;
+}
+
+
  
 VALUE v8_Template_Set(VALUE self, VALUE name, VALUE value) {
   HandleScope handles;

data/ext/v8/v8_template.h

@@ -1,6 +1,8 @@
 #ifndef _RUBY_V8_TEMPLATE_
 #define _RUBY_V8_TEMPLATE_ 
 
+v8::Local<v8::ObjectTemplate> Racer_Create_V8_ObjectTemplate(VALUE object);
+
 VALUE v8_Template_Set(VALUE self, VALUE name, VALUE value);
 
 VALUE v8_ObjectTemplate_New(VALUE clazz);

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

data/lib/v8/context.rb

@@ -22,9 +22,11 @@ module V8
       if IO === javascript || StringIO === javascript
         javascript = javascript.read()
       end
-      @native.eval(javascript).tap do |result|
-        raise JavascriptError.new(result) if result.kind_of?(C::Message)
-        return To.ruby(result)
+      @native.open do        
+        @native.eval(javascript).tap do |result|
+          raise JavascriptError.new(result) if result.kind_of?(C::Message)
+          return To.ruby(result)
+        end
       end
     end
         

data/lib/v8/to.rb

@@ -21,9 +21,13 @@ module V8
         end
       end
       
-      def camelcase(str)
+      def camel_case(str)
         str.to_s.gsub(/_(\w)/) {$1.upcase}
-      end      
+      end
+      
+      def perl_case(str)
+        str.gsub(/([A-Z])([a-z])/) {"_#{$1.downcase}#{$2}"}.downcase
+      end
     end
   end
 end

data/spec/redjs/jsapi_spec.rb

@@ -113,27 +113,30 @@ describe "Ruby Javascript API" do
         cxt.eval('timesfive(3)').should == 15
       end          
     end
+    
+    it "reports ruby methods that do not exist as undefined" do
+      Context.open(:with => Object.new) do |cxt|
+        cxt.eval('this.foobar').should be_nil 
+      end
+    end
   
     it "can call public locally defined ruby methods" do
       class_eval do
-        def voo
-          "doo"
+        def voo(str)
+          "voo#{str}"
         end
       end
-      evaljs("o.voo").should_not be_nil
-      evaljs("o.voo()").should == "doo"
+      evaljs("o.voo('doo')").should == "voodoo"
     end
   
     it "translates ruby naming conventions into javascript naming conventions, but you can still access them by their original names" do
       class_eval do
-        def my_special_method
-          "hello"
+        def my_special_method(to)
+          "hello #{to}"
         end
       end
-      evaljs("o.mySpecialMethod").should_not be_nil
-      evaljs("o.mySpecialMethod()").should == "hello"
-      evaljs("o.my_special_method").should_not be_nil
-      evaljs("o.my_special_method()").should == "hello"
+      evaljs("o.mySpecialMethod('Frank')").should == "hello Frank"
+      evaljs("o.my_special_method('Jack')").should == "hello Jack"
     end
   
     it "hides methods not defined directly on this instance's class" do
@@ -152,8 +155,8 @@ describe "Ruby Javascript API" do
         def baz_bang        
         end      
       end
-      pending "why the hell isn't the return value of getIds() being respected?!?"
-      evaljs(<<-EOJS).should == ["fooBar,bazBang"]
+      require 'set'
+      evaljs(<<-EOJS).to_set.should == Set.new(["fooBar","bazBang"])
       var names = [];
       for (var p in o) {
         names.push(p);
@@ -166,18 +169,49 @@ describe "Ruby Javascript API" do
       Context.open do |cxt|
         cxt['o'] = @instance
         class_eval do
-          def bar
-            "baz!"
+          def whiz(str)
+            "whiz#{str}!"
           end
         end
-        cxt.eval("o.bar").should_not be_nil
-        cxt.eval("o.bar()").should == "baz!"
+        cxt.eval("o.whiz('bang')").should == "whizbang!"
       end
     end 
   
-    it "treats ruby methods that have an arity of 0 as javascript properties by default"
+    it "treats ruby methods that have an arity of 0 as javascript properties by default" do
+      class_eval do
+        def property
+          "flan!"
+        end
+      end
+      evaljs('o.property').should == 'flan!'
+    end
   
-    it "will call ruby accesssor function when setting a property from javascript"  
+    it "will call ruby accesssor function when setting a property from javascript" do
+      class_eval do
+        def dollars
+          @dollars
+        end
+        
+        def dollars=(amount)
+          @dollars = amount
+        end        
+      end
+      evaljs('o.dollars = 50')
+      @instance.dollars.should == 50
+    end
+    
+    it "will accept expando properties by default for properties on ruby object that are not implemented in ruby" do
+      evaljs('o.five = 5; o.five').should == 5
+    end
+    
+    it "it silently fails to replace properties which are defined on ruby objects but which are read-only" do
+      class_eval do
+        def bar
+          "baz"
+        end      
+      end
+      evaljs('o.bar = "bing"; o.bar').should == "baz"
+    end
   
     def evaljs(str)
       Context.open do |cxt|
@@ -245,6 +279,7 @@ describe "Ruby Javascript API" do
     end
   
     it "can limit the number of instructions that are executed in the context" do
+      pending "haven't figured out how to constrain resources in V8"
       lambda {
         Context.open do |cxt|
           cxt.instruction_limit = 100 * 1000
@@ -345,9 +380,7 @@ end
   describe "Exception Handling" do
     it "raises javascript exceptions as ruby exceptions" do
       lambda {
-        Context.open do |cxt|
-          cxt.eval('foo')
-        end
+        Context.new.eval('foo')
       }.should raise_error(JavascriptError)
     end
   end

data/spec/v8/to_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+include V8
+
+describe V8::To do
+  
+  it "can convert into perl case" do
+    To.perl_case("foo").should == "foo"
+    To.perl_case("fooBar").should == "foo_bar"
+    To.perl_case("fooBarBaz").should == "foo_bar_baz"
+    To.perl_case("XMLDocument").should == "xml_document"
+  end
+  
+  
+end

data/therubyracer.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{therubyracer}
-  s.version = "0.4.4"
+  s.version = "0.4.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Charles Lowell", "Bill Robertson"]
-  s.date = %q{2010-01-14}
+  s.date = %q{2010-01-18}
   s.description = %q{Embed the V8 Javascript interpreter into Ruby.}
   s.email = ["cowboyd@thefrontside.net", "billrobertson42@gmail.com"]
   s.extensions = ["ext/v8/extconf.rb"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: therubyracer
 version: !ruby/object:Gem::Version 
-  version: 0.4.4
+  version: 0.4.5
 platform: ruby
 authors: 
 - Charles Lowell
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-14 00:00:00 +02:00
+date: 2010-01-18 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -86,6 +86,7 @@ files:
 - spec/redjs_helper.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/v8/to_spec.rb
 - tasks/rspec.rake
 - therubyracer.gemspec
 has_rdoc: true