h8 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38c8f3b25b694cb718a7be51eb9ad7cdb3796d7a
-  data.tar.gz: 548f468f6a4dec9f63bd5de2fe6eff950a51b5b2
+  metadata.gz: 62539324e412e959064c165f17099c2f688eca44
+  data.tar.gz: bfcbcf2ed6018b7a6704f5dcf70a57bcb9482b66
 SHA512:
-  metadata.gz: 63ab563ae77b67b5b2a89e545e350736a6fc34a0ff22b7a74d796ce102c8bf98486c71201712e42275b0dbe1901f7473367cc772cb504da1fe0b99cb793dbaa6
-  data.tar.gz: d6a50a1bb8f933027f920fcca11be972922d6744ea95174409e99431a3255d1af34519d2d751b2cc51ecfadd0804cc6e153e1635c15b9eaa32ad4f56ed3f69c0
+  metadata.gz: bee24241453a7b41afda2cef2ae636abf2fb4290697d5c9bb1e11f8092e07a0da59387ca6f41a3f8c48df4b349c64bd27a768348714c0b0191c1cd75a6c93ffa
+  data.tar.gz: 0f7ced45565b634b5e7f3a67819ec390fa6960f14d5004c9a298891be7d6d53f91cda8831d47f5902bddf61ee5205ca05a30709156bf89ef229d2236bfdc1ea2

data/ext/h8/h8.cpp

@@ -47,6 +47,39 @@ void h8::JsTimeoutError::raise() const {
 	rb_raise(js_timeout_exception, "timeout expired");
 }
 
