h8 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 342d8b09078eb9d8601e80c49e49550eb3d179d8
-  data.tar.gz: bf0f41dc3286c9f67a04266083cc385142dcc2ce
+  metadata.gz: 7353dcd3c307b93e4f7fd68ccbc7af260e51d09c
+  data.tar.gz: 8603a9cfb342305c5dfcf156bf92d595bde23a34
 SHA512:
-  metadata.gz: 66763287432f0694d92ec467f0b96c986d528ba58321b16674200e7c1815d4f39a1ca6bdb2cab986f7e2de822359d42391458a27c8295d46ac35943383915b67
-  data.tar.gz: 3ec3557325aece0f43ccedc11cf1475ef867fe6b15a508f256328fcc6ecdb0e1837565c4129b78439a69a7a19f41d8f22e4b1746d6ab4652cfc58e5f8750bcaa
+  metadata.gz: 94056bd7b5378d50ceefd3322479e38b3eb122ee019a0c4ce4a9531bb447fa062e26393c4a5738d97138eaf973a6627b55002126850133fe59c6a9b652028c96
+  data.tar.gz: b1a98f23583bc8cb77ffd35bae2cb1f3d71ea6b9e6f6553149ee2162b468ff9474654d6069d5aa68bb8c0cd97713b26caa24b08604f4b52bbd8b8cca92cc5eb5

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/README.md

@@ -1,11 +1,30 @@
-# Hybrid8
+# Hybrid8, aka H8
 
-_Warning_ this gem is not yet functional. Please do not try to use until versions >= 0.1.0! 
+_Warning_ this gem has yet limited functionality and is under main development. Versions suitable
+for an open beta test will start from 0.1.*.
 
-Therubyracer gem alternative to work with ruby 2.1+ in multithreaded environment.
+Therubyracer gem alternative to effectively work with ruby 2.1+ in multithreaded environment in an
+effective and GC-safe way. Should be out of the box replacement for most scenarios.
+
+Special features:
+
+- care about wrapped Ruby objects lifespan (are kept until either ruby or javascript context
+reference wrapped object). In no way GC will not reclaim ruby object that is in use by the
+javascript context
+
+- care about wrapped Javascript objects lifetime the same. Referenced JS items will not be recycled
+while there are ruby objects referencing it. It also means that once created H8::Context will not
+be reclaimed as long as there is at least one active wrapped object returned from the script.
 
 ## Installation
 
+### Prerequisites
+
+You should have installed libv8, use latest version with v8::Isolate and v8::Locker. This version
+may not find you installation, contact me if you have problems, I'll tune it up.
+
+### Setting up
+
 Add this line to your application's Gemfile:
 
     gem 'hybrid8'
@@ -20,10 +39,55 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+Is generally like therubyracer gem. Create context, set variables, run scripts.
+
+    require 'h8'
+
+    res = H8::Context.eval "({foo: 'hello', bar: 'world'});"
+    puts "#{res.foo} #{res.bar}"
+
+another way to access attributes:
+
+    puts res['foo']
+
+The same works with arrays:
+
+    res = H8::Context.eval "['foo', bar'];"
+    puts res[1]
+
+To set context variables:
+
+    cxt = H8::Context.new some: 'value'
+    cxt[:pi] = 3.1415
+
+You can return function and call it from ruby:
+
+    fun = cxt.eval "(function pi_n(n) { return pi * n; })"
+    p fun(2)
+
+The same you can return objects and call its member functions - if a member is a function,
+it will be called with given arguments:
+
+    res = H8::Context.eval <<-End
+      function cls(base) {
+        this.base = base;
+        this.someVal = 'hello!';
+        this.noArgs = function() { return 'world!'};
+        this.doAdd = function(a, b) {
+          return a + b + base;
+        }
+      }
+      new cls(100);
+    End
+    res.someVal.should == 'hello!'
+    res.noArgs.should == 'world!'
+    res.doAdd(10, 1).should == 111
 
 ## Contributing
 
