therubyracer 0.4.7-x86-darwin-9

data/ext/v8/v8_cxt.cpp

@@ -0,0 +1,92 @@
+#include "v8_cxt.h"
+#include "v8_msg.h"
+#include "v8_template.h"
+#include "converters.h"
+
+using namespace v8;
+
+VALUE V8_C_Context;
+
+//TODO: rename everything to Context_
+//TODO: do the object init from within here
+
+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 {
+    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;
+  }
+}
+
+VALUE v8_Context_InContext(VALUE self) {
+  return Context::InContext() ? Qtrue : Qfalse;  
+}
+
+VALUE v8_Context_GetCurrent(VALUE self) {
+  HandleScope handles;
+  if (Context::InContext()) {
+    Local<Context> current = Context::GetCurrent();
+    return V8_Ref_Create(self, current);    
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE v8_cxt_Global(VALUE self) {
+  HandleScope handles;
+  Local<Context> cxt = V8_Ref_Get<Context>(self);
+  Local<Value> global = *cxt->Global();
+  return V82RB(global);
+}
+
+VALUE v8_cxt_open(VALUE self) {
+  HandleScope handles;
+  Local<Context> cxt = V8_Ref_Get<Context>(self);
+  Context::Scope enter(cxt);
+  if (rb_block_given_p()) {
+    return rb_yield(self);
+  } else {
+    return Qnil;
+  }
+}
+
+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());
+	if (exceptions.HasCaught()) {
+		return V8_Ref_Create(V8_C_Message, exceptions.Message());
+	}
+  Local<Value> result = script->Run();
+  if (exceptions.HasCaught()) {
+    return V8_Ref_Create(V8_C_Message, exceptions.Message());
+  } else {
+    return V82RB(result);
+  }
+}
+
+VALUE v8_cxt_eql(VALUE self, VALUE other) {
+  HandleScope handles;
+  if (RTEST(CLASS_OF(other) != V8_C_Context)) {
+    return Qnil;
+  } else {
+    Local<Context> cxt = V8_Ref_Get<Context>(self);
+    Local<Context> that = V8_Ref_Get<Context>(other);
+    return cxt == that ? Qtrue : Qfalse;
+  }
+  return Qnil;
+}
+
+

data/ext/v8/v8_cxt.h

@@ -0,0 +1,20 @@
+#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;
+extern VALUE V8_C_Context;
+
+VALUE v8_Context_New(int argc, VALUE *argv, VALUE self);
+VALUE v8_Context_InContext(VALUE self);
+VALUE v8_Context_GetCurrent(VALUE self);
+VALUE v8_cxt_Global(VALUE self);
+VALUE v8_cxt_open(VALUE self);
+VALUE v8_cxt_eval(VALUE self, VALUE source);
+VALUE v8_cxt_eql(VALUE self, VALUE other);
+
+#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,17 @@
+#include "converters.h"
+#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);
+}
+
+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

@@ -0,0 +1,10 @@
+#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);
+VALUE v8_Message_Get(VALUE self);
+#endif

data/ext/v8/v8_obj.cpp

@@ -0,0 +1,52 @@
+#include "v8_obj.h"
+#include "v8_ref.h"
+#include "converters.h"
+
+using namespace v8;
+
+#include <cstdio>
+
+VALUE V8_C_Object;
+
+namespace {
+  Local<Object> unwrap(VALUE robj) {
+    return V8_Ref_Get<Object>(robj);
+  }
+}
+
+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 = unwrap(self);
+  VALUE keystr = rb_str_to_str(key);
+  Local<Value> value = obj->Get(RB2V8(keystr));
+  return V82RB(value);
+}
+
+VALUE v8_Object_Set(VALUE self, VALUE key, VALUE value) {
+  HandleScope handles;
+  Local<Object> obj = unwrap(self);
+
+  VALUE keystr = rb_funcall(key, rb_intern("to_s"), 0);
+  obj->Set(RB2V8(keystr), RB2V8(value));
+  return Qnil;
+}
+
+VALUE v8_Object_GetPropertyNames(VALUE self) {
+  HandleScope handles;
+  Local<Object> object = unwrap(self);  
+  Local<Value> names = object->GetPropertyNames();
+  return V82RB(names);
+}
+
+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_obj.h

@@ -0,0 +1,13 @@
+#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);
+VALUE v8_Object_GetPropertyNames(VALUE self);
+VALUE v8_Object_context(VALUE self);
+#endif

data/ext/v8/v8_ref.cpp

@@ -0,0 +1,26 @@
+#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) {
+
+}
+
+v8_ref::~v8_ref() {  
+  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,20 @@
+#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);
+  Local<Value> result = script->Run();
+  return V82RB(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,69 @@
+#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) {
+  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;
+}

data/ext/v8/v8_standalone.h

@@ -0,0 +1,31 @@
+#ifndef __v8_standalone_h__
+#define __v8_standalone_h__
+
+#include "ruby.h"
+
+/**
+ * interned symbol for "call"
+ */
+extern VALUE ruby_call_symbol;
+
+/**
+ * id for respond_to?
+ */
+extern VALUE ruby_respond_to_ID;
+
+extern VALUE ruby_proc_class;
+extern VALUE ruby_method_class;
+
+
+/**
+ * Determine whether or not a value can respond to "call".
+ * i.e. is this Proc/Method object?
+ */
+bool is_callable(VALUE& object);
+
+/**
+ * Debugging aid.  Println debugging goo for VALUES.
+ */
+VALUE v8_what_is_this(VALUE self, VALUE object);
+
+#endif

data/ext/v8/v8_str.cpp

@@ -0,0 +1,17 @@
+
+#include "v8_str.h"
+#include "v8.h"
+#include "v8_ref.h"
+
+using namespace v8;
+
+VALUE v8_str_new(VALUE clazz, VALUE str) {
+  HandleScope handles;
+  return V8_Ref_Create(clazz, String::New(RSTRING(str)->ptr));
+}
+
+VALUE v8_str_to_s(VALUE self){
+  HandleScope handles;
+  Local<String> str = V8_Ref_Get<String>(self);
+  return rb_str_new2(*String::AsciiValue(str));
+}