therubyracer 0.4.0 → 0.4.1

data/Manifest.txt

@@ -4,6 +4,8 @@ Manifest.txt
 README.rdoc
 Rakefile
 docs/data_conversion.txt
+ext/v8/callbacks.cpp
+ext/v8/callbacks.h
 ext/v8/convert_ruby.cpp
 ext/v8/convert_ruby.h
 ext/v8/convert_string.cpp

data/Rakefile

@@ -26,6 +26,7 @@ end
 
 Rake::ExtensionTask.new("v8", $hoe.spec) do |ext|
   ext.lib_dir = "lib/v8"
+  ext.source_pattern = "*.{cpp,h}"
 end
 
 require 'newgem/tasks'

data/ext/v8/callbacks.cpp

@@ -0,0 +1,25 @@
+#include <ruby.h>
+
+#include "callbacks.h"
+#include "converters.h"
+
+using namespace v8;
+
+Handle<Value> RacerRubyInvocationCallback(const Arguments& args) {
+  VALUE code = (VALUE)External::Unwrap(args.Data());
+  if (NIL_P(code)) {
+    return Null();
+  } else {      
+    VALUE* arguments = new VALUE[args.Length()];
+    for(int c=0;c<args.Length(); ++c) {
+      Handle<Value> val = args[c];
+      arguments[c] = V82RB(val);
+    }
+      
+    VALUE result = rb_funcall2(code, rb_intern("call"), args.Length(), arguments);
+    delete [] arguments;
+    
+    Handle<Value> convertedResult = RB2V8(result);
+    return convertedResult  ;
+  }
+}

data/ext/v8/callbacks.h

@@ -0,0 +1,8 @@
+#ifndef CALLBACKS_H_8VK3LWBG
+#define CALLBACKS_H_8VK3LWBG
+
+#include <v8.h>
+
+v8::Handle<v8::Value> RacerRubyInvocationCallback(const v8::Arguments& args); 
+
+#endif /* end of include guard: CALLBACKS_H_8VK3LWBG */

data/ext/v8/convert_ruby.h

@@ -2,9 +2,6 @@
 #define __convert_ruby_h__
 
 #include <ruby.h>
