h8 0.0.2 → 0.0.4

data/ext/h8/main.cpp

@@ -1,3 +1,4 @@
+#include <functional>
 #include <h8.h>
 #include <include/libplatform/libplatform.h>
 
@@ -7,23 +8,37 @@ extern "C" {
 void Init_h8(void);
 }
 
-VALUE h8_exception;
+VALUE h8_exception, js_exception, js_timeout_exception;
 VALUE context_class;
+VALUE ruby_gate_class;
 VALUE value_class;
+VALUE Rundefined;
 
 ID id_is_a;
+ID id_safe_call;
+
+VALUE protect_ruby(const std::function<VALUE()> &block) {
+	try {
+		return block();
+	} catch (JsError& e) {
+		e.raise();
+	} catch (...) {
+		rb_raise(rb_eStandardError, "unknown error in JS");
+	}
+	return Qnil;
+}
 
 static void rvalue_free(void* ptr) {
 	delete (JsGate*) ptr;
 }
 
-void h8::rvalue_mark(void* ptr) {
-	JsGate *gate = (JsGate*)ptr;
-	rb_gc_mark(gate->h8->self);
+static void rvalue_mark(void* ptr) {
+	JsGate *gate = (JsGate*) ptr;
+	rb_gc_mark(gate->ruby_context());
 }
 
 VALUE rvalue_alloc(VALUE klass) {
-	return Data_Wrap_Struct(klass, h8::rvalue_mark, rvalue_free, new JsGate);
+	return Data_Wrap_Struct(klass, rvalue_mark, rvalue_free, new JsGate);
 }
 
 inline JsGate* rv(VALUE self) {
@@ -56,11 +71,11 @@ static VALUE rvalue_is_undefined(VALUE self) {
 	return rv(self)->is_undefined();
 }
 
-static VALUE rvalue_get_attr(VALUE self,VALUE name) {
+static VALUE rvalue_get_attr(VALUE self, VALUE name) {
 	return rv(self)->get_attribute(name);
 }
 
-static VALUE rvalue_get_index(VALUE self,VALUE index) {
+static VALUE rvalue_get_index(VALUE self, VALUE index) {
 	return rv(self)->get_index(index);
 }
 
@@ -81,11 +96,19 @@ static VALUE rvalue_is_function(VALUE self) {
 }
 
 static VALUE rvalue_call(VALUE self, VALUE args) {
-	return rv(self)->call(args);
+	return protect_ruby([&] {
+		return rv(self)->call(args);
+	});
 }
 
-static VALUE rvalue_apply(VALUE self, VALUE to,VALUE args) {
-	return rv(self)->apply(to,args);
+static VALUE rvalue_apply(VALUE self, VALUE to, VALUE args) {
+	return protect_ruby([&] {
+		return rv(self)->apply(to, args);
+	});
+}
+
+static VALUE rvalue_get_ruby_context(VALUE self) {
+	return rv(self)->ruby_context();
 }
 
 //------------ context ----------------------------------------------------------------
@@ -96,26 +119,37 @@ inline H8* rc(VALUE self) {
 	return prcxt;
 }
 
-static VALUE context_eval(VALUE self, VALUE script) {
-	H8* cxt = rc(self);
-	H8::Scope s(cxt);
-	return cxt->eval_to_ruby(StringValueCStr(script));
+static VALUE context_eval(VALUE self, VALUE script,VALUE timeout) {
+	return protect_ruby([&] {
+		H8* cxt = rc(self);//		v8::Locker l(cxt->getIsolate());
+		H8::Scope s(cxt);
+		return cxt->eval_to_ruby(StringValueCStr(script), FIX2INT(timeout));
+	});
 }
 
-static VALUE context_set_var(VALUE self, VALUE name,VALUE value) {
-	rc(self)->set_var(name, value);
-	return Qnil;
+static VALUE context_set_var(VALUE self, VALUE name, VALUE value) {
+	return protect_ruby([=] {
+		rc(self)->set_var(name, value);
+		return Qnil;
+	});
 }
 
 static void context_free(void* ptr) {
 	delete (H8*) ptr;
 }
 
-VALUE h8::context_alloc(VALUE klass) {
+static void context_mark(void* ptr) {
+	H8* h8 = (H8*) ptr;
+	h8->ruby_mark_gc();
+}
+
+namespace h8 {
+VALUE context_alloc(VALUE klass) {
 	H8 *h8 = new H8;
-	h8->self = Data_Wrap_Struct(klass, 0, context_free, h8);
+	h8->self = Data_Wrap_Struct(klass, context_mark, context_free, h8);
 	return h8->self;
 }
+}
 
 void init_v8() {
 	v8::V8::InitializeICU();
@@ -128,13 +162,16 @@ void Init_h8(void) {
 	init_v8();
 
 	id_is_a = rb_intern("is_a?");
+	id_safe_call = rb_intern("secure_call");
 
 	VALUE h8 = rb_define_module("H8");
 
 	context_class = rb_define_class_under(h8, "Context", rb_cObject);
+	ruby_gate_class = rb_define_class_under(h8, "RubyGate", rb_cObject);
 	rb_define_alloc_func(context_class, context_alloc);
-	rb_define_method(context_class, "eval", (ruby_method) context_eval, 1);
-	rb_define_method(context_class, "set_var", (ruby_method) context_set_var, 2);
+	rb_define_method(context_class, "_eval", (ruby_method) context_eval, 2);
+	rb_define_method(context_class, "set_var", (ruby_method) context_set_var,
+			2);
 
 	value_class = rb_define_class_under(h8, "Value", rb_cObject);
 	rb_define_alloc_func(value_class, rvalue_alloc);
@@ -143,20 +180,27 @@ void Init_h8(void) {
 	rb_define_method(value_class, "to_f", (ruby_method) rvalue_to_f, 0);
 	rb_define_method(value_class, "integer?", (ruby_method) rvalue_is_int, 0);
 	rb_define_method(value_class, "float?", (ruby_method) rvalue_is_float, 0);
-	rb_define_method(value_class, "string?", (ruby_method) rvalue_is_string,
-			0);
+	rb_define_method(value_class, "string?", (ruby_method) rvalue_is_string, 0);
 	rb_define_method(value_class, "array?", (ruby_method) rvalue_is_array, 0);
 	rb_define_method(value_class, "object?", (ruby_method) rvalue_is_object, 0);
-	rb_define_method(value_class, "function?", (ruby_method) rvalue_is_function, 0);
-	rb_define_method(value_class, "undefined?", (ruby_method) rvalue_is_undefined,
+	rb_define_method(value_class, "function?", (ruby_method) rvalue_is_function,
 			0);
+	rb_define_method(value_class, "undefined?",
+			(ruby_method) rvalue_is_undefined, 0);
 	rb_define_method(value_class, "_get_attr", (ruby_method) rvalue_get_attr,
 			1);
 	rb_define_method(value_class, "_get_index", (ruby_method) rvalue_get_index,
 			1);
 	rb_define_method(value_class, "_call", (ruby_method) rvalue_call, 1);
 	rb_define_method(value_class, "_apply", (ruby_method) rvalue_apply, 2);
+	rb_define_method(value_class, "context",
+			(ruby_method) rvalue_get_ruby_context, 0);
 
 	h8_exception = rb_define_class_under(h8, "Error", rb_eStandardError);
+	js_exception = rb_define_class_under(h8, "JsError", h8_exception);
+	js_timeout_exception = rb_define_class_under(h8, "TimeoutError", js_exception);
 
+	VALUE u_class = rb_define_class_under(h8, "UndefinedClass", rb_cObject);
+	Rundefined = rb_funcall(u_class, rb_intern("instance"), 0);
 }
+

data/ext/h8/object_wrap.h

@@ -23,7 +23,7 @@
 #ifndef SRC_OBJECT_WRAP_H_
 #define SRC_OBJECT_WRAP_H_
 
-#include "v8.h"
+#include <include/v8.h>
 #include <assert.h>
 
 

data/ext/h8/ruby_gate.cpp

@@ -0,0 +1,117 @@
+#include "h8.h"
+#include "ruby_gate.h"
+#include <ruby.h>
+
+using namespace h8;
+
+h8::RubyGate::RubyGate(H8* _context, VALUE object) :
+		context(_context), ruby_object(object), next(0), prev(0) {
+	v8::HandleScope scope(context->getIsolate());
+//        	printf("Ruby object gate constructor\n");
+	context->add_resource(this);
+
+	v8::Local<v8::ObjectTemplate> templ = ObjectTemplate::New();
+	templ->SetInternalFieldCount(2);
+	templ->SetCallAsFunctionHandler(&ObjectCallback);
+
+	templ->SetNamedPropertyHandler(h8::RubyGate::mapGet, h8::RubyGate::mapSet);
+
+	v8::Handle<v8::Object> handle = templ->NewInstance();
+	handle->SetAlignedPointerInInternalField(1, RUBYGATE_ID);
+	Wrap(handle);
+}
+
+void h8::RubyGate::mapGet(Local<String> name,
+		const PropertyCallbackInfo<Value> &info) {
+	RubyGate *rg = RubyGate::unwrap(info.This());
+	assert(rg != 0);
+	rg->getProperty(name, info);
+}
+
+void h8::RubyGate::mapSet(Local<String> name,
+		Local<Value> value,
+		const PropertyCallbackInfo<Value> &info) {
+	RubyGate *rg = RubyGate::unwrap(info.This());
+	assert(rg != 0);
+	rg->setProperty(name, value, info);
+}
+
+void h8::RubyGate::ObjectCallback(
+		const v8::FunctionCallbackInfo<v8::Value>& args) {
+	v8::HandleScope scope(args.GetIsolate());
+	v8::Handle<v8::Object> obj = args.This();
+	RubyGate* rg = h8::ObjectWrap::Unwrap<RubyGate>(args.This());
+	rg->doObjectCallback(args);
+}
+
+VALUE h8::RubyGate::rescue_callback(VALUE me, VALUE exception_object) {
+	RubyGate* gate;
+	Data_Get_Struct(me, RubyGate, gate);
+	gate->last_ruby_error = exception_object;
+	return Qnil;
+}
+
+VALUE RubyGate::call(VALUE args) {
+	VALUE callable = rb_ary_pop(args);
+	return rb_proc_call(callable, args);
+}
+
+VALUE RubyGate::secure_call(VALUE args) {
+	VALUE method = rb_ary_pop(args);
+	VALUE receiver = rb_ary_pop(args);
+	return rb_funcall(context_class, id_safe_call, 3, receiver, method, args);
+}
+
+void h8::RubyGate::throw_js() {
+	Local<v8::Object> error = v8::Exception::Error(
+			context->js("ruby exception")).As<v8::Object>();
+	error->Set(context->js("source"), context->to_js(last_ruby_error));
+	context->getIsolate()->ThrowException(error);
+}
+
+void h8::RubyGate::rescued_call(VALUE rb_args, VALUE (*call)(VALUE),
+		const std::function<void(VALUE)> &block) {
+	last_ruby_error = Qnil;
+	VALUE me = Data_Wrap_Struct(ruby_gate_class, 0, 0, this);
+	VALUE res = rb_rescue((ruby_method) (call), rb_args,
+			(ruby_method) (rescue_callback), me);
+	if (last_ruby_error == Qnil)
+		block(res);
+	else
+		throw_js();
+}
+
+void h8::RubyGate::doObjectCallback(
+		const v8::FunctionCallbackInfo<v8::Value>& args) {
+
+	VALUE rb_args = ruby_args(args, 1);
+	rb_ary_push(rb_args, ruby_object);
+	return rescued_call(rb_args, call, [&] (VALUE res) {
+		args.GetReturnValue().Set(context->to_js(res));
+	});
+}
+
+void h8::RubyGate::getProperty(Local<String> name,
+		const PropertyCallbackInfo<Value> &info) {
+	VALUE rb_args = rb_ary_new2(2);
+	rb_ary_push(rb_args, ruby_object);
+	rb_ary_push(rb_args, context->to_ruby(name));
+	return rescued_call(rb_args, secure_call, [&] (VALUE res) {
+		info.GetReturnValue().Set(context->to_js(res));
+		});
+}
+
+void h8::RubyGate::setProperty(Local<String> name,
+		Local<Value> value,
+		const PropertyCallbackInfo<Value> &info) {
+	VALUE rb_args = rb_ary_new2(3);
+	rb_ary_push(rb_args, context->to_ruby(value));
+	rb_ary_push(rb_args, ruby_object);
+	VALUE method = context->to_ruby(name);
+	method = rb_str_cat2(method, "=");
+	rb_ary_push(rb_args, method);
+	return rescued_call(rb_args, secure_call, [&] (VALUE res) {
+		info.GetReturnValue().Set(context->to_js(res));
+		});
+}
+

data/ext/h8/ruby_gate.h

@@ -0,0 +1,118 @@
+#ifndef __ruby_gate_h
+#define __ruby_gate_h
+
+#include <exception>
+#include <functional>
+
+#include "h8.h"
+#include "object_wrap.h"
+#include "allocated_resource.h"
+
+namespace h8 {
+
+#define RUBYGATE_ID ((void*)0xF0200)
+
+/**
+ * Gate a generic ruby object to Javascript context and retain it for
+ * the lifetime of the javascript object
+ */
+class RubyGate: public ObjectWrap, public AllocatedResource {
+public:
+	RubyGate(H8* _context, VALUE object);
+
+	/**
+	 * Check the handle and unwrap the RubyGate if it is wrapped
+	 * @return wrapped RubyGate* or 0
+	 */
+	static RubyGate* unwrap(v8::Handle<v8::Object> handle) {
+		if (handle->InternalFieldCount() == 2
+				&& handle->GetAlignedPointerFromInternalField(1) == RUBYGATE_ID) {
+			return ObjectWrap::Unwrap<RubyGate>(handle);
+		}
+		return 0;
+	}
+
+	void setRubyInstance(VALUE instance) {
+		this->ruby_object = instance;
+	}
+
+	virtual void rb_mark_gc() {
+		rb_gc_mark(ruby_object);
+	}
+
+	virtual void free() {
+		AllocatedResource::free();
+		persistent().ClearWeak();
+		persistent().Reset();
+		delete this;
+	}
+
+	VALUE rubyObject() const {
+		return ruby_object;
+	}
+
+	virtual ~RubyGate() {
+	}
+
+protected:
+	/**
+	 * Perform rb_rescue call to 'call' callback, and invoke block with value returned by callback
+	 * unless a ruby exception is caught, in which a correct JsError is thrown.
+	 */
+	void rescued_call(VALUE rb_args, VALUE (*call)(VALUE),const std::function<void(VALUE)> &block);
+
+	/**
+	 * Convert some v8 parameters-like object to ruby arguments array, allocating
+	 * extra slots in array if need
+	 */
+	template <class T>
+	VALUE ruby_args(const T& args, unsigned extras = 0) {
+		unsigned n = args.Length();
+		VALUE rb_args = rb_ary_new2(n+extras);
+		for (unsigned i = 0; i < n; i++)
+			rb_ary_push(rb_args, context->to_ruby(args[i]));
+		return rb_args;
+	}
+
+
+	/**
+	 * Ruby callable callback for rb_rescue and like. Args [0..-2] are call arguments,
+	 * last arg[-1] should be a callable to perform call with (for performance
+	 * reasons it should be the last).
+	 */
+	static VALUE call(VALUE args);
+
+	/**
+	 * Call ruby method via H8::Context#secure_call
+	 */
+	static VALUE secure_call(VALUE args);
+
+	/**
+	 * callback for rb_rescue. Sets last_ruby_error.
+	 */
+	static VALUE rescue_callback(VALUE me,VALUE exception_object);
+
+	void getProperty(Local<String> name, const PropertyCallbackInfo<Value> &info);
+	void setProperty(Local<String> name, Local<Value> value,const PropertyCallbackInfo<Value> &info);
+private:
+
+	void doObjectCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+	static void ObjectCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
+	static void mapGet(Local<String> name, const PropertyCallbackInfo<Value> &info);
+	static void mapSet(Local<String> name, Local<Value> value,const PropertyCallbackInfo<Value> &info);
+
+	void throw_js();
+
+
+	friend class H8;
+
+	H8 *context;
+	VALUE ruby_object = Qnil;
+	VALUE last_ruby_error = Qnil;
+
+	RubyGate *next, *prev;
+};
+}
+
+#endif

data/hybrid8.gemspec

@@ -1,6 +1,7 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
 require 'h8/version'
 require "rake/extensiontask"
 require 'rubygems/package_task'
@@ -11,7 +12,7 @@ spec = Gem::Specification.new do |spec|
   spec.authors       = ["sergeych"]
   spec.email         = ["real.sergeych@gmail.com"]
   spec.summary       = %q{Minimalistic and sane v8 bindings}
-  spec.description   = %q{Should be more or less replacement for broken therubyracer gem and riny 2.1+ }
+  spec.description   = %q{Should be more or less replacement for broken therubyracer gem and ruby 2.1+ }
   spec.homepage      = ""
   spec.license       = "MIT"
 
@@ -42,3 +43,4 @@ Rake::ExtensionTask.new "h8", spec do |ext|
 end
 
 spec
+

data/lib/h8.rb

@@ -1,9 +1,68 @@
 require 'h8/version'
 require 'h8/context'
-require 'h8/h8'
 require 'h8/value'
+require 'singleton'
 
 module H8
+  # The exception that H8 raises on errors that are not caused by executing
+  # javascript (e.g. bad parameters, illegal conversion and so on)
+  class Error < StandardError
+  end
+
+  # The general error caused by the script execution, e.g. uncaught javascript exceptinos and like.
+  # Check #message to see the cause.
+  class JsError < Error
+    attr :message
+    attr :source
+
+    def to_s
+      message
+    end
+  end
+
+  # Script execution is timed out (see H8::Context#eval timeout parameter)
+  class TimeoutError < JsError
+    def initialize message
+      super
+      @message = message
+      @source = nil
+    end
+  end
+
+  # The class representing undefined in javascript. Singleton
+  # Nota that H8::Undefined == false but is not FalseClass
+  class UndefinedClass
+    include Singleton
+
+    def blank?
+      true
+    end
+
+    def undefined?
+      true
+    end
 
-  # Your code goes here...
+    def empty?
+      true
+    end
+
+    def present?
+      false
+    end
+
+    def !
+      true
+    end
+
+    def == x
+      x.is_a?(H8::UndefinedClass) || x == false
+    end
+
+  end
+
+  # The constant representing 'undefined' value in Javascript
+  # The proper use is to compare returned value res == H8::Undefined
+  Undefined = UndefinedClass.instance
 end
+
+require 'h8/h8'