+Note that at this early point of development you better first talk to me to not to reinvent the
+wheel.
+
 1. Fork it ( https://github.com/[my-github-username]/hybrid8/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)

data/ext/h8/extconf.rb

@@ -21,21 +21,23 @@ abort 'missing malloc()' unless have_func 'malloc'
 abort 'missing free()' unless have_func 'free'
 
 # Give it a name
-extension_name = 'hybrid8'
+extension_name = 'h8'
 
+dir_config('v8', '/Users/sergeych/dev/v8', '/Users/sergeych/dev/v8/lib')
 
 dir_config(extension_name)
 ok = true
 
-# unless have_header('gmp.h')
-#   $stderr.puts "can't find gmp.h, try --with-gmp-include=<path>"
-#   ok = false
-# end
-#
-# unless have_library('gmp', '__gmpz_init')
-#   $stderr.puts "can't find -lgmp, try --with-gmp-lib=<path>"
-#   ok = false
-# end
+unless have_header('include/v8.h')
+  $stderr.puts "can't find v8.h, install libv8 3.25.30+ first"
+  ok = false
+end
+
+unless have_library('v8_base') && have_library('v8_snapshot') && have_library('v8_libplatform') \
+  && have_library('v8_libbase') && have_library('icuuc') && have_library('icudata')
+  $stderr.puts "can't find libv8"
+  ok = false
+end
 
 
 # This test is actually due to a Clang 3.3 shortcoming, included in OS X 10.9,
@@ -60,3 +62,20 @@ else
   raise "Unable to build, correct above errors and rerun"
 end
 
+# LIBV8_COMPATIBILITY = '~> 3.30'
+#
+# begin
+#   require 'rubygems'
+#   gem 'libv8', LIBV8_COMPATIBILITY
+# rescue Gem::LoadError
+#   warn "Warning! Unable to load libv8 #{LIBV8_COMPATIBILITY}."
+# rescue LoadError
+#   warn "Warning! Could not load rubygems. Please make sure you have libv8 #{LIBV8_COMPATIBILITY} installed."
+# ensure
+#   require 'libv8'
+# end
+#
+# Libv8.configure_makefile
+
+create_makefile('h8/h8')
+

data/ext/h8/h8.cpp

@@ -0,0 +1,16 @@
+#include "h8.h"
+
+Local<Value> h8::H8::gateObject(VALUE ruby_value) const {
+	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
+			return gate->value();
+	}
+	rb_raise(h8_exception, "Object gate is not implemented");
+	return Undefined(isolate);
+}

data/ext/h8/h8.h

@@ -0,0 +1,159 @@
+#ifndef _h8_h
+#define _h8_h
+
+#include <include/v8.h>
+#include <ruby.h>
+#include <iostream>
+
+using namespace v8;
+using namespace std;
+
+extern VALUE h8_exception;
+extern VALUE h8_class;
+extern VALUE value_class;
+
+extern ID id_is_a;
+
+//#include <ruby/thread.h>
+
+namespace h8 {
+
+template<class T> inline void t(const T& x) {
+	cout << x << endl << flush;
+}
+
+class H8 {
+public:
+
+	class Scope: public HandleScope {
+		v8::Isolate::Scope isolate_scope;
+		v8::Context::Scope context_scope;
+		H8* rcontext;
+	public:
+		Scope(H8* cxt) :
+				HandleScope(cxt->getIsolate()), isolate_scope(
+						cxt->getIsolate()), context_scope(cxt->getContext()), rcontext(
+						cxt) {
+		}
+	};
+
+	static void init();
+
+	H8() {
+		isolate = Isolate::New();
+		Isolate::Scope isolate_scope(isolate);
+		HandleScope handle_scope(isolate);
+
+		v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(
+				isolate);
+		v8::Handle<v8::Context> context = v8::Context::New(isolate, NULL,
+				global);
+		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) {
+		// TODO: throw ruby exception on error
+		return to_ruby(eval(script_utf));
+	}
+
+	Handle<Context> getContext() {
+		return Local<Context>::New(isolate, persistent_context);
+	}
+
+	bool isError() const {
+		return is_error;
+	}
+
+	Isolate* getIsolate() const {
+		return isolate;
+	}
+
+	VALUE to_ruby(Handle<Value> value);
+
+	v8::Local<v8::String> js(VALUE val) const {
+		return js(StringValueCStr(val));
+	}
+
+	v8::Local<v8::String> js(const char* str) const {
+		return v8::String::NewFromUtf8(isolate, str);
+	}
+
+	void set_var(VALUE name, VALUE value) {
+		Scope scope(this);
+		getContext()->Global()->Set(js(name), to_js(value));
+	}
+
+	Local<Value> to_js(VALUE ruby_value) const {
+		switch (TYPE(ruby_value)) {
+		case T_STRING:
+			return js(ruby_value);
+		case T_FIXNUM:
+			return v8::Int32::New(isolate, FIX2INT(ruby_value));
+		case T_FLOAT:
+			return v8::Number::New(isolate, NUM2DBL(ruby_value));
+		case T_DATA:
+		case T_OBJECT:
+			return gateObject(ruby_value);
+		default:
+			rb_raise(h8_exception, "can't gate to js: unknown type");
+		}
+		return Undefined(isolate);
+	}
+
+	Local<Value> gateObject(VALUE object) const;
+
+	virtual ~H8() {
+		persistent_context.Reset();
+	}
+
+private:
+	friend VALUE context_alloc(VALUE klass);
+	friend void rvalue_mark(void* ptr);
+
+	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;
+};
+// Context
+}
+
+typedef VALUE (*ruby_method)(...);
+
+#include "js_gate.h"
+
+inline VALUE h8::H8::to_ruby(Handle<Value> value) {
+	return JsGate::to_ruby(this, value);
+}
+
+#endif