-#include <v8.h>
-#include "v8_ref.h"
-#include "v8_obj.h"
 #include <string>
 
 /**
@@ -44,13 +41,6 @@ template<class DEST, class RET> class RubyValueSource {
           return dest.pushBool(true);
         case T_FALSE:
           return dest.pushBool(false);
-        case T_DATA:
-          VALUE clsProc = rb_eval("::Proc");
-          VALUE clsMethod = rb_eval("::Method");
-          VALUE smartMatch = rb_intern("===");
-          if (RTEST(rb_funcall(clsProc, smartMatch, value)) || RTEST(rbfuncall(clsMethod, smartMatch, value))) {
-            
-          }
         }
         return dest.pushUndefined();
     }
@@ -96,10 +86,6 @@ class RubyValueDest {
     VALUE pushUndefined() {
         return Qnil;
     }
-    
-    VALUE pushObject(v8::Handle<v8::Object>& value) {
-      return V8_Ref_Create(V8_C_Object, value);
-    }
 };
 
 

data/ext/v8/convert_v8.h

@@ -15,57 +15,69 @@ template<class T, class R> class V8HandleSource {
   V8HandleSource() {}
   ~V8HandleSource() {}
 
-  R operator() (v8::Handle<v8::Value>& value) {
+  bool operator() (v8::Handle<v8::Value>& value, R& result) {
+
+    // a bit klunky, but alternative is to evaluate what type the
+    // object is twice, which is unappealing
     
     if (value.IsEmpty()) {
-      return dest.pushNull();
+      result = dest.pushNull();
+      return true;
     }
 
     if (value->IsUndefined()) {
-      return dest.pushNull();
+      result = dest.pushNull();
+      return true;
     }
 
     if(value->IsNull()) {
-      return dest.pushNull();
+      result = dest.pushNull();
+      return true;
     }
     
     if(value->IsTrue()) {
-      return dest.pushBool(true);
+      result = dest.pushBool(true);
+      return true;
     }
 
     if(value->IsFalse()) {
-      return dest.pushBool(false);
+      result = dest.pushBool(false);
+      return true;
     }
 
     if(value->IsString()) {
       v8::Local<v8::String> str = value->ToString();
-      char buffer[1024];
-      int strlen = str->Length();
-      std::string output(strlen, 0);
-      for (int total = 0; total < strlen;) {
-        int written = str->WriteAscii(buffer, total, 1024);
-        output.replace(total, written, buffer);
-        total += written;
-      }
-      return dest.pushString(output);
+      result = convertString(str);
+      return true;
     }
 
     if(value->IsInt32()) {
-      return dest.pushInt(value->Int32Value());
+      result = dest.pushInt(value->Int32Value());
+      return true;
     }
 
     if(value->IsNumber()) {
-      return dest.pushDouble(value->NumberValue());
+      result = dest.pushDouble(value->NumberValue());
+      return true;
     }
     
-    if (value->IsObject()) {
-      v8::Local<v8::Object> object(v8::Object::Cast(*value));
-      return dest.pushObject(object);
+    result = dest.pushNull();
+    return false;
+  }
+
+  R convertString(v8::Local<v8::String>& str) {
+    char buffer[1024];
+    int strlen = str->Length();
+    std::string output(strlen, 0);
+    for (int total = 0; total < strlen;) {
+      int written = str->WriteAscii(buffer, total, 1024);
+      output.replace(total, written, buffer);
+      total += written;
     }
-    
-    return dest.pushNull();
+    return dest.pushString(output);    
   }
 
+
 };
 
 /**
@@ -103,10 +115,6 @@ public:
     v8::Local<v8::Value> pushUndefined() {
       return v8::Local<v8::Value>::New(v8::Undefined());
     }
-    
-    // v8:Local<v8:Value> pushFunction(Function) {
-    //   
-    // }
 };
 
 

data/ext/v8/converters.cpp

@@ -1,4 +1,61 @@
 #include "converters.h"
+#include "callbacks.h"
+#include "v8_ref.h"
+#include "v8_obj.h"
 
-convert_v8_to_rb_t V82RB;
-convert_rb_to_v8_t RB2V8;
+using namespace v8;
+
+namespace {
+  std::string UNDEFINED_STR("undefined");
+}
+
+VALUE V82RB(Handle<Value>& value) {
+  convert_v8_to_rb_t convert;
+  VALUE result;
+  if(convert(value, result)) {
+    return result;
+  }
+  
+  if (value->IsObject()) {
+    Local<Object> object(Object::Cast(*value));
+    return V8_Ref_Create(V8_C_Object, value);
+  }
+  
+  return Qnil;
+}
+
+Local<Value> RB2V8(VALUE value) {
+  
+  VALUE valueClass = rb_class_of(value);
+  
+  if(valueClass == rb_cProc || valueClass == rb_cMethod) {
+    Local<FunctionTemplate> t = FunctionTemplate::New(RacerRubyInvocationCallback, External::Wrap((void *)value));
+    return t->GetFunction();  
+  }
+
+  convert_rb_to_v8_t convert;
+  return convert(value);
+}
+
+std::string RB2String(VALUE value) {
+  convert_rb_to_string_t convert;
+  return convert(value);
+}
+
+std::string V82String(Handle<Value>& value) {
+  convert_v8_to_string_t convert;
+  std::string result;
+  if(convert(value, result)) {
+    return result;
+  }
+  
+  if (value->IsObject()) {
+    Local<Object> object(Object::Cast(*value));
+    Local<String> str = object->ToString();
+    if(convert(value, result)) {
+      return result;
+    }
+  }  
+  
+  return UNDEFINED_STR;
+}

data/ext/v8/converters.h

@@ -4,6 +4,7 @@
 #include "convert_ruby.h"
 #include "convert_string.h"
 #include "convert_v8.h"
+#include <cstring>
 
 typedef RubyValueSource<V8LocalDest, v8::Local<v8::Value> > convert_rb_to_v8_t; 
 typedef V8HandleSource<RubyValueDest, VALUE> convert_v8_to_rb_t;
@@ -11,7 +12,10 @@ typedef V8HandleSource<RubyValueDest, VALUE> convert_v8_to_rb_t;
 typedef RubyValueSource<StringDest, std::string> convert_rb_to_string_t;
 typedef V8HandleSource<StringDest, std::string> convert_v8_to_string_t;
 
-extern convert_v8_to_rb_t V82RB;
-extern convert_rb_to_v8_t RB2V8;
+VALUE V82RB(v8::Handle<v8::Value>& value);
+v8::Local<v8::Value> RB2V8(VALUE value);
+
+std::string RB2String(VALUE value);
+std::string V82String(v8::Handle<v8::Value>& value);
 
 #endif

data/ext/v8/v8.cpp

@@ -65,6 +65,8 @@ extern "C" {
         rb_define_method(V8_C_Object, "Set", (VALUE(*)(...))v8_Object_Set, 2);
         
         V8_C_Message = rb_define_class_under(rb_mNative, "Message", rb_cObject);
+        rb_define_method(V8_C_Message, "Get", (VALUE(*)(...))v8_Message_Get, 0);
+        
         V8_C_Function = rb_define_class_under(rb_mNative, "Function", V8_C_Object);
     }
 }

data/ext/v8/v8_cxt.cpp

@@ -18,25 +18,17 @@ VALUE v8_Context_New(int argc, VALUE *argv, VALUE self) {
 
 VALUE v8_cxt_Global(VALUE self) {
   HandleScope handles;
-  convert_v8_to_rb_t v82rb;
   Local<Context> cxt = V8_Ref_Get<Context>(self);
   Local<Value> global = *cxt->Global();
-  return v82rb(global);
+  return V82RB(global);
 }
 
 VALUE v8_cxt_open(VALUE self) {
   HandleScope handles;
-  TryCatch exceptions;
   Local<Context> cxt = V8_Ref_Get<Context>(self);
   Context::Scope enter(cxt);
   if (rb_block_given_p()) {
-    VALUE result = rb_yield(self);
-    if (exceptions.HasCaught()) {
-      return V8_Wrap_Message(exceptions.Message());
-    } else {
-      return result;
-    }
-    return result;
+    return rb_yield(self);
   } else {
     return Qnil;
   }
@@ -44,12 +36,17 @@ VALUE v8_cxt_open(VALUE self) {
 
 VALUE v8_cxt_eval(VALUE self, VALUE source) {
   HandleScope handles;
+  TryCatch exceptions;
   Local<Context> cxt = V8_Ref_Get<Context>(self);
   Context::Scope enter(cxt);
   Local<Value> source_str = RB2V8(source);
   Local<Script> script = Script::Compile(source_str->ToString());
   Local<Value> result = script->Run();
-  return V82RB(result);
+  if (exceptions.HasCaught()) {
+    return V8_Ref_Create(V8_C_Message, exceptions.Message());
+  } else {
+    return V82RB(result);
+  }
 }
 
 

data/ext/v8/v8_msg.cpp

@@ -1,4 +1,4 @@
-
+#include "converters.h"
 #include "v8_msg.h"
 #include "v8_ref.h"
 
@@ -8,4 +8,10 @@ VALUE V8_C_Message;
 
 VALUE V8_Wrap_Message(Handle<v8::Message> msg) {
   return V8_Ref_Create(V8_C_Message, msg);
+}
+
+VALUE v8_Message_Get(VALUE self) {
+  Local<Message> message = V8_Ref_Get<Message>(self);
+  Local<Value> str = message->Get();
+  return V82RB(str);
 }

data/ext/v8/v8_msg.h

@@ -6,4 +6,5 @@
 
 extern VALUE V8_C_Message;
 VALUE V8_Wrap_Message(v8::Handle<v8::Message> msg);
+VALUE v8_Message_Get(VALUE self);
 #endif

data/ext/v8/v8_obj.cpp

@@ -4,6 +4,8 @@
 
 using namespace v8;
 
+#include <cstdio>
+
 VALUE V8_C_Object;
 
 VALUE v8_Object_New(VALUE clazz) {
@@ -21,9 +23,9 @@ VALUE v8_Object_Get(VALUE self, VALUE key) {
 
 VALUE v8_Object_Set(VALUE self, VALUE key, VALUE value) {
   HandleScope handles;
-  convert_rb_to_v8_t rb2v8;
   Local<Object> obj = V8_Ref_Get<Object>(self);
   VALUE keystr = rb_funcall(key, rb_intern("to_s"), 0);
-  obj->Set(rb2v8(keystr), rb2v8(value));
+  
+  obj->Set(RB2V8(keystr), RB2V8(value));
   return Qnil;
 }

data/ext/v8/v8_script.cpp

@@ -15,7 +15,6 @@ VALUE v8_script_new(VALUE self, VALUE source) {
 VALUE v8_script_Run(VALUE self) {
   HandleScope handles;
   Local<Script> script = V8_Ref_Get<Script>(self);
-  convert_v8_to_rb_t toValue;
   Local<Value> result = script->Run();
-  return toValue(result);  
+  return V82RB(result);
 }

data/ext/v8/v8_template.cpp

@@ -4,27 +4,9 @@
 #include "v8_func.h"
 #include "v8_template.h"
 #include "converters.h"
+#include "callbacks.h"
 
 using namespace v8;
-
-Handle<Value> RubyInvocationCallback(const Arguments& args) {
-  VALUE code = (VALUE)External::Unwrap(args.Data());
-  if (NIL_P(code)) {
-    return Null();
-  } else {      
-    VALUE* arguments = new VALUE[args.Length()];
-    for(int c=0;c<args.Length(); ++c) {
-      Handle<Value> val = args[c];
-      arguments[c] = V82RB(val);
-    }
-      
-    VALUE result = rb_funcall2(code, rb_intern("call"), args.Length(), arguments);
-    delete [] arguments;
-    
-    Handle<Value> convertedResult = RB2V8(result);
-    return convertedResult  ;
-  }
-}
  
 VALUE v8_Template_Set(VALUE self, VALUE name, VALUE value) {
   HandleScope handles;
@@ -43,7 +25,7 @@ VALUE v8_FunctionTemplate_New(int argc, VALUE *argv, VALUE self) {
   VALUE code;
   rb_scan_args(argc, argv, "00&", &code);
   HandleScope handles;
-  Local<FunctionTemplate> t = FunctionTemplate::New(RubyInvocationCallback, External::Wrap((void *)code));
+  Local<FunctionTemplate> t = FunctionTemplate::New(RacerRubyInvocationCallback, External::Wrap((void *)code));
   return V8_Ref_Create(self,t,code);
 }
 

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

data/lib/v8/context.rb

@@ -6,14 +6,15 @@ module V8
     
     def open(&block)
       @native.open do
-        block.call(self).tap do |result|
-          raise JavascriptError.new(result) if result.kind_of?(C::Message)
-        end
+        block.call(self)
       end if block_given?
     end
     
     def eval(javascript)
-      To.ruby @native.eval(javascript)
+      @native.eval(javascript).tap do |result|
+        raise JavascriptError.new(result) if result.kind_of?(C::Message)
+        return To.ruby(result)
+      end
     end
         
     def evaluate(*args)
@@ -36,6 +37,8 @@ module V8
   class ContextError < StandardError
   end
   class JavascriptError < StandardError
-    
+    def initialize(v8_message)
+      super(v8_message.Get())
+    end
   end
 end

data/spec/redjs/jsapi_spec.rb

@@ -1,4 +1,3 @@
-require 'rubygems'
 require "#{File.dirname(__FILE__)}/../redjs_helper.rb"
 
 describe "Ruby Javascript API" do
@@ -101,7 +100,7 @@ describe "Ruby Javascript API" do
 
     it "can embed a closure into a context and call it" do
       Context.open do |cxt|
-        cxt["say"] = C::FunctionTemplate.new {|word, times| word * times}
+        cxt["say"] = lambda {|word, times| word * times}
         cxt.eval("say('Hello',2)").should == "HelloHello"
       end
     end

data/therubyracer.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{therubyracer}
-  s.version = "0.4.0"
+  s.version = "0.4.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Charles Lowell", "Bill Robertson"]
-  s.date = %q{2009-12-22}
+  s.date = %q{2010-01-09}
   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.0
+  version: 0.4.1
 platform: ruby
 authors: 
 - Charles Lowell
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-22 00:00:00 +02:00
+date: 2010-01-09 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,6 +42,8 @@ files:
 - README.rdoc
 - Rakefile
 - docs/data_conversion.txt
+- ext/v8/callbacks.cpp
+- ext/v8/callbacks.h
 - ext/v8/convert_ruby.cpp
 - ext/v8/convert_ruby.h
 - ext/v8/convert_string.cpp