therubyracer 0.4.0

data/ext/v8/converters.cpp

@@ -0,0 +1,4 @@
+#include "converters.h"
+
+convert_v8_to_rb_t V82RB;
+convert_rb_to_v8_t RB2V8;

data/ext/v8/converters.h

@@ -0,0 +1,17 @@
+#ifndef __converters_h__
+#define __converters_h__
+
+#include "convert_ruby.h"
+#include "convert_string.h"
+#include "convert_v8.h"
+
+typedef RubyValueSource<V8LocalDest, v8::Local<v8::Value> > convert_rb_to_v8_t; 
+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;
+
+#endif

data/ext/v8/extconf.rb

@@ -0,0 +1,25 @@
+#!/opt/local/bin/ruby
+require 'mkmf'
+
+dir_config('v8')
+have_library('v8') or raise "unable to find libv8"
+
+create_makefile('v8')
+
+# now add a few extra targets
+File.open("Makefile", "a") do |makefile|
+makefile.print <<EOF
+
+test: all
+	@echo running spec...
+	spec -O spec/spec.opts spec/therubyracer_spec.rb
+
+docs/cpp:
+	mkdir -p docs/cpp
+
+docs: all docs/cpp
+	@echo Generate C++ docs to docs/cpp/html
+	doxygen Doxyfile
+
+EOF
+end

data/ext/v8/v8.cpp

@@ -0,0 +1,70 @@
+#include "v8_cxt.h"
+#include "v8_str.h"
+#include "v8_obj.h"
+#include "v8_msg.h"
+#include "v8_func.h"
+#include "v8_script.h"
+#include "v8_template.h"
+#include "v8_standalone.h"
+
+#include <stdio.h>
+
+extern "C" {
+    /**
+     * ruby init method for the extension
+     */
+    void Init_v8();
+}
+
+VALUE rb_mModule;
+VALUE rb_cV8;
+
+extern "C" {
+    void Init_v8() {
+      
+        ruby_call_symbol = ID2SYM(rb_intern("call"));
+        ruby_respond_to_ID = rb_intern("respond_to?");
+        ruby_proc_class = rb_eval_string("::Proc");
+        ruby_method_class = rb_eval_string("::Method");
+      
+        rb_mModule = rb_define_module("V8");
+        rb_define_singleton_method(rb_mModule, "what_is_this?", (VALUE(*)(...)) v8_what_is_this, 1);
+                
+        //native module setup
+        VALUE rb_mNative = rb_define_module_under(rb_mModule, "C");
+        
+        //native context
+        VALUE V8__C__Context = rb_define_class_under(rb_mNative, "Context", rb_cObject);
+        rb_define_singleton_method(V8__C__Context, "new", (VALUE(*)(...)) v8_Context_New, -1);
+        rb_define_method(V8__C__Context, "Global", (VALUE(*)(...)) v8_cxt_Global, 0);
+        rb_define_method(V8__C__Context, "open", (VALUE(*)(...)) v8_cxt_open, 0);
+        rb_define_method(V8__C__Context, "eval", (VALUE(*)(...)) v8_cxt_eval, 1);
+        
+        //native String
+        VALUE V8__C__String = rb_define_class_under(rb_mNative, "String", rb_cObject);
+        rb_define_singleton_method(V8__C__String, "new", (VALUE(*)(...)) v8_str_new, 1);
+        rb_define_method(V8__C__String, "to_s", (VALUE(*)(...)) v8_str_to_s, 0);
+        
+        VALUE V8__C__Script = rb_define_class_under(rb_mNative, "Script", rb_cObject);
+        rb_define_singleton_method(V8__C__Script, "new", (VALUE(*)(...)) v8_script_new, 1);
+        rb_define_method(V8__C__Script, "Run", (VALUE(*)(...)) v8_script_Run, 0);
+        
+        VALUE V8__C__Template = rb_define_class_under(rb_mNative, "Template", rb_cObject);
+        rb_define_method(V8__C__Template, "Set", (VALUE(*)(...))v8_Template_Set, 2);
+        
+        VALUE V8__C__ObjectTemplate = rb_define_class_under(rb_mNative, "ObjectTemplate", V8__C__Template);
+        rb_define_singleton_method(V8__C__ObjectTemplate, "new", (VALUE(*)(...))v8_ObjectTemplate_New, 0);
+        
+        VALUE V8__C__FunctionTemplate = rb_define_class_under(rb_mNative, "FunctionTemplate", V8__C__Template);
+        rb_define_singleton_method(V8__C__FunctionTemplate, "new", (VALUE(*)(...))v8_FunctionTemplate_New, -1);
+        rb_define_method(V8__C__FunctionTemplate, "GetFunction", (VALUE(*)(...))v8_FunctionTemplate_GetFunction, 0);
+        
+        V8_C_Object = rb_define_class_under(rb_mNative, "Object", rb_cObject);
+        rb_define_singleton_method(V8_C_Object, "new", (VALUE(*)(...))v8_Object_New, 0);
+        rb_define_method(V8_C_Object, "Get", (VALUE(*)(...))v8_Object_Get, 1);
+        rb_define_method(V8_C_Object, "Set", (VALUE(*)(...))v8_Object_Set, 2);
+        
+        V8_C_Message = rb_define_class_under(rb_mNative, "Message", rb_cObject);
+        V8_C_Function = rb_define_class_under(rb_mNative, "Function", V8_C_Object);
+    }
+}

