mustang 0.0.1 → 0.1.0

data/ext/v8/v8_base.h

@@ -0,0 +1,23 @@
+#ifndef __V8_BASE_H
+#define __V8_BASE_H
+
+#include "v8_main.h"
+
+using namespace v8;
+
+/* V8::Data class */
+RUBY_EXTERN VALUE rb_cV8Data;
+/* V8::EmptyClass class */
+RUBY_EXTERN VALUE rb_cV8EmptyClass;
+/* V8::UndefinedClass class */
+RUBY_EXTERN VALUE rb_cV8UndefinedClass;
+/* V8::NullClass class */
+RUBY_EXTERN VALUE rb_cV8NullClass;
+
+/* API */
+void Init_V8_Data();
+void Init_V8_Empty();
+void Init_V8_Undefined();
+void Init_V8_Null();
+
+#endif /* __V8_BASE_H */

data/ext/v8/v8_cast.cpp

@@ -0,0 +1,151 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_base.h"
+#include "v8_value.h"
+#include "v8_object.h"
+#include "v8_string.h"
+#include "v8_integer.h"
+#include "v8_number.h"
+#include "v8_date.h"
+#include "v8_array.h"
+#include "v8_function.h"
+#include "v8_regexp.h"
+#include "v8_context.h"
+#include "v8_external.h"
+#include "v8_errors.h"
+#include "v8_macros.h"
+
+using namespace v8;
+
+#define OVERLOAD_TO_RUBY_WITH(from)		   \
+  VALUE to_ruby(Handle<from> value)		   \
+  {						   \
+    return to_ruby((Handle<Value>) value);	   \
+  }
+
+Handle<Value> to_v8(VALUE value)
+{
+  HandleScope scope;
+  
+  switch (TYPE(value)) {
+  case T_NIL:
+    return Null();
+  case T_TRUE:
+    return True();
+  case T_FALSE:
+    return False();
+  case T_SYMBOL:
+    return to_v8(rb_sym_to_s(value));
+  case T_FIXNUM:
+    return to_v8(rb_v8_integer_new2(value));
+  case T_FLOAT:
+    return to_v8(rb_v8_number_new2(value));
+  case T_STRING:
+    return to_v8(rb_v8_string_new2(value));
+  case T_REGEXP:
+    return to_v8(rb_v8_regexp_new2(value));
+  case T_ARRAY:
+    return to_v8(rb_v8_array_new2(value));
+  case T_HASH:
+    return to_v8(rb_v8_object_new2(value));
+  default:
+    if (rb_obj_is_kind_of(value, rb_cRange)) {
+      return to_v8(rb_any_to_ary(value));
+    } else if (rb_obj_is_kind_of(value, rb_cTime)) {
+      return to_v8(rb_v8_date_new2(value));
+    } else if (rb_obj_is_kind_of(value, rb_cProc)) {
+      return to_v8(rb_v8_function_new2(value));
+    } else if (rb_obj_is_kind_of(value, rb_cMethod)) {
+      return to_v8(rb_v8_function_new2(value));
+    } else if (rb_obj_is_kind_of(value, rb_cV8Value)) {
+      return v8_ref_get<Value>(value);
+    } else if (rb_obj_is_kind_of(value, rb_cV8UndefinedClass)) {
+      return Undefined();
+    } else if (rb_obj_is_kind_of(value, rb_cV8NullClass)) {
+      return Null();
+    } else if (rb_obj_is_kind_of(value, rb_cV8EmptyClass)) {
+      return Handle<Value>();
+    } else {
+      return to_v8(rb_v8_object_new2(value));
+    }
+  }
+}
+
+VALUE to_ruby(Handle<Value> value)
+{
+  if (value.IsEmpty()) {
+    return rb_const_get(rb_mV8, rb_intern("Empty"));
+  } else if (value->IsUndefined()) {
+    return rb_const_get(rb_mV8, rb_intern("Undefined"));
+  } else if (value->IsNull()) {
+    return rb_const_get(rb_mV8, rb_intern("Null"));
+  } else if (value->IsBoolean()) {
+    return value->BooleanValue() ? Qtrue : Qfalse;
+  } else if (value->IsDate()) {
+    return to_ruby_without_peer<Date>(value, rb_cV8Date);
+  } else if (value->IsUint32() || value->IsInt32()) {
+    return to_ruby_without_peer<Integer>(value, rb_cV8Integer);
+  } else if (value->IsNumber()) {
+    return to_ruby_without_peer<Number>(value, rb_cV8Number);
+  } else if (value->IsString()) {
+    return to_ruby_without_peer<String>(value, rb_cV8String);
+  } else if (value->IsFunction()) {
+    return to_ruby_with_peer<Function>(value, rb_cV8Function);
+  } else if (value->IsRegExp()) {
+    return to_ruby_without_peer<RegExp>(value, rb_cV8Regexp);
+  } else if (value->IsArray()) {
+    return to_ruby_with_peer<Array>(value, rb_cV8Array);
+  } else if (value->IsExternal()) {
+    return to_ruby_without_peer<External>(value, rb_cV8External);
+  } else if (value->IsObject()) {
+    return to_ruby_with_peer<Object>(value, rb_cV8Object);
+  }
+
+  return Qnil;
+}
+
+OVERLOAD_TO_RUBY_WITH(Boolean);
+OVERLOAD_TO_RUBY_WITH(String);
+OVERLOAD_TO_RUBY_WITH(Integer);
+OVERLOAD_TO_RUBY_WITH(Number);
+OVERLOAD_TO_RUBY_WITH(Function);
+OVERLOAD_TO_RUBY_WITH(RegExp);
+OVERLOAD_TO_RUBY_WITH(Array);
+OVERLOAD_TO_RUBY_WITH(External);
+OVERLOAD_TO_RUBY_WITH(Object);
+
+VALUE to_ruby(bool value)     { return value ? Qtrue : Qfalse; }
+VALUE to_ruby(double value)   { return rb_float_new(value); }
+VALUE to_ruby(char *value)    { return rb_str_new2(value); }
+VALUE to_ruby(int64_t value)  { return LONG2NUM(value); }
+VALUE to_ruby(uint32_t value) { return UINT2NUM(value); }
+VALUE to_ruby(int32_t value)  { return INT2FIX(value); }
+
+/* V8::Cast module methods */
+
+VALUE rb_mV8Cast;
+
+/*
+ * call-seq:
+ *   obj.to_v8  => v8_obj
+ *
+ * Converts standard ruby object to ruby v8 representation.
+ *
+ *   [1,2,3].to_v8 # => #<V8::Array>
+ *   1230.to_v8    # => #<V8::Integer>
+ *   "foo".to_v8   # => #<V8::String>
+ *
+ */
+static VALUE rb_v8_cast_to_v8(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(to_v8(self));
+}
+
+
+/* V8::Cast module initializer */
+void Init_V8_Cast()
+{
+  rb_mV8Cast = rb_define_module_under(rb_mV8, "Cast");
+  rb_define_method(rb_mV8Cast, "to_v8", RUBY_METHOD_FUNC(rb_v8_cast_to_v8), 0);
+}