+h8::H8::H8()
+: self(Qnil)
+{
+	isolate = Isolate::New();
+	Locker l(isolate);
+	Isolate::Scope isolate_scope(isolate);
+	HandleScope handle_scope(isolate);
+	isolate->SetCaptureStackTraceForUncaughtExceptions(true);
+
+	isolate->SetData(0, this);
+
+	v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(
+			isolate);
+
+	// Set up RubyGate in JS context
+	Local<FunctionTemplate> ft = v8::FunctionTemplate::New(isolate,RubyGate::GateConstructor);
+	ft->SetClassName(js("RubyGate"));
+	Local<ObjectTemplate> templ = ft->InstanceTemplate();
+
+	templ->SetInternalFieldCount(2);
+	templ->SetCallAsFunctionHandler(&RubyGate::ObjectCallback);
+	templ->SetNamedPropertyHandler(RubyGate::mapGet, RubyGate::mapSet);
+	templ->SetIndexedPropertyHandler(RubyGate::indexGet, RubyGate::indexSet);
+
+	global->Set(isolate, "RubyGate", ft);
+
+	v8::Handle<v8::Context> context = v8::Context::New(isolate, NULL,
+			global);
+	persistent_context.Reset(isolate, context);
+	gate_function.Reset(isolate,ft);
+}
+
+
 Local<Value> h8::H8::gateObject(VALUE ruby_value) {
 	if ( Qtrue == rb_funcall(ruby_value, id_is_a, 1, value_class)) {
 		JsGate *gate;
@@ -59,8 +92,35 @@ Local<Value> h8::H8::gateObject(VALUE ruby_value) {
 	if( ruby_value == Rundefined )
 		return v8::Undefined(isolate);
 	// Generic Ruby object
-	RubyGate *gate = new RubyGate(this, ruby_value);
-	return gate->handle(isolate);
+//	RubyGate *gate = new RubyGate(this, ruby_value);
+//	return gate->handle(isolate);
+	// Generic ruby object - new logic
+	assert( sizeof(VALUE) <= sizeof(void*) );
+	Local<Value> wrapped_ruby_value = External::New(isolate, (void*)ruby_value);
+	return getGateFunction()->GetFunction()->CallAsConstructor(1, &wrapped_ruby_value);
+}
+
+void h8::H8::gate_class(VALUE name,VALUE callable) {
+	Scope scope(this);
+
+	Local<Object> global = getContext()->Global();
+
+	Local<FunctionTemplate> ft = v8::FunctionTemplate::New(isolate,
+			RubyGate::ClassGateConstructor,
+			to_js(callable)
+			);
+	Local<String> class_name = js(name);
+	ft->SetClassName(class_name);
+	ft->Inherit(getGateFunction());
+
+	Local<ObjectTemplate> templ = ft->InstanceTemplate();
+
+	templ->SetInternalFieldCount(2);
+	templ->SetCallAsFunctionHandler(&RubyGate::ObjectCallback);
+	templ->SetNamedPropertyHandler(RubyGate::mapGet, RubyGate::mapSet);
+	templ->SetIndexedPropertyHandler(RubyGate::indexGet, RubyGate::indexSet);
+
+	global->Set(class_name, ft->GetFunction());
 }
 
 void h8::H8::ruby_mark_gc() const {
@@ -152,6 +212,7 @@ h8::H8::~H8() {
 			resources.peek_first<AllocatedResource>()->free();
 		}
 		persistent_context.Reset();
+		gate_function.Reset();
 	}
 	isolate->Dispose();
 }

data/ext/h8/h8.h

@@ -103,20 +103,7 @@ public:
 
 	static void init();
 
-	H8() :
-			self(Qnil) {
-		isolate = Isolate::New();
-		Locker l(isolate);
-		Isolate::Scope isolate_scope(isolate);
-		HandleScope handle_scope(isolate);
-		isolate->SetCaptureStackTraceForUncaughtExceptions(true);
-
-		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);
-	}
+	H8();
 
 	/**
 	 * Evaluate javascript.
@@ -139,6 +126,10 @@ public:
 		return Local<Context>::New(isolate, persistent_context);
 	}
 
+	Handle<FunctionTemplate> getGateFunction() {
+		return Local<FunctionTemplate>::New(isolate, gate_function);
+	}
+
 	bool isError() const {
 		return is_error;
 	}
@@ -147,6 +138,8 @@ public:
 		return isolate;
 	}
 
+	void gate_class(VALUE name, VALUE proc);
+
 	VALUE to_ruby(Handle<Value> value);
 
 	v8::Local<v8::String> js(VALUE val) const {
@@ -236,6 +229,7 @@ private:
 	VALUE self;
 
 	Persistent<Context> persistent_context;
+	Persistent<FunctionTemplate> gate_function;
 
 	bool is_error = false;
 	bool gvl_released = false;

data/ext/h8/main.cpp

@@ -148,6 +148,13 @@ static VALUE context_set_var(VALUE self, VALUE name, VALUE value) {
 	});
 }
 
+static VALUE context_gate_class(VALUE self, VALUE name, VALUE lambda) {
+	return protect_ruby([&] {
+		rc(self)->gate_class(name, lambda);
+		return Qnil;
+	});
+}
+
 static VALUE context_force_gc(VALUE self) {
 	rc(self)->gc();
 	return Qnil;
@@ -191,6 +198,8 @@ void Init_h8(void) {
 	rb_define_method(context_class, "_eval", (ruby_method) context_eval, 3);
 	rb_define_method(context_class, "_set_var", (ruby_method) context_set_var,
 			2);
+	rb_define_method(context_class, "_gate_class", (ruby_method) context_gate_class,
+			2);
 	rb_define_method(context_class, "javascript_gc",
 			(ruby_method) context_force_gc, 0);
 

data/ext/h8/ruby_gate.cpp

@@ -13,8 +13,7 @@ static void* unblock_caller(void *param) {
 	return NULL;
 }
 
-static void with_gvl(RubyGate *gate, const std::function<void(void)> &block) {
-	H8 *h8 = gate->getH8();
+static void with_gvl(H8 *h8, const std::function<void(void)> &block) {
 	if (h8->isGvlReleased()) {
 		h8->setGvlReleased(false);
 		rb_thread_call_with_gvl(unblock_caller, (void*) &block);
@@ -23,22 +22,65 @@ static void with_gvl(RubyGate *gate, const std::function<void(void)> &block) {
 		block();
 }
 
-h8::RubyGate::RubyGate(H8* _context, VALUE object) :
+static void with_gvl(RubyGate *gate, const std::function<void(void)> &block) {
+	with_gvl(gate->getH8(), block);
+}
+
+void h8::RubyGate::ClassGateConstructor(
+		const v8::FunctionCallbackInfo<Value>& args) {
+	Isolate *isolate = args.GetIsolate();
+	H8* h8 = (H8*) isolate->GetData(0);
+	assert(!args.Data().IsEmpty());
+
+	RubyGate *lambda = RubyGate::unwrap(args.Data().As<Object>());
+	assert(lambda != 0);
+
+	with_gvl(h8, [&] {
+		VALUE rb_args = ruby_args(h8, args, 1);
+		rb_ary_push(rb_args, lambda->ruby_object);
+		// Object creating ruby code can raise exceptions:
+		lambda->rescued_call(
+				rb_args,
+				call,
+				[&] (VALUE res) {
+					new RubyGate(h8, args.This(), res);
+				});
+	});
+	args.GetReturnValue().Set(args.This());
+}
+
+void h8::RubyGate::GateConstructor(
+		const v8::FunctionCallbackInfo<Value>& args) {
+	Isolate *isolate = args.GetIsolate();
+	H8* h8 = (H8*) isolate->GetData(0);
+	assert(args.Length() == 1);
+	Local<Value> val = args[0];
+	VALUE ruby_object = Qnil;
+
+	if (val->IsExternal())
+		ruby_object = (VALUE) val.As<External>()->Value(); // External::Cast(*val)->Value();
+	else {
+		assert(val->IsObject());
+		puts("val is object");
+		RubyGate *rg = RubyGate::unwrap(val.As<Object>());
+		puts("Hurray - unwrap");
+		assert(rg != 0);
+		puts("Hurray - not 0");
+		ruby_object = rg->ruby_object;
+		char* ss = StringValueCStr(ruby_object);
+		rb_warn("Object passed %s\n", ss);
+	}
+
+	new RubyGate(h8, args.This(), ruby_object);
+	args.GetReturnValue().Set(args.This());
+}
+
+h8::RubyGate::RubyGate(H8* _context, Handle<Object> instance, 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(RubyGate::mapGet, RubyGate::mapSet);
-	templ->SetIndexedPropertyHandler(RubyGate::indexGet, RubyGate::indexSet);
-
-	v8::Handle<v8::Object> handle = templ->NewInstance();
-	handle->SetAlignedPointerInInternalField(1, RUBYGATE_ID);
-	Wrap(handle);
+	instance->SetAlignedPointerInInternalField(1, RUBYGATE_ID);
+	Wrap(instance);
 }
 
 void h8::RubyGate::mapGet(Local<String> name,
@@ -118,26 +160,25 @@ void h8::RubyGate::rescued_call(VALUE rb_args, VALUE (*call)(VALUE),
 		// exceptions...
 		try {
 			block(res);
-		}
-		catch(JsError& e) {
+		} catch (JsError& e) {
 			Local<v8::Object> error = v8::Exception::Error(
 					context->js(e.what())).As<v8::Object>();
 			context->getIsolate()->ThrowException(error);
-		}
-		catch(...) {
-			Local<v8::Object> error = v8::Exception::Error(
-					context->js("unknown exception (inner bug)")).As<v8::Object>();
+		} catch (...) {
+			Local<v8::Object> error =
+					v8::Exception::Error(
+							context->js("unknown exception (inner bug)")).As<
+							v8::Object>();
 			context->getIsolate()->ThrowException(error);
 		}
-	}
-	else
+	} else
 		throw_js();
 }
 
 void h8::RubyGate::doObjectCallback(
 		const v8::FunctionCallbackInfo<v8::Value>& args) {
 	with_gvl(this, [&] {
-		VALUE rb_args = ruby_args(args, 1);
+		VALUE rb_args = ruby_args(context, args, 1);
 		rb_ary_push(rb_args, ruby_object);
 		rescued_call(rb_args, call, [&] (VALUE res) {
 					args.GetReturnValue().Set(context->to_js(res));

data/ext/h8/ruby_gate.h

@@ -18,7 +18,7 @@ namespace h8 {
  */
 class RubyGate: public ObjectWrap, public AllocatedResource {
 public:
-	RubyGate(H8* _context, VALUE object);
+	RubyGate(H8* _context, Handle<Object> instance, VALUE object);
 
 	/**
 	 * Check the handle and unwrap the RubyGate if it is wrapped
@@ -77,7 +77,7 @@ protected:
 	 * extra slots in array if need
 	 */
 	template<class T>
-	VALUE ruby_args(const T& args, unsigned extras = 0) {
+	static VALUE ruby_args(H8* context,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++)
@@ -110,6 +110,9 @@ protected:
 	void getIndex(uint32_t index, const PropertyCallbackInfo<Value> &info);
 	void setIndex(uint32_t index, Local<Value> value,
 			const PropertyCallbackInfo<Value> &info);
+
+	static void GateConstructor(const v8::FunctionCallbackInfo<Value>& args);
+	static void ClassGateConstructor(const v8::FunctionCallbackInfo<Value>& args);
 private:
 
 	void doObjectCallback(const v8::FunctionCallbackInfo<v8::Value>& args);

data/lib/h8/context.rb

@@ -7,7 +7,7 @@ module H8
       @idcount = 0
       set_all **kwargs
       _set_var '___create_ruby_class', -> (cls, args) {
-        _do_cretate_ruby_class cls, args
+        _do_create_ruby_class cls, args
       }
     end
 
@@ -102,13 +102,7 @@ module H8
     # in which case constructor function will be created
     def set_var name, value
       if value.is_a?(Class)
-        clsid = "__ruby_class_#{@idcount += 1}"
-        _set_var clsid, value
-        eval <<-End
-          function #{name.to_s}() {
-            return ___create_ruby_class(#{clsid}, arguments);
-          }
-        End
+        _gate_class name.to_s, -> (*args) { value.new *args }
       else
         _set_var name, value
       end
@@ -116,7 +110,7 @@ module H8
 
     # create class instance passing it arguments stored in javascript 'arguments' object
     # (so it repacks them first)
-    def _do_cretate_ruby_class(klass, arguments)
+    def _do_create_ruby_class(klass, arguments)
       klass.new *H8::arguments_to_a(arguments.to_ruby.values)
     end
   end

data/lib/h8/version.rb

@@ -1,3 +1,3 @@
 module H8
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/spec/ruby_gate_spec.rb

@@ -5,7 +5,7 @@ describe 'ruby gate' do
 
   it 'should gate callables' do
     cxt      = H8::Context.new
-    count = 0
+    count    = 0
     cxt[:fn] = -> (a, b) {
       count += 1
       a + b
@@ -44,8 +44,8 @@ describe 'ruby gate' do
     cxt[:fn] = -> (a, b) {
       a + b
     }
-    res = cxt.eval("fn(11, 22);") { |cxt|
-      cxt[:fn] = -> (a,b) { a - b }
+    res      = cxt.eval("fn(11, 22);") { |cxt|
+      cxt[:fn] = -> (a, b) { a - b }
     }
     res.to_i.should == -11
   end
@@ -62,7 +62,7 @@ describe 'ruby gate' do
 
   it 'should convert nil, true, false and undefined' do
     cxt      = H8::Context.new
-    value = false
+    value    = false
     cxt[:fn] = -> {
       [nil, true, false, value, H8::Undefined]
     }
@@ -82,9 +82,9 @@ describe 'ruby gate' do
   end
 
   it 'should convert strings to native string' do
-    cxt = H8::Context.new
+    cxt       = H8::Context.new
     cxt[:str] = src = "Пример строки"
-    res = 'ПРИМЕР СТРОКИ'
+    res       = 'ПРИМЕР СТРОКИ'
     cxt.eval('str.toLocaleUpperCase()').should == res
     up = cxt.eval('fn = function(t) { return t.toLocaleUpperCase(); }')
     up.call(src).should == res
@@ -151,6 +151,7 @@ describe 'ruby gate' do
     expect(-> {
       res = cxt.eval <<-End
       result = fn(11, 22);
+      throw Error("It should not happen");
       End
     }).to raise_error(MyException) { |e|
             e.message.should == 'Shit happens'
@@ -174,7 +175,7 @@ describe 'ruby gate' do
       End
       fail 'did not raise error'
     rescue H8::JsError => e
-      x  = e.javascript_error
+      x = e.javascript_error
       e.name.should == 'Error'
       e.message.should =~ /test/
       e.javascript_backtrace.should =~ /at bad \(eval\:4\:17\)/
@@ -251,6 +252,7 @@ describe 'ruby gate' do
       cxt.eval('foo.priv_method').should == H8::Undefined
       cxt.eval('foo.test_args').should be_kind_of(Proc)
       cxt.eval('foo.test_args("hi", "you")').should == 'hi-you'
+      cxt.eval('foo instanceof RubyGate').should == true
     end
 
     it 'should set ruby properties' do
@@ -342,12 +344,12 @@ describe 'ruby gate' do
     end
 
     it 'should pass varargs' do
-      cxt = H8::Context.new
+      cxt        = H8::Context.new
       cxt[:test] = -> (args) {
         # Sample how to deal with javascript 'arguments' vararg object:
         H8::arguments_to_a(args).join(',')
       }
-      res = cxt.eval <<-End
+      res        = cxt.eval <<-End
         function test2() {
           return test(arguments);
         }
@@ -356,6 +358,19 @@ describe 'ruby gate' do
       res.should == '1,2,ho'
     end
 
+    it 'should gate classes through API' do
+      c = H8::Context.new
+      la = -> (*args) {
+        { 'hello' => 'world'}
+      }
+      c._gate_class 'Tec', la
+      c.eval("var res = new Tec()")
+      c.eval('res').should == { 'hello' => 'world' }
+      c.eval("res['hello']").should == 'world'
+      c.eval('res instanceof Tec').should == true
+      c.eval('res instanceof RubyGate').should == true
+    end
+
     it 'should gate classes' do
       class Gated
         attr :init_args
@@ -363,15 +378,25 @@ describe 'ruby gate' do
         def initialize *args
           @init_args = args
         end
+
+        def inspect
+          "Gated<#{@init_args.inspect}>"
+        end
+
+        def to_str
+          inspect
+        end
       end
 
       cxt = H8::Context.new RClass: Gated
-      c = cxt.eval 'new RClass()'
+      c   = cxt.eval 'new RClass()'
       c.should be_a(Gated)
       c.init_args.should == []
 
       c = cxt.eval 'rc = new RClass("hello", "world")'
       c.should be_a(Gated)
+      cxt.eval('rc instanceof RubyGate').should == true
+      cxt.eval('new RClass() instanceof RClass').should == true
       c.init_args.should == ['hello', 'world']
       cxt.eval('rc.init_args').should == ['hello', 'world']
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: h8
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - sergeych
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-19 00:00:00.000000000 Z
+date: 2015-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler