mustang 0.0.1 → 0.1.0

data/ext/v8/v8_date.h

@@ -0,0 +1,16 @@
+#ifndef __V8_DATE_H
+#define __V8_DATE_H
+
+#include "v8_main.h"
+
+using namespace v8;
+
+/* V8::Date class */
+RUBY_EXTERN VALUE rb_cV8Date;
+
+/* API */
+Handle<Value> to_v8_date(VALUE value);
+VALUE rb_v8_date_new2(VALUE data);
+void Init_V8_Date();
+
+#endif//__V8_DATE_H

data/ext/v8/v8_errors.cpp

@@ -0,0 +1,147 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_value.h"
+#include "v8_base.h"
+#include "v8_errors.h"
+#include "v8_macros.h"
+
+#include <string.h>
+
+using namespace v8;
+
+VALUE rb_eV8Error;
+VALUE rb_eV8RangeError;
+VALUE rb_eV8ReferenceError;
+VALUE rb_eV8SyntaxError;
+VALUE rb_eV8TypeError;
+
+/* V8::Error methods */
+
+/*
+ * call-seq:
+ *   err.syntax_error?  => true or false
+ *
+ * Returns <code>true</code> when it represents an syntax error.
+ *
+ */
+static VALUE rb_v8_error_syntax_error_p(VALUE self)
+{
+  return rb_obj_is_kind_of(self, rb_eV8SyntaxError);
+}
+
+/*
+ * call-seq:
+ *   err.range_error?  => true or false
+ *
+ * Returns <code>true</code> when it represents an range error.
+ *
+ */
+static VALUE rb_v8_error_range_error_p(VALUE self)
+{
+  return rb_obj_is_kind_of(self, rb_eV8RangeError);
+}
+
+/*
+ * call-seq:
+ *   err.reference_error?  => true or false
+ *
+ * Returns <code>true</code> when it represents an reference error.
+ *
+ */
+static VALUE rb_v8_error_reference_error_p(VALUE self)
+{
+  return rb_obj_is_kind_of(self, rb_eV8ReferenceError);
+}
+
+/*
+ * call-seq:
+ *   err.type_error?  => true or false
+ *
+ * Returns <code>true</code> when it represents an type error.
+ *
+ */
+static VALUE rb_v8_error_type_error_p(VALUE self)
+{
+  return rb_obj_is_kind_of(self, rb_eV8TypeError);
+}
+
+/* Local helpers */
+
+VALUE rb_v8_error_message(Handle<Object> ex)
+{
+  HandleScope scope;
+  String::AsciiValue error_msg(ex->Get(String::New("message")));
+  return rb_str_new2(*error_msg);
+}
+
+VALUE rb_v8_error_klass(Handle<Object> ex)
+{
+  HandleScope scope;
+  Handle<Function> con(Function::Cast(*ex->Get(String::New("constructor"))));
+
+  if (!con.IsEmpty() && !con->IsUndefined() && !con->IsNull()) {
+    String::AsciiValue con_name(con->GetName());
+    char* type = (char*)*con_name;
+
+    if (strcmp(type, "SyntaxError") == 0) {
+      return rb_eV8SyntaxError;
+    } else if (strcmp(type, "ReferenceError") == 0) {
+      return rb_eV8ReferenceError;
+    } else if (strcmp(type, "RangeError") == 0) {
+      return rb_eV8RangeError;
+    } else if (strcmp(type, "TypeError") == 0) {
+      return rb_eV8TypeError;
+    }
+  }
+
+  return rb_eV8Error;
+}
+
+/* Public constructors */
+
+VALUE rb_v8_error_new2(Handle<Value> ex, Handle<Message> msg, Handle<Value> trace)
+{
+  HandleScope scope;
+  
+  Handle<Object> exc(Object::Cast(*ex));
+  VALUE err = rb_funcall2(rb_v8_error_klass(exc), rb_intern("new"), 0, NULL);
+
+  // Error class doesn't have any reflections to v8 objects, so we have to
+  // rewrite everything into its instance variables.
+  rb_iv_set(err, "@message", rb_v8_error_message(exc));
+  rb_iv_set(err, "@line_no", to_ruby(msg->GetLineNumber()));
+  rb_iv_set(err, "@source_line", to_ruby(msg->GetSourceLine()));
+  rb_iv_set(err, "@script_name", to_ruby(msg->GetScriptResourceName()));
+  rb_iv_set(err, "@start_col", to_ruby(msg->GetStartColumn()));
+  rb_iv_set(err, "@end_col", to_ruby(msg->GetEndColumn()));
+  
+  return err;
+}
+
+VALUE rb_v8_error_new3(TryCatch try_catch)
+{
+  return rb_v8_error_new2(try_catch.Exception(), try_catch.Message(), try_catch.StackTrace());
+}
+
+
+/* V8 error types initializer. */
+void Init_V8_Errors()
+{
+  rb_eV8Error = rb_define_class_under(rb_mV8, "Error", rb_cV8Data);
+  rb_define_method(rb_eV8Error, "reference_error?", RUBY_METHOD_FUNC(rb_v8_error_reference_error_p), 0);
+  rb_define_method(rb_eV8Error, "syntax_error?", RUBY_METHOD_FUNC(rb_v8_error_syntax_error_p), 0);
+  rb_define_method(rb_eV8Error, "range_error?", RUBY_METHOD_FUNC(rb_v8_error_range_error_p), 0);
+  rb_define_method(rb_eV8Error, "type_error?", RUBY_METHOD_FUNC(rb_v8_error_type_error_p), 0);
+  rb_define_attr(rb_eV8Error, "message", 1, 0);
+  rb_define_attr(rb_eV8Error, "line_no", 1, 0);
+  rb_define_attr(rb_eV8Error, "source_line", 1, 0);
+  rb_define_attr(rb_eV8Error, "script_name", 1, 0);
+  rb_define_attr(rb_eV8Error, "start_col", 1, 0);
+  rb_define_attr(rb_eV8Error, "end_col", 1, 0);
+  rb_define_attr(rb_eV8Error, "stack_trace", 1, 0);
+    
+  rb_eV8RangeError = rb_define_class_under(rb_mV8, "RangeError", rb_eV8Error);
+  rb_eV8ReferenceError = rb_define_class_under(rb_mV8, "ReferenceError", rb_eV8Error);
+  rb_eV8SyntaxError = rb_define_class_under(rb_mV8, "SyntaxError", rb_eV8Error);
+  rb_eV8TypeError = rb_define_class_under(rb_mV8, "TypeError", rb_eV8Error);
+}