data/ext/v8/v8_cast.h

@@ -0,0 +1,64 @@
+#ifndef __V8_CAST_H
+#define __V8_CAST_H
+
+#include "v8_main.h"
+#include "v8_macros.h"
+
+using namespace v8;
+
+/* V8::Cast module */
+RUBY_EXTERN VALUE rb_mV8Cast;
+
+/* API */
+Handle<Value> to_v8(VALUE value);
+
+VALUE to_ruby(Handle<Value> value);
+VALUE to_ruby(Handle<Boolean> value);
+VALUE to_ruby(Handle<String> value);
+VALUE to_ruby(Handle<Integer> value);
+VALUE to_ruby(Handle<Number> value);
+VALUE to_ruby(Handle<Function> value);
+VALUE to_ruby(Handle<RegExp> value);
+VALUE to_ruby(Handle<Array> value);
+VALUE to_ruby(Handle<Object> value);
+
+VALUE to_ruby(bool value);
+VALUE to_ruby(double value);
+VALUE to_ruby(int64_t value);
+VALUE to_ruby(uint32_t value);
+VALUE to_ruby(int32_t value);
+VALUE to_ruby(char *value);
+
+void Init_V8_Cast();
+
+/* Universal converters */
+
+template <class T> VALUE to_ruby_with_peer(Handle<Value> value, VALUE klass)
+{
+  HandleScope scope;
+  Local<T> obj = T::Cast(*value);
+  Local<Value> peer = obj->GetHiddenValue(String::NewSymbol(RUBY_PEER_ATTR));
+
+  if (peer.IsEmpty()) {
+    VALUE self = v8_ref_new(klass, obj);
+    v8_set_peer2(obj, self);
+    return self;
+  } else {
+    return (VALUE)External::Unwrap(peer);
+  }
+}
+
+template <class T> VALUE to_ruby_without_peer(Handle<Value> value, VALUE klass)
+{
+  HandleScope scope;
+  Local<T> obj = T::Cast(*value);
+  return v8_ref_new(klass, obj);
+}
+
+template <class T> VALUE to_ruby_no_cast(Handle<T> value, VALUE klass)
+{
+  HandleScope scope;
+  return v8_ref_new(klass, value);
+}
+
+#endif//__V8_CAST_H