data/ext/v8/v8_cxt.cpp

@@ -0,0 +1,55 @@
+#include "v8_cxt.h"
+#include "v8_msg.h"
+#include "converters.h"
+
+using namespace v8;
+
+VALUE v8_Context_New(int argc, VALUE *argv, VALUE self) {
+  HandleScope handles;
+  VALUE scope;
+  rb_scan_args(argc,argv, "01", &scope);
+  if (NIL_P(scope)) {
+    return V8_Ref_Create(self, Context::New());
+  } else {
+    Local<ObjectTemplate> t = V8_Ref_Get<ObjectTemplate>(scope);    
+    return V8_Ref_Create(self, Context::New(0, t));
+  }
+}
+
+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);
+}
+
+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;
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE v8_cxt_eval(VALUE self, VALUE source) {
+  HandleScope handles;
+  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);
+}
+
+

data/ext/v8/v8_cxt.h

@@ -0,0 +1,16 @@
+#ifndef _RUBY_V8_CXT_
+#define _RUBY_V8_CXT_ 
+
+#include "ruby.h"
+#include "v8.h"
+#include "v8_ref.h"
+
+extern VALUE rb_cV8;
+extern VALUE V8_C_Object;
+
+VALUE v8_Context_New(int argc, VALUE *argv, VALUE self);
+VALUE v8_cxt_Global(VALUE self);
+VALUE v8_cxt_open(VALUE self);
+VALUE v8_cxt_eval(VALUE self, VALUE source);
+
+#endif

data/ext/v8/v8_func.cpp

@@ -0,0 +1,10 @@
+
+#include "v8_func.h"
+
+using namespace v8;
+
+VALUE V8_C_Function;
+
+VALUE V8_Wrap_Function(Handle<Function> f) {
+  return V8_Ref_Create(V8_C_Function, f);
+}

data/ext/v8/v8_func.h

@@ -0,0 +1,11 @@
+#ifndef _RUBY_V8_FUNCTION_
+#define _RUBY_V8_FUNCTION_
+
+#include "v8.h"
+#include "ruby.h"
+#include "v8_ref.h"
+
+extern VALUE V8_C_Function;
+
+VALUE V8_Wrap_Function(v8::Handle<v8::Function> f);
+#endif

data/ext/v8/v8_msg.cpp

@@ -0,0 +1,11 @@
+
+#include "v8_msg.h"
+#include "v8_ref.h"
+
+using namespace v8;
+
+VALUE V8_C_Message;
+
+VALUE V8_Wrap_Message(Handle<v8::Message> msg) {
+  return V8_Ref_Create(V8_C_Message, msg);
+}

data/ext/v8/v8_msg.h

@@ -0,0 +1,9 @@
+#ifndef _RUBY_V8_MESSAGE_
+#define _RUBY_V8_MESSAGE_ 
+
+#include "v8.h"
+#include "ruby.h"
+
+extern VALUE V8_C_Message;
+VALUE V8_Wrap_Message(v8::Handle<v8::Message> msg);
+#endif

data/ext/v8/v8_obj.cpp

@@ -0,0 +1,29 @@
+#include "v8_obj.h"
+#include "v8_ref.h"
+#include "converters.h"
+
+using namespace v8;
+
+VALUE V8_C_Object;
+
+VALUE v8_Object_New(VALUE clazz) {
+  HandleScope handles;
+  return V8_Ref_Create(clazz, Object::New());
+}
+
+VALUE v8_Object_Get(VALUE self, VALUE key) {
+  HandleScope handles;  
+  Local<Object> obj = V8_Ref_Get<Object>(self);
+  VALUE keystr = rb_funcall(key,rb_intern("to_s"), 0);
+  Local<Value> value = obj->Get(RB2V8(keystr));
+  return V82RB(value);
+}
+
+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));
+  return Qnil;
+}

data/ext/v8/v8_obj.h

@@ -0,0 +1,11 @@
+#ifndef _RUBY_V8_OBJECT_
+#define _RUBY_V8_OBJECT_ 
+
+#include "ruby.h"
+
+extern VALUE V8_C_Object;
+
+VALUE v8_Object_New(VALUE clazz);
+VALUE v8_Object_Get(VALUE self, VALUE key);
+VALUE v8_Object_Set(VALUE self, VALUE key, VALUE value);
+#endif

data/ext/v8/v8_ref.cpp