data/ext/v8/v8_errors.h

@@ -0,0 +1,19 @@
+#ifndef __V8_ERRORS_H
+#define __V8_ERRORS_H
+
+#include "v8_main.h"
+
+using namespace v8;
+
+RUBY_EXTERN VALUE rb_eV8Error;
+RUBY_EXTERN VALUE rb_eV8RangeError;
+RUBY_EXTERN VALUE rb_eV8ReferenceError;
+RUBY_EXTERN VALUE rb_eV8StntaxError;
+RUBY_EXTERN VALUE rb_eV8TypeError;
+
+/* API */
+VALUE rb_v8_error_new2(Handle<Value> ex, Handle<Message> msg);
+VALUE rb_v8_error_new3(TryCatch try_catch);
+void Init_V8_Errors();
+
+#endif /* __V8_ERRORS_H */

data/ext/v8/v8_external.cpp

@@ -0,0 +1,66 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_value.h"
+#include "v8_external.h"
+#include "v8_macros.h"
+
+using namespace v8;
+
+VALUE rb_cV8External;
+UNWRAPPER(External);
+
+/* Typecasting helpers */
+
+Handle<Value> to_v8_external(VALUE value)
+{
+  return External::New((void*)value);
+}
+
+/* V8::External methods */
+
+/*
+ * call-seq:
+ *   V8::External.new(obj)   => new_external_obj
+ *   V8::External.wrap(obj)  => new_external_obj
+ *
+ * Wraps given object as new v8 external.
+ *
+ */
+static VALUE rb_v8_external_new(VALUE klass, VALUE obj)
+{
+  HandleScope scope;
+  return v8_ref_new(klass, to_v8_external(obj));
+}
+  
+/*
+ * call-seq:
+ *   ext.value   => native_obj
+ *   ext.to_obj  => native_obj
+ *   ext.unwrap  => native_obj
+ *
+ * Returns original value of wraped external. 
+ *
+ */
+static VALUE rb_v8_external_value(VALUE self)
+{
+  HandleScope scope;
+  return (VALUE)unwrap(self)->Value();
+}
+
+/* Public constructors */
+
+VALUE rb_v8_external_new2(VALUE data)
+{
+  return rb_v8_external_new(rb_cV8External, data);
+}
+
+
+/* V8::External initializer. */
+void Init_V8_External()
+{
+  rb_cV8External = rb_define_class_under(rb_mV8, "External", rb_cV8Value);
+  rb_define_singleton_method(rb_cV8External, "new", RUBY_METHOD_FUNC(rb_v8_external_new), 1);
+  rb_define_singleton_method(rb_cV8External, "wrap", RUBY_METHOD_FUNC(rb_v8_external_new), 1);
+  rb_define_method(rb_cV8External, "value", RUBY_METHOD_FUNC(rb_v8_external_value), 0);
+  rb_define_method(rb_cV8External, "to_obj", RUBY_METHOD_FUNC(rb_v8_external_value), 0);
+}

