h8 0.0.2 → 0.0.4

data/ext/h8/h8.cpp

@@ -1,16 +1,108 @@
+#include <thread>
+#include <mutex>
+#include <condition_variable>
+#include <chrono>
+
 #include "h8.h"
+#include "ruby_gate.h"
+
+void h8::JsError::raise() {
+	if (has_js_exception) {
+		VALUE ruby_exception;
+		{
+			// raising exception does longjump so we should keep all memory
+			// allocation done before:
+			H8::Scope scope(h8);
+
+			Local<Object> jsx = exception().As<Object>();
+			Local<Value> source = jsx->Get(h8->js("source"));
+			RubyGate *rg = RubyGate::unwrap(source.As<Object>());
+			if (rg) {
+				// Passing thru the Ruby exception
+				ruby_exception = rg->rubyObject();
+			} else {
+				Local<String> s = message()->Get();
+				String::Utf8Value res(s->ToString());
+				ruby_exception = ruby_exception = rb_exc_new2(js_exception,
+						*res ? *res : "test");
+				rb_iv_set(ruby_exception, "@message", h8->to_ruby(s));
+				// TODO: Pass also all information from Message instance
+				rb_iv_set(ruby_exception, "@source", h8->to_ruby(source));
+			}
+		}
+		rb_exc_raise(ruby_exception);
+//		}
+	} else {
+		rb_raise(h8_exception, "%s", reason);
+	}
+}
 
-Local<Value> h8::H8::gateObject(VALUE ruby_value) const {
+void h8::JsTimeoutError::raise() {
+	rb_raise(js_timeout_exception, "timeout expired");
+}
+
+Local<Value> h8::H8::gateObject(VALUE ruby_value) {
 	if ( Qtrue == rb_funcall(ruby_value, id_is_a, 1, value_class)) {
 		JsGate *gate;
 		Data_Get_Struct(ruby_value, JsGate, gate);
-		if( gate->h8 != this ) {
-			rb_raise(h8_exception, "H8::Value is bound to other H8::Context");
-			return Undefined(isolate);
-		}
-		else
+		if (gate->h8 != this) {
+			throw JsError(this, "H8::Value is bound to other H8::Context");
+		} else
 			return gate->value();
 	}
-	rb_raise(h8_exception, "Object gate is not implemented");
-	return Undefined(isolate);
+	// Generic Ruby object
+	RubyGate *gate = new RubyGate(this, ruby_value);
+	return gate->handle(isolate);
+}
+
+void h8::H8::ruby_mark_gc() const {
+	for (chain::link *x : resources)
+		((AllocatedResource*) x)->rb_mark_gc();
+}
+
+v8::Handle<v8::Value> h8::H8::eval(const char* script_utf,unsigned max_ms) {
+	v8::EscapableHandleScope escape(isolate);
+	Local<Value> result;
+
+	Handle<v8::String> script_source = String::NewFromUtf8(isolate, script_utf);
+	v8::Handle<v8::Script> script;
+	JsCatcher try_catch(this);
+	v8::ScriptOrigin origin(String::NewFromUtf8(isolate, "eval"));
+
+	script = v8::Script::Compile(script_source, &origin);
+
+	if (script.IsEmpty()) {
+		try_catch.throwIfCaught();
+		result = Undefined(isolate);
+	} else {
+		result = Undefined(isolate);
+		if( max_ms > 0 ) {
+			std::mutex m;
+			std::condition_variable cv;
+			std::thread thr( [&] {
+				std::unique_lock<std::mutex> lock(m);
+				if( std::cv_status::timeout == cv.wait_for(lock, std::chrono::milliseconds(max_ms) ) ) {
+					isolate->TerminateExecution();
+				}
+			});
+			script->Run();
+			cv.notify_all();
+			thr.join();
+		}
+		else {
+			result = script->Run();
+		}
+		try_catch.throwIfCaught();
+	}
+	return escape.Escape(result);
+}
+
+h8::H8::~H8() {
+	while (!resources.is_empty()) {
+		// this should also remove it from the list:
+		resources.peek_first<AllocatedResource>()->free();
+	}
+
+	persistent_context.Reset();
+	isolate->Dispose();
 }

data/ext/h8/h8.h

@@ -4,24 +4,76 @@
 #include <include/v8.h>
 #include <ruby.h>
 #include <iostream>
+#include <exception>
+#include "allocated_resource.h"
+#include "JsCatcher.h"
 
 using namespace v8;
 using namespace std;
 
-extern VALUE h8_exception;
-extern VALUE h8_class;
+extern VALUE h8_exception, js_exception, js_timeout_exception;
+extern VALUE context_class;
 extern VALUE value_class;
+extern VALUE ruby_gate_class;
+extern VALUE Rundefined;
 
 extern ID id_is_a;
-
-//#include <ruby/thread.h>
+extern ID id_safe_call;
 
 namespace h8 {
 
+/// Allocate ruby H8::Context class (wrapper for h8::H8), ruby utility function
+/// shold be declared as friend
+VALUE context_alloc(VALUE klass);
+
+class RubyGate;
+class H8;
+
 template<class T> inline void t(const T& x) {
 	cout << x << endl << flush;
 }
 
+/**
+ * The exception that is raised toward ruby code, e.g. when JS code throws uncaught exception,
+ * interpreter fails to cope with syntax, parameters are used in a wrong way, etc. Instead of calling
+ * rb_raise() which will longjump() over all your C++ code, throw instance of JsError.
+ */
+class JsError: public std::exception {
+public:
+	JsError(H8* h8, const char* str_reason) :
+			h8(h8), has_js_exception(false) {
+		reason = str_reason;
+	}
+
+	JsError(H8* h8, v8::Local<v8::Message> message, v8::Local<v8::Value> exception);
+
+	/**
+	 * Call it with a proper exception class and be careful - after this call no code will be executed!
+	 */
+	virtual void raise();
+
+	Local<Message> message() const;
+
+	Local<Value> exception() const;
+
+	virtual ~JsError() noexcept {
+		_message.Reset();
+		_exception.Reset();
+	}
+protected:
+	const char* reason;
+	bool has_js_exception;
+	H8 *h8;
+	v8::Persistent<v8::Message, v8::CopyablePersistentTraits<v8::Message>> _message;
+	v8::Persistent<v8::Value, v8::CopyablePersistentTraits<v8::Value>> _exception;
+};
+
+class JsTimeoutError : public JsError {
+public:
+	JsTimeoutError(H8* h8) : JsError(h8, NULL) {}
+	virtual void raise();
+};
+
 class H8 {
 public:
 
@@ -29,6 +81,7 @@ public:
 		v8::Isolate::Scope isolate_scope;
 		v8::Context::Scope context_scope;
 		H8* rcontext;
+
 	public:
 		Scope(H8* cxt) :
 				HandleScope(cxt->getIsolate()), isolate_scope(
@@ -39,7 +92,8 @@ public:
 
 	static void init();
 
-	H8() {
+	H8() :
+			self(Qnil) {
 		isolate = Isolate::New();
 		Isolate::Scope isolate_scope(isolate);
 		HandleScope handle_scope(isolate);
@@ -51,33 +105,19 @@ public:
 		persistent_context.Reset(isolate, context);
 	}
 
-	Handle<Value> eval(const char* script_utf) {
-		v8::EscapableHandleScope escape(isolate);
-		Local<Value> result;
-
-		Handle<v8::String> script_source = String::NewFromUtf8(isolate,
-				script_utf);
-		v8::Handle<v8::Script> script;
-		v8::TryCatch try_catch;
-		v8::ScriptOrigin origin(String::NewFromUtf8(isolate, "eval"));
-
-		script = v8::Script::Compile(script_source, &origin);
-
-		if (script.IsEmpty()) {
-			report_exception(try_catch);
-			result = Undefined(isolate);
-		} else {
-			result = script->Run();
-			if (try_catch.HasCaught()) {
-				report_exception(try_catch);
-			}
-		}
-		return escape.Escape(result);
-	}
-
-	VALUE eval_to_ruby(const char* script_utf) {
+	/**
+	 * Evaluate javascript.
+	 *
+	 * \param script_utf the null-terminated script string in utf8 endcoding
+	 * \param max_ms if set, then script maximum execution time will be limited
+	 * 				 to this value, JsTimeoutError will be thrown if exceeded
+	 * \return the value returned by the script.
+	 */
+	Handle<Value> eval(const char* script_utf,unsigned max_ms=0);
+
+	VALUE eval_to_ruby(const char* script_utf,int timeout=0) {
 		// TODO: throw ruby exception on error
-		return to_ruby(eval(script_utf));
+		return to_ruby(eval(script_utf,timeout));
 	}
 
 	Handle<Context> getContext() {
@@ -107,7 +147,7 @@ public:
 		getContext()->Global()->Set(js(name), to_js(value));
 	}
 
-	Local<Value> to_js(VALUE ruby_value) const {
+	Local<Value> to_js(VALUE ruby_value) {
 		switch (TYPE(ruby_value)) {
 		case T_STRING:
 			return js(ruby_value);
@@ -115,35 +155,46 @@ public:
 			return v8::Int32::New(isolate, FIX2INT(ruby_value));
 		case T_FLOAT:
 			return v8::Number::New(isolate, NUM2DBL(ruby_value));
+		case T_UNDEF:
+			return v8::Undefined(isolate);
+		case T_NIL:
+			return v8::Null(isolate);
 		case T_DATA:
 		case T_OBJECT:
 			return gateObject(ruby_value);
 		default:
-			rb_raise(h8_exception, "can't gate to js: unknown type");
+			VALUE msg = rb_str_new2("can't gate to js (unknown): ");
+			rb_str_append(msg, rb_any_to_s(ruby_value));
+			throw JsError(this, StringValueCStr(msg));
 		}
 		return Undefined(isolate);
 	}
 
-	Local<Value> gateObject(VALUE object) const;
+	Local<Value> gateObject(VALUE object);
 
-	virtual ~H8() {
-		persistent_context.Reset();
+	VALUE ruby_context() const {
+		return self;
 	}
 
+	void add_resource(AllocatedResource *resource) {
+		resources.push(resource);
+	}
+
+	void ruby_mark_gc() const;
+
+	virtual ~H8();
+
 private:
-	friend VALUE context_alloc(VALUE klass);
-	friend void rvalue_mark(void* ptr);
+	friend VALUE h8::context_alloc(VALUE klass);
 
 	Isolate *isolate;
 	VALUE self;
 
-	void report_exception(v8::TryCatch& tc) {
-		rb_raise(h8_exception, "Failed to compile/execute script");
-	}
-
 	Persistent<Context> persistent_context;
 
 	bool is_error = false;
+
+	chain resources;
 };
 // Context
 }
@@ -156,4 +207,20 @@ inline VALUE h8::H8::to_ruby(Handle<Value> value) {
 	return JsGate::to_ruby(this, value);
 }
 
+inline h8::JsError::JsError(H8* h8, v8::Local<v8::Message> message,
+		v8::Local<v8::Value> exception) :
+		h8(h8), _message(h8->getIsolate(), message), _exception(h8->getIsolate(),
+				exception), has_js_exception(true), reason(NULL) {
+}
+
+inline Local<Message> h8::JsError::message() const {
+	return Local<Message>::New(h8->getIsolate(), _message);
+}
+
+inline Local<Value> h8::JsError::exception() const {
+	return Local<Value>::New(h8->getIsolate(), _exception);
+}
+
+
+
 #endif

data/ext/h8/js_gate.cpp

@@ -0,0 +1,18 @@
+#include "h8.h"
+#include "JsCatcher.h"
+
+using namespace h8;
+
+VALUE JsGate::apply(Local<Value> self, VALUE args) const {
+	H8::Scope scope(h8);
+	long count = RARRAY_LEN(args);
+	Local<Value> *js_args = new Local<Value> [count];
+	for (int i = 0; i < count; i++) {
+		js_args[i] = h8->to_js(rb_ary_entry(args, i));
+	}
+	h8::JsCatcher catcher(h8);
+	Local<Value> result = object()->CallAsFunction(self, count, js_args);
+	catcher.throwIfCaught();
+	delete [] js_args;
+	return h8->to_ruby(result);
+}

data/ext/h8/js_gate.h

@@ -2,6 +2,7 @@
 #define __js_gate_h
 
 #include "h8.h"
+#include "allocated_resource.h"
 
 using namespace v8;
 
@@ -10,7 +11,7 @@ namespace h8 {
 /**
  * Interface to anything that could be converted to a Javascipt object. Provides common helpers.
  */
-class JsValue {
+class JsValue: public AllocatedResource {
 public:
 	virtual Local<Value> value() const = 0;
 
@@ -19,9 +20,10 @@ public:
 	}
 
 	virtual Isolate* isolate() = 0;
+	virtual ~JsValue() {
+	}
 };
 
-
 /**
  * Gates JS object to ruby environment. Holds persistent reference to the source js object until
  * ruby object is recycled (then frees it). Note that this ruby object is not meant to be kept alive
@@ -29,7 +31,7 @@ public:
  *
  * Methods of this class do not need the H8::Scope, they create one internally.
  */
-class JsGate : public JsValue {
+class JsGate: public JsValue {
 public:
 	/**
 	 * Used in the ruby allocator. Do not call unless you know what you do.
@@ -41,14 +43,8 @@ public:
 	 * Return Ruby object that gates specified Handled javascript object. Ruby object
 	 * locks permanently value until get recycled.
 	 */
-	template <class T>
-	static VALUE to_ruby(H8* h8, const Handle<T>& value) {
-	    JsGate *gate;
-	    VALUE ruby_gate = rb_class_new_instance(0, NULL, value_class);
-	    Data_Get_Struct(ruby_gate, JsGate, gate);
-	    gate->set(h8, value);
-	    return ruby_gate;
-	}
+	template<class T>
+	static VALUE to_ruby(H8* h8, const Handle<T>& value);
 
 	/**
 	 * Reset gate to the specified handle.
@@ -57,6 +53,7 @@ public:
 	void set(H8 *h8, const Handle<T>& val) {
 		this->h8 = h8;
 		persistent_value.Reset(h8->getIsolate(), val);
+		h8->add_resource(this);
 	}
 
 	/**
@@ -73,7 +70,7 @@ public:
 	 */
 	VALUE to_i() {
 		H8::Scope scope(h8);
-        return INT2FIX(value()->IntegerValue());
+		return INT2FIX(value()->IntegerValue());
 	}
 
 	/**
@@ -81,7 +78,7 @@ public:
 	 */
 	VALUE to_f() {
 		H8::Scope scope(h8);
-        return DBL2NUM(value()->NumberValue());
+		return DBL2NUM(value()->NumberValue());
 	}
 
 	/**
@@ -89,7 +86,7 @@ public:
 	 */
 	VALUE is_int() {
 		H8::Scope scope(h8);
-        return value()->IsInt32() ? Qtrue : Qfalse;
+		return value()->IsInt32() ? Qtrue : Qfalse;
 	}
 
 	/**
@@ -97,7 +94,7 @@ public:
 	 */
 	VALUE is_float() {
 		H8::Scope scope(h8);
-        return value()->IsNumber() ? Qtrue : Qfalse;
+		return value()->IsNumber() ? Qtrue : Qfalse;
 	}
 
 	/**
@@ -105,7 +102,7 @@ public:
 	 */
 	VALUE is_array() {
 		H8::Scope scope(h8);
-        return value()->IsArray() ? Qtrue : Qfalse;
+		return value()->IsArray() ? Qtrue : Qfalse;
 	}
 
 	/**
@@ -113,7 +110,7 @@ public:
 	 */
 	VALUE is_object() {
 		H8::Scope scope(h8);
-        return value()->IsObject() ? Qtrue : Qfalse;
+		return value()->IsObject() ? Qtrue : Qfalse;
 	}
 
 	/**
@@ -122,7 +119,8 @@ public:
 	 */
 	VALUE get_attribute(VALUE name) {
 		H8::Scope scope(h8);
-		Local<Value> v8_name = v8::String::NewFromUtf8(isolate(), StringValueCStr(name));
+		Local<Value> v8_name = v8::String::NewFromUtf8(isolate(),
+				StringValueCStr(name));
 		return h8->to_ruby(object()->Get(v8_name));
 	}
 
@@ -136,7 +134,7 @@ public:
 	 */
 	VALUE is_string() {
 		H8::Scope scope(h8);
-        return value()->IsString() ? Qtrue : Qfalse;
+		return value()->IsString() ? Qtrue : Qfalse;
 	}
 
 	VALUE is_function() {
@@ -149,6 +147,9 @@ public:
 		return value()->IsUndefined() ? Qtrue : Qfalse;
 	}
 
+	/**
+	 * Call this as function over global context
+	 */
 	VALUE call(VALUE args) const {
 		v8::HandleScope scope(h8->getIsolate());
 		return apply(h8->getContext()->Global(), args);
@@ -159,16 +160,19 @@ public:
 		return apply(h8->gateObject(self), args);
 	}
 
-	VALUE apply(Local<Value> self, VALUE args) const {
-		H8::Scope scope(h8);
-		long count = RARRAY_LEN(args);
-		Local<Value> *js_args = new Local<Value>[count];
-		for (int i = 0; i < count; i++) {
-			js_args[i] = h8->to_js(rb_ary_entry(args, i));
-		}
-		Local<Value> result = object()->CallAsFunction(self, count, js_args);
-		delete[] js_args;
-		return h8->to_ruby(result);
+	VALUE ruby_context() const {
+		return h8->ruby_context();
+	}
+
+	/**
+	 * Call this object as function applying it to the object self
+	 * (which will be this during javascript call)
+	 */
+	VALUE apply(Local<Value> self, VALUE args) const;
+
+	virtual void free() {
+		persistent_value.Reset();
+		AllocatedResource::free();
 	}
 
 	virtual Local<Value> value() const {
@@ -179,7 +183,7 @@ public:
 		return h8->getIsolate();
 	}
 
-	~JsGate() {
+	virtual ~JsGate() {
 		persistent_value.Reset();
 	}
 
@@ -187,10 +191,45 @@ private:
 	friend void rvalue_mark(void* ptr);
 	friend class H8;
 
-	H8 *h8=0;
+	H8 *h8 = 0;
 	Persistent<Value> persistent_value;
 };
 
 }
 
+#include "ruby_gate.h"
+
+template<class T>
+VALUE h8::JsGate::to_ruby(H8* h8, const Handle<T>& value) {
+	// Convert primitives
+	Local<Value> v = value;
+	if (v->IsString()) {
+		H8::Scope scope(h8);
+		String::Utf8Value res(v);
+		return *res ? rb_str_new2(*res) : Qnil;
+	}
+	if (v->IsInt32()) {
+		return INT2FIX(v->Int32Value());
+	}
+	if (v->IsNumber()) {
+		return DBL2NUM(v->NumberValue());
+	}
+	if( v->IsUndefined()) {
+		return Rundefined;
+	}
+	if( v->IsNull() ) {
+		return Qnil;
+	}
+	RubyGate *rg = RubyGate::unwrap(v.As<v8::Object>());
+	if( rg ) {
+		return rg->rubyObject();
+	}
+	JsGate *gate;
+	VALUE ruby_gate = rb_class_new_instance(0, NULL, value_class);
+	Data_Get_Struct(ruby_gate, JsGate, gate);
+	gate->set(h8, value);
+	return ruby_gate;
+}
+
+
 #endif