data/ext/v8/v8_context.cpp

@@ -0,0 +1,174 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_context.h"
+#include "v8_errors.h"
+#include "v8_macros.h"
+
+using namespace v8;
+
+VALUE rb_cV8Context;
+UNWRAPPER(Context);
+
+/* V8::Context methods */
+
+/*
+ * call-seq:
+ *   V8::Context.new  => new_context
+ *
+ * Returns new V8 context.
+ *
+ */
+static VALUE rb_v8_context_new(VALUE self)
+{
+  HandleScope scope;
+  Persistent<Context> context(Context::New());
+
+  VALUE ref = v8_ref_new(self, context);
+  rb_iv_set(ref, "@errors", rb_ary_new());
+
+  context.Dispose();
+  return ref;
+}
+
+/*
+ * call-seq:
+ *   cxt.enter                => true or false
+ *   cxt.enter { |cxt| ... }  => nil
+ *
+ * Enters to context. Returns <code>true</code> when enter action has
+ * been performed. If current context is already entered then returns
+ * <code>false</code>.
+ *
+ * If block passed then context enters only for block execution, and
+ * exits imidietely after that.
+ *
+ */
+static VALUE rb_v8_context_enter(VALUE self)
+{
+  HandleScope scope;
+  Handle<Context> context = unwrap(self);
+
+  VALUE entered = Qfalse;
+
+  if (Context::GetEntered() != context) {
+    context->Enter();
+    entered = Qtrue;
+  }
+  
+  if (rb_block_given_p()) {
+    rb_yield(self);
+    context->Exit();
+    return Qnil; 
+  }
+  
+  return entered;
+}
+
+/*
+ * call-seq:
+ *   cxt.eval(source, filename)      => result
+ *   cxt.evaluate(source, filename)  => result
+ *
+ * Evaluates given JavaScript code within current context.
+ *
+ *   cxt = V8::Context.new
+ *   cxt.evaluate("1+1", "script.js")    # => 2
+ *   cxt.evaluate("var a=1", "<eval>")   # => 1
+ *   cxt.evaluate("var b=a+1", "<eval>") # => 2
+ *
+ */
+static VALUE rb_v8_context_evaluate(VALUE self, VALUE source, VALUE filename)
+{
+  HandleScope scope;
+  
+  Local<String> _source(String::Cast(*to_v8(source)));
+  Local<String> _filename(String::Cast(*to_v8(filename)));
+
+  rb_v8_context_enter(self);
+  rb_iv_set(self, "@error", Qfalse);  
+
+  TryCatch try_catch;
+  Local<Script> script = Script::Compile(_source, _filename);
+
+  if (!try_catch.HasCaught()) {
+    Local<Value> result = script->Run();
+
+    if (!try_catch.HasCaught()) {
+      return to_ruby(result);
+    }
+  }
+
+  return rb_v8_error_new3(try_catch);
+}
+
+/*
+ * call-seq:
+ *   cxt.prototype  => obj
+ *
+ * Returns prototype object of current context. 
+ *
+ */
+VALUE rb_v8_context_prototype(VALUE self)
+{
+  HandleScope scope;
+  Handle<Object> proto(Object::Cast(*unwrap(self)->Global()->GetPrototype()));
+  return to_ruby(proto);
+}
+
+/*
+ * call-seq:
+ *   cxt.global  => value
+ *
+ * Returns global object for this context.
+ *
+ */
+static VALUE rb_v8_context_global(VALUE self)
+{
+  HandleScope scope;
+  Handle<Value> global = unwrap(self)->Global();
+  return to_ruby(global);
+}
+
+/*
+ * call-seq:
+ *   cxt.exit  => nil
+ *
+ * Exits from context.
+ *
+ */
+static VALUE rb_v8_context_exit(VALUE self)
+{
+  HandleScope scope;
+  unwrap(self)->Exit();
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   cxt.entered?  => true or false
+ *
+ * Returns <code>true</code> when this context is entered.
+ *
+ */
+static VALUE rb_v8_context_entered_p(VALUE self)
+{
+  HandleScope scope;
+  return unwrap(self) == Context::GetEntered() ? Qtrue : Qfalse;
+}
+
+
+/* V8::Context class initializer. */
+void Init_V8_Context()
+{
+  rb_cV8Context = rb_define_class_under(rb_mV8, "Context", rb_cObject);
+  rb_define_singleton_method(rb_cV8Context, "new", RUBY_METHOD_FUNC(rb_v8_context_new), 0);
+  rb_define_method(rb_cV8Context, "evaluate", RUBY_METHOD_FUNC(rb_v8_context_evaluate), 2);
+  rb_define_method(rb_cV8Context, "eval", RUBY_METHOD_FUNC(rb_v8_context_evaluate), 2);
+  rb_define_method(rb_cV8Context, "prototype", RUBY_METHOD_FUNC(rb_v8_context_prototype), 0);
+  rb_define_method(rb_cV8Context, "global", RUBY_METHOD_FUNC(rb_v8_context_global), 0);
+  rb_define_method(rb_cV8Context, "enter", RUBY_METHOD_FUNC(rb_v8_context_enter), 0);
+  rb_define_method(rb_cV8Context, "exit", RUBY_METHOD_FUNC(rb_v8_context_exit), 0);
+  rb_define_method(rb_cV8Context, "entered?", RUBY_METHOD_FUNC(rb_v8_context_entered_p), 0);
+  rb_define_attr(rb_cV8Context, "error", 1, 0);
+  rb_define_attr(rb_cV8Context, "errors", 1, 0);
+}

data/ext/v8/v8_context.h

@@ -0,0 +1,12 @@
+#ifndef __V8_CONTEXT_H
+#define __V8_CONTEXT_H
+
+#include "v8_main.h"
+
+/* V8::Context class */
+RUBY_EXTERN VALUE rb_cV8Context;
+
+/* API */
+void Init_V8_Context();
+
+#endif//__V8_CONTEXT_H

data/ext/v8/v8_date.cpp

@@ -0,0 +1,61 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_value.h"
+#include "v8_date.h"
+#include "v8_macros.h"
+
+using namespace v8;
+
+VALUE rb_cV8Date;
+UNWRAPPER(Date);
+
+/* Typecasting */
+
+Handle<Value> to_v8_date(VALUE value)
+{
+  return Date::New(NUM2DBL(value));
+}
+
+/* V8::Date methods */
+
+/*
+ * call-seq:
+ *   V8::Date.new(time)  => new_date
+ *
+ * Returns new V8 date reflected from given ruby time value.
+ *
+ */
+static VALUE rb_v8_date_new(VALUE klass, VALUE time)
+{
+  HandleScope scope;
+  return v8_ref_new(klass, to_v8_date(time));
+}
+
+/*
+ * call-seq:
+ *   str.to_i  => value
+ *
+ * Returns integer value representation of referenced v8 date.
+ *
+ */
+static VALUE rb_v8_date_to_i(VALUE self)
+{
+  HandleScope scope;
+  return rb_int_new(unwrap(self)->NumberValue());
+}
+
+/* Public constructors */
+
+VALUE rb_v8_date_new2(VALUE data)
+{
+  return rb_v8_date_new(rb_cV8Date, data);
+}
+
+
+/* V8::Date initializer. */
+void Init_V8_Date()
+{
+  rb_cV8Date = rb_define_class_under(rb_mV8, "Date", rb_cV8Value);
+  rb_define_singleton_method(rb_cV8Date, "new", RUBY_METHOD_FUNC(rb_v8_date_new), 1);
+  rb_define_method(rb_cV8Date, "to_i", RUBY_METHOD_FUNC(rb_v8_date_to_i), 0);
+}