data/ext/v8/v8_external.h

@@ -0,0 +1,16 @@
+#ifndef __V8_EXTERNAL_H
+#define __V8_EXTERNAL_H
+
+#include "v8_main.h"
+
+using namespace v8;
+
+/* V8::External class */
+RUBY_EXTERN VALUE rb_cV8External;
+
+/* API */
+Handle<Value> to_v8_external(VALUE value);
+VALUE rb_v8_external_new2(VALUE data);
+void Init_V8_External();
+
+#endif//__V8_EXTERNAL_H

data/ext/v8/v8_function.cpp

@@ -0,0 +1,182 @@
+#include "v8_ref.h"
+#include "v8_cast.h"
+#include "v8_object.h"
+#include "v8_function.h"
+#include "v8_external.h"
+#include "v8_errors.h"
+#include "v8_macros.h"
+
+using namespace v8;
+
+VALUE rb_cV8Function;
+UNWRAPPER(Function);
+
+/* Typecasting */
+
+static Handle<Value> proc_caller(const Arguments &args)
+{
+  HandleScope scope;
+
+  if (!args.Data().IsEmpty() && args.Data()->IsExternal()) {
+    VALUE proc = (VALUE)External::Cast(*args.Data())->Value();
+    VALUE proc_args[args.Length()];
+
+    // We have to invoke `arity` on given proc instead of calling rb_proc_arity,
+    // because we can have instance of Method instead of Proc...
+    int proc_arity = FIX2INT(rb_funcall2(proc, rb_intern("arity"), 0, NULL));
+    
+    if (proc_arity < 0 || proc_arity == args.Length()) {
+      for (int i = 0; i < args.Length(); i++) {
+	proc_args[i] = to_ruby(args[i]);
+      }
+
+      // Again, we have to invoke `call` method like this instead of rb_proc_call...
+      return to_v8(rb_funcall2(proc, rb_intern("call"), args.Length(), proc_args));
+    } else {
+      ThrowException(Exception::Error(String::New("wrong number of arguments")));
+    }
+  }
+
+  return Null();
+}
+
+Handle<Value> to_v8_function(VALUE value)
+{
+  HandleScope scope;
+  Handle<FunctionTemplate> func = FunctionTemplate::New(proc_caller, to_v8_external(value));
+  return func->GetFunction();
+}
+
+/* V8::Function methods */
+
+/*
+ * call-seq:
+ *   V8::Function.new(proc)    => new_func
+ *   V8::Function.new { ... }  => new_func
+ *
+ * When block given then creates new function based on it, otherwise
+ * creates function based on passed parameter (proc/lambda/method).
+ *
+ */
+static VALUE rb_v8_function_new(int argc, VALUE *argv, VALUE klass)
+{
+  HandleScope scope;
+  VALUE orig;
+  
+  if (rb_block_given_p()) {
+    orig = rb_block_proc();
+  } else {
+    if (argc == 1) {
+      orig = argv[0];
+    } else {
+      rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
+      return Qnil;
+    }
+  }
+
+  VALUE self = v8_ref_new(klass, to_v8_function(orig), orig);
+  rb_iv_set(self, "@origin", orig);
+  v8_set_peer(self);
+
+  return self;
+}
+
+/*
+ * call-seq:
+ *   func.call_on(recv, *args)  => result
+ *
+ * Executes function with given arguments on specified receiver. When function code is
+ * broken then proper JavaScript error will be returned. 
+ *
+ */
+static VALUE rb_v8_function_call_on(int argc, VALUE *argv, VALUE self)
+{
+  HandleScope scope;
+  TryCatch try_catch;
+
+  if (argc < 1) {
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", FIX2INT(argc));
+    return Qnil;
+  }
+  
+  VALUE recv = argv[0];
+  
+  Handle<Object> this_obj =
+    NIL_P(recv) ? Context::GetEntered()->Global() :
+    unwrap(recv)->ToObject();
+  
+  Handle<Value> args[argc-1];
+  
+  for (int i = 1; i < argc; i++) {
+    args[i-1] = to_v8(argv[i]);
+  }
+  
+  Handle<Value> result = unwrap(self)->Call(this_obj, argc-1, args);
+
+  if (try_catch.HasCaught()) {
+    return rb_v8_error_new3(try_catch);
+  } else {
+    return to_ruby(result);
+  }
+}
+
+/*
+ * call-seq:
+ *   func.name  => str
+ *
+ * Returns function's internal name.
+ *
+ */
+static VALUE rb_v8_function_get_name(VALUE self)
+{
+  HandleScope scope;
+  return to_ruby(unwrap(self)->GetName());
+}
+
+/*
+ * call-seq:
+ *   func.name = str  => str
+ *
+ * Sets function's internal name.
+ *
+ */
+static VALUE rb_v8_function_set_name(VALUE self, VALUE name)
+{
+  HandleScope scope;
+  unwrap(self)->SetName(String::New(StringValuePtr(name)));
+  return name;
+}
+
+/*
+ * call-seq:
+ *   func.bind(obj)  => obj
+ *
+ * Binds given object as function's receiver. 
+ *
+ */
+static VALUE rb_v8_function_bind(VALUE self, VALUE recv)
+{
+  return rb_iv_set(self, "@receiver", recv);
+}
+
+
+/* Public constructors */
+
+VALUE rb_v8_function_new2(VALUE data)
+{
+  return rb_v8_function_new(1, &data, rb_cV8Function);
+}
+
+
+/* V8::Function initializer. */
+void Init_V8_Function()
+{
+  rb_cV8Function = rb_define_class_under(rb_mV8, "Function", rb_cV8Object);
+  rb_define_singleton_method(rb_cV8Function, "new", RUBY_METHOD_FUNC(rb_v8_function_new), -1);
+  rb_define_method(rb_cV8Function, "bind", RUBY_METHOD_FUNC(rb_v8_function_bind), 1);
+  rb_define_method(rb_cV8Function, "call_on", RUBY_METHOD_FUNC(rb_v8_function_call_on), -1);
+  rb_define_method(rb_cV8Function, "name", RUBY_METHOD_FUNC(rb_v8_function_get_name), 0);
+  rb_define_method(rb_cV8Function, "name=", RUBY_METHOD_FUNC(rb_v8_function_set_name), 1);
+  rb_define_attr(rb_cV8Function, "receiver", 1, 0);
+  rb_define_attr(rb_cV8Function, "origin", 1, 0);
+}