@@ -0,0 +1,27 @@
+#include <v8_ref.h>
+#include "stdio.h"
+using namespace v8;
+
+
+v8_ref::v8_ref(Handle<void> object, VALUE ref) : handle(Persistent<void>::New(object)), references(ref) {
+  //printf("Allocating v8 reference\n");
+}
+
+v8_ref::~v8_ref() {  
+  //printf("Disposing v8 reference\n");
+  handle.Dispose();
+}
+
+void v8_ref_mark(v8_ref* ref) {
+  if (ref->references != 0) {
+    rb_gc_mark(ref->references);
+  }
+}
+
+void v8_ref_free(v8_ref* ref) {
+  delete ref;
+}
+
+VALUE V8_Ref_Create(VALUE ruby_class, v8::Handle<void> handle, VALUE ref) {
+  return Data_Wrap_Struct(ruby_class, v8_ref_mark, v8_ref_free, new v8_ref(handle, ref));
+}

data/ext/v8/v8_ref.h

@@ -0,0 +1,31 @@
+#ifndef _RUBY_V8_REF_
+#define _RUBY_V8_REF_
+
+#include <v8.h>
+#include "ruby.h"
+
+//the v8_ref wraps a v8 handle so that ruby can hold a reference to it.
+
+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);
+  virtual ~v8_ref();
+  v8::Persistent<void> handle;
+  VALUE references;
+};
+
+
+//memory management
+void v8_ref_mark(v8_ref* ref);
+void v8_ref_free(v8_ref* ref);
+
+VALUE V8_Ref_Create(VALUE ruby_class, v8::Handle<void> handle, VALUE ref = 0);
+
+template <class T> v8::Local<T> V8_Ref_Get(VALUE object) {
+  v8_ref* ref = 0;
+  Data_Get_Struct(object, struct v8_ref, ref); 
+  return (T *)*ref->handle;  
+}
+
+#endif

data/ext/v8/v8_script.cpp

@@ -0,0 +1,21 @@
+#include "v8.h"
+#include "v8_ref.h"
+#include "v8_script.h"
+#include "converters.h"
+
+using namespace v8;
+
+
+VALUE v8_script_new(VALUE self, VALUE source) {
+  HandleScope handles;
+  Local<String> src = V8_Ref_Get<String>(source);
+  return V8_Ref_Create(self, Script::New(src));
+}
+
+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);  
+}

data/ext/v8/v8_script.h

@@ -0,0 +1,8 @@
+#ifndef _RUBY_V8_SCRIPT_
+#define _RUBY_V8_SCRIPT_ 
+
+#include "ruby.h"
+
+VALUE v8_script_new(VALUE self, VALUE source);
+VALUE v8_script_Run(VALUE self);
+#endif

data/ext/v8/v8_standalone.cpp

@@ -0,0 +1,70 @@
+#include "v8_standalone.h"
+
+VALUE ruby_call_symbol;
+VALUE ruby_respond_to_ID;
+
+VALUE ruby_proc_class;
+VALUE ruby_method_class;
+
+
+bool is_callable(VALUE& object) {
+  return Qtrue == rb_funcall(object, ruby_respond_to_ID, 1, ruby_call_symbol);  
+}
+
+bool is_function(VALUE& object) {
+  VALUE klass = RDATA(object)->basic.klass;
+  return  klass == ruby_proc_class || klass == ruby_method_class;
+}
+
+/**
+ * Debugging aid
+ */
+VALUE v8_what_is_this(VALUE self, VALUE object) {
+  VALUE boolean;
+  switch (TYPE(object)) {
+    case T_NIL:		
+    printf("nil\n");
+    break;
+    case T_OBJECT:	
+    printf("ordinary object\n"); 
+    if (is_callable(object)) {
+      printf("responds to call!<br/>");
+    }
+    break;
+    case T_CLASS:		
+      printf("class[%s]<br/>", rb_class2name(object)); 
+      break;
+    case T_MODULE:	printf("module\n"); break;
+    case T_FLOAT:	printf("floating point number\n"); break;
+    case T_STRING:	printf("string\n"); break;
+    case T_REGEXP:	printf("regular expression\n"); break;
+    case T_ARRAY:	printf("array\n"); break;
+    case T_FIXNUM:	printf("Fixnum(31bit integer)\n"); break;
+    case T_HASH:	printf("associative array\n"); break;
+    case T_STRUCT:	printf("(Ruby) structure\n"); break;
+    case T_BIGNUM:	printf("multi precision integer\n"); break;
+    case T_FILE:	printf("IO\n"); break;
+    case T_TRUE:	printf("true\n"); break;
+    case T_FALSE:	printf("false\n"); break;
+    case T_DATA:	
+      printf("data... inspecting\n");
+      if (is_function(object)) {
+        printf("It's a function!!!<br/>");
+      }
+      if (is_callable(object)) {
+        printf("Responds to call!<br/>");
+      } else {
+        printf("Does *NOT* respond to call<br/>");
+      }
+      v8_what_is_this(Qnil, RDATA(object)->basic.klass);
+      break;
+    case T_SYMBOL:	printf("symbol\n"); break;
+
+    default:
+    printf("I have no idea!!!\n");
+      rb_raise(rb_eTypeError, "not valid value");
+      break;
+  }
+  
+  return Qnil;
+}