data/ext/h8/js_gate.h

@@ -0,0 +1,196 @@
+#ifndef __js_gate_h
+#define __js_gate_h
+
+#include "h8.h"
+
+using namespace v8;
+
+namespace h8 {
+
+/**
+ * Interface to anything that could be converted to a Javascipt object. Provides common helpers.
+ */
+class JsValue {
+public:
+	virtual Local<Value> value() const = 0;
+
+	Local<Object> object() const {
+		return value()->ToObject();
+	}
+
+	virtual Isolate* isolate() = 0;
+};
+
+
+/**
+ * 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
+ * by the H8 instance, instead, its owner should.
+ *
+ * Methods of this class do not need the H8::Scope, they create one internally.
+ */
+class JsGate : public JsValue {
+public:
+	/**
+	 * Used in the ruby allocator. Do not call unless you know what you do.
+	 */
+	JsGate() {
+	}
+
+	/**
+	 * 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;
+	}
+
+	/**
+	 * Reset gate to the specified handle.
+	 */
+	template<class T>
+	void set(H8 *h8, const Handle<T>& val) {
+		this->h8 = h8;
+		persistent_value.Reset(h8->getIsolate(), val);
+	}
+
+	/**
+	 * Get ruby string representation
+	 */
+	VALUE to_s() {
+		H8::Scope scope(h8);
+		String::Utf8Value res(value());
+		return *res ? rb_str_new2(*res) : Qnil;
+	}
+
+	/**
+	 * Get ruby integer representation (FIXNUM)
+	 */
+	VALUE to_i() {
+		H8::Scope scope(h8);
+        return INT2FIX(value()->IntegerValue());
+	}
+
+	/**
+	 * Get ruby Float representation (FIXNUM)
+	 */
+	VALUE to_f() {
+		H8::Scope scope(h8);
+        return DBL2NUM(value()->NumberValue());
+	}
+
+	/**
+	 * @return true if the object is a primitive integer
+	 */
+	VALUE is_int() {
+		H8::Scope scope(h8);
+        return value()->IsInt32() ? Qtrue : Qfalse;
+	}
+
+	/**
+	 * @return true if the object is a primitive float
+	 */
+	VALUE is_float() {
+		H8::Scope scope(h8);
+        return value()->IsNumber() ? Qtrue : Qfalse;
+	}
+
+	/**
+	 * @return true if the object is an array
+	 */
+	VALUE is_array() {
+		H8::Scope scope(h8);
+        return value()->IsArray() ? Qtrue : Qfalse;
+	}
+
+	/**
+	 * @return true if the object is an object
+	 */
+	VALUE is_object() {
+		H8::Scope scope(h8);
+        return value()->IsObject() ? Qtrue : Qfalse;
+	}
+
+	/**
+	 * Retreive JS object attribute and convert it to the ruby wrapper
+	 * of the new JsGate instace.
+	 */
+	VALUE get_attribute(VALUE name) {
+		H8::Scope scope(h8);
+		Local<Value> v8_name = v8::String::NewFromUtf8(isolate(), StringValueCStr(name));
+		return h8->to_ruby(object()->Get(v8_name));
+	}
+
+	VALUE get_index(VALUE index) {
+		H8::Scope scope(h8);
+		return h8->to_ruby(object()->Get(NUM2INT(index)));
+	}
+
+	/**
+	 * @return true if the object is a primitive string
+	 */
+	VALUE is_string() {
+		H8::Scope scope(h8);
+        return value()->IsString() ? Qtrue : Qfalse;
+	}
+
+	VALUE is_function() {
+		H8::Scope scope(h8);
+		return value()->IsFunction();
+	}
+
+	VALUE is_undefined() {
+		H8::Scope scope(h8);
+		return value()->IsUndefined() ? Qtrue : Qfalse;
+	}
+
+	VALUE call(VALUE args) const {
+		v8::HandleScope scope(h8->getIsolate());
+		return apply(h8->getContext()->Global(), args);
+	}
+
+	VALUE apply(VALUE self, VALUE args) const {
+		v8::HandleScope scope(h8->getIsolate());
+		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);
+	}
+
+	virtual Local<Value> value() const {
+		return Local<Value>::New(h8->getIsolate(), persistent_value);
+	}
+
+	virtual Isolate* isolate() {
+		return h8->getIsolate();
+	}
+
+	~JsGate() {
+		persistent_value.Reset();
+	}
+
+private:
+	friend void rvalue_mark(void* ptr);
+	friend class H8;
+
+	H8 *h8=0;
+	Persistent<Value> persistent_value;
+};
+
+}
+
+#endif