h8 0.4.0 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 62539324e412e959064c165f17099c2f688eca44
-  data.tar.gz: bfcbcf2ed6018b7a6704f5dcf70a57bcb9482b66
+  metadata.gz: da7dc92fe9f18d03e202dbd8566c5469f3b122b2
+  data.tar.gz: 4c570745ab23ac22f705405742ff10b7fb9310df
 SHA512:
-  metadata.gz: bee24241453a7b41afda2cef2ae636abf2fb4290697d5c9bb1e11f8092e07a0da59387ca6f41a3f8c48df4b349c64bd27a768348714c0b0191c1cd75a6c93ffa
-  data.tar.gz: 0f7ced45565b634b5e7f3a67819ec390fa6960f14d5004c9a298891be7d6d53f91cda8831d47f5902bddf61ee5205ca05a30709156bf89ef229d2236bfdc1ea2
+  metadata.gz: 3eade24933e29d3d5b124b4665a3eef82e4e6dee3cde4a7e62c1a5f68acf08ee5d060bdaa1f7a61eeedd53aea417b751618d847ffd67dd8f75dddbdd32f5cc56
+  data.tar.gz: 90c14a2a879418134c41ce3958ce8b943cc5d86285811657e280af079e3802d275e1156860f6af4f3f664515ec37f19e9a51d07d8914a8e5eaa5c03218d20026

data/ext/h8/h8.cpp

@@ -71,12 +71,18 @@ h8::H8::H8()
 	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);
+
+	v8::Context::Scope cs(context);
+
+	Local<Function> fn = ft->GetFunction();
+
+	context->Global()->Set(js("RubyGate"), fn);
+
 	persistent_context.Reset(isolate, context);
-	gate_function.Reset(isolate,ft);
+	gate_function_template.Reset(isolate,ft);
+	gate_function.Reset(isolate,fn);
 }
 
 
@@ -91,13 +97,15 @@ 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);
 	// Generic ruby object - new logic
 	assert( sizeof(VALUE) <= sizeof(void*) );
+
+	RubyGate *gate = find_gate(ruby_value);
+	if( gate )
+		return gate->handle();
+
 	Local<Value> wrapped_ruby_value = External::New(isolate, (void*)ruby_value);
-	return getGateFunction()->GetFunction()->CallAsConstructor(1, &wrapped_ruby_value);
+	return getGateFunction()->CallAsConstructor(1, &wrapped_ruby_value);
 }
 
 void h8::H8::gate_class(VALUE name,VALUE callable) {
@@ -111,7 +119,7 @@ void h8::H8::gate_class(VALUE name,VALUE callable) {
 			);
 	Local<String> class_name = js(name);
 	ft->SetClassName(class_name);
-	ft->Inherit(getGateFunction());
+	ft->Inherit(getGateFunctionTemplate());
 
 	Local<ObjectTemplate> templ = ft->InstanceTemplate();
 
@@ -165,6 +173,23 @@ void h8::H8::invoke(v8::Handle<v8::Script> script, Local<Value>& result) {
 #endif
 }
 
+void h8::H8::register_ruby_gate(RubyGate* gate) {
+	add_resource(gate);
+	id_map.insert(std::pair<VALUE,RubyGate*>(gate->ruby_object, gate));
+}
+
+void h8::H8::unregister_ruby_gate(RubyGate* gate) {
+	add_resource(gate);
+	id_map.erase(gate->ruby_object);
+}
+
+h8::RubyGate* h8::H8::find_gate(VALUE rb_object) {
+	auto it = id_map.find(rb_object);
+	if( it == id_map.end() )
+		return 0;
+	return it->second;
+}
+
 v8::Handle<v8::Value> h8::H8::eval(const char* script_utf, unsigned max_ms,const char* source_name) {
 	v8::EscapableHandleScope escape(isolate);
 	Local<Value> result;
@@ -213,6 +238,7 @@ h8::H8::~H8() {
 		}
 		persistent_context.Reset();
 		gate_function.Reset();
+		gate_function_template.Reset();
 	}
 	isolate->Dispose();
 }

data/ext/h8/h8.h

@@ -5,6 +5,8 @@
 #include <ruby.h>
 #include <iostream>
 #include <exception>
+#include <map>
+
 #include "allocated_resource.h"
 #include "js_catcher.h"
 
@@ -126,8 +128,12 @@ public:
 		return Local<Context>::New(isolate, persistent_context);
 	}
 
-	Handle<FunctionTemplate> getGateFunction() {
-		return Local<FunctionTemplate>::New(isolate, gate_function);
+	Handle<FunctionTemplate> getGateFunctionTemplate() {
+		return Local<FunctionTemplate>::New(isolate, gate_function_template);
+	}
+
+	Handle<Function> getGateFunction() {
+		return Local<Function>::New(isolate, gate_function);
 	}
 
 	bool isError() const {
@@ -219,6 +225,10 @@ public:
 		return rb_interrupted;
 	}
 
+	void register_ruby_gate(RubyGate* gate);
+	void unregister_ruby_gate(RubyGate* gate);
+	RubyGate *find_gate(VALUE rb_object);
+
 	virtual ~H8();
 
 private:
@@ -229,13 +239,15 @@ private:
 	VALUE self;
 
 	Persistent<Context> persistent_context;
-	Persistent<FunctionTemplate> gate_function;
+	Persistent<FunctionTemplate> gate_function_template;
+	Persistent<Function> gate_function;
 
 	bool is_error = false;
 	bool gvl_released = false;
 	bool rb_interrupted = false;
 
 	chain resources;
+	std::map<VALUE,RubyGate*> id_map;
 };
 // Context
 }

data/ext/h8/ruby_gate.cpp

@@ -36,16 +36,17 @@ void h8::RubyGate::ClassGateConstructor(
 	assert(lambda != 0);
 
 	with_gvl(h8, [&] {
-		VALUE rb_args = ruby_args(h8, args, 1);
+		VALUE rb_args = ruby_args(h8, args, 2);
+		rb_ary_push(rb_args, h8->ruby_context());
 		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);
-				});
-	});
+			lambda->rescued_call(
+					rb_args,
+					call,
+					[&] (VALUE res) {
+						new RubyGate(h8, args.This(), res);
+					});
+		});
 	args.GetReturnValue().Set(args.This());
 }
 
@@ -57,19 +58,8 @@ void h8::RubyGate::GateConstructor(
 	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);
-	}
+	assert(val->IsExternal());
+	ruby_object = (VALUE) val.As<External>()->Value(); // External::Cast(*val)->Value();
 
 	new RubyGate(h8, args.This(), ruby_object);
 	args.GetReturnValue().Set(args.This());
@@ -78,16 +68,21 @@ void h8::RubyGate::GateConstructor(
 h8::RubyGate::RubyGate(H8* _context, Handle<Object> instance, VALUE object) :
 		context(_context), ruby_object(object), next(0), prev(0) {
 	v8::HandleScope scope(context->getIsolate());
-	context->add_resource(this);
+	context->register_ruby_gate(this);
 	instance->SetAlignedPointerInInternalField(1, RUBYGATE_ID);
 	Wrap(instance);
 }
 
 void h8::RubyGate::mapGet(Local<String> name,
 		const PropertyCallbackInfo<Value> &info) {
-	RubyGate *rg = RubyGate::unwrap(info.This());
-	assert(rg != 0);
-	rg->getProperty(name, info);
+	Local<Value> loc = info.This()->GetRealNamedPropertyInPrototypeChain(name);
+	if (!loc.IsEmpty())
+		info.GetReturnValue().Set(loc);
+	else {
+		RubyGate *rg = RubyGate::unwrap(info.This());
+		assert(rg != 0);
+		rg->getProperty(name, info);
+	}
 }
 
 void h8::RubyGate::mapSet(Local<String> name, Local<Value> value,
@@ -128,7 +123,9 @@ VALUE h8::RubyGate::rescue_callback(VALUE me, VALUE exception_object) {
 
 VALUE RubyGate::call(VALUE args) {
 	VALUE callable = rb_ary_pop(args);
-	return rb_proc_call(callable, args);
+	VALUE context = rb_ary_pop(args);
+	VALUE res = rb_funcall(context, rb_intern("safe_proc_call"), 2, callable, args);
+	return res;
 }
 
 VALUE RubyGate::secure_call(VALUE args) {
@@ -171,19 +168,24 @@ void h8::RubyGate::rescued_call(VALUE rb_args, VALUE (*call)(VALUE),
 							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(context, args, 1);
+		rb_ary_push(rb_args, context->ruby_context());
 		rb_ary_push(rb_args, ruby_object);
 		rescued_call(rb_args, call, [&] (VALUE res) {
-					args.GetReturnValue().Set(context->to_js(res));
-				});
-	});
+			if( res == ruby_object )
+				args.GetReturnValue().Set(args.This());
+			else
+				args.GetReturnValue().Set(context->to_js(res));
+		});
+});
 }
 
 void h8::RubyGate::getProperty(Local<String> name,
@@ -193,6 +195,9 @@ void h8::RubyGate::getProperty(Local<String> name,
 		rb_ary_push(rb_args, ruby_object);
 		rb_ary_push(rb_args, context->to_ruby(name));
 		rescued_call(rb_args, secure_call, [&] (VALUE res) {
+				if( res == ruby_object )
+					info.GetReturnValue().Set(info.This());
+				else
 					info.GetReturnValue().Set(context->to_js(res));
 				});
 	});

data/ext/h8/ruby_gate.h

@@ -51,6 +51,7 @@ public:
 
 	virtual ~RubyGate() {
 //		puts("~RG()");
+		context->unregister_ruby_gate(this);
 		persistent().ClearWeak();
 		persistent().Reset();
 		// The rest is done by the base classes

data/lib/h8/context.rb

@@ -69,12 +69,12 @@ module H8
       begin
         m = instance.public_method(method)
         owner = m.owner
-        if owner != Object.class && owner != Kernel && owner != BasicObject.class
+        if can_access?(owner)
           return m.call(*args) if method[0] == '[' || method[-1] == '='
           if m.arity != 0
             return -> (*args) { m.call *args }
           else
-            return m.call *args
+            return m.call
           end
         end
       rescue NameError
@@ -86,8 +86,12 @@ module H8
                        end
         begin
           m = instance.public_method(method)
-          if m.owner == instance.class
-            return m.call(*args)
+          if can_access?(owner)
+            if method == :[]
+              return m.call(*args) || m.call(args[0].to_sym)
+            else
+              return m.call(*args)
+            end
           end
         rescue NameError
           # It means there is no [] or []=, e.g. undefined
@@ -96,6 +100,16 @@ module H8
       H8::Undefined
     end
 
+    # This is workaround for buggy rb_proc_call which produces segfaults
+    # if proc is not exactly a proc, so we call it like this:
+    def safe_proc_call proc, args
+      proc.call *args
+    end
+
+    def self.can_access?(owner)
+      owner != Object.class && owner != Kernel && owner != BasicObject.class
+    end
+
     protected
 
     # Set var that could be either a callable, class instance, simple value or a Class class

data/lib/h8/version.rb

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

data/spec/js_gate_spec.rb

@@ -40,10 +40,11 @@ describe 'js_gate' do
     H8::Context.eval('null').should == nil
   end
 
-  it 'should retreive JS fieds as indexes' do
+  it 'should retreive JS fieds as indexes indiffirently' do
     res = H8::Context.eval("({ 'foo': 'bar', 'bar': 122 });")
     res['foo'].to_s.should == 'bar'
     res['bar'].to_i.should == 122
+    res[:foo].should == 'bar'
   end
 
   it 'should retreive JS fields as properties' do

data/spec/ruby_gate_spec.rb

@@ -19,26 +19,6 @@ describe 'ruby gate' do
     count.should == 1
   end
 
-  # it 'should gate callables in therubyrace mode' do
-  #   cxt      = H8::Context.new
-  #   cxt[:fn] = -> (this, a, b) {
-  #     p this.to_s
-  #     p this.offset
-  #     this.offset + a + b
-  #   }
-  #
-  #   res = cxt.eval <<-End
-  #     function Test() {
-  #       this.offset = 110;
-  #       this.method = function(a,b) {
-  #         return fn(this,a,b);
-  #       }
-  #     }
-  #     new Test().method(11, 22);
-  #   End
-  #   res.to_i.should == 143
-  # end
-
   it 'should allow edit context on yield' do
     cxt      = H8::Context.new
     cxt[:fn] = -> (a, b) {
@@ -237,6 +217,7 @@ describe 'ruby gate' do
 
     it 'should access object properties and methods' do
       cxt       = H8::Context.new
+      cxt.eval('RubyGate.prototype.test2 = function() { return "ttt"; }; null;');
       cxt[:foo] = Test.new
       cxt.eval('foo.ro').should == 'readonly'
       cxt.eval('foo.rw').should == 'not initialized'
@@ -336,9 +317,10 @@ describe 'ruby gate' do
 
     it 'should access plain hashes' do
       cxt     = H8::Context.new
-      h       = { 'one' => 2 }
+      h       = { 'one' => 2, :two => 21 }
       cxt[:h] = h
       cxt.eval("h['one']").should == 2
+      cxt.eval("h['two']").should == 21
       eval("h['one']=1;")
       h['one'].should == 1
     end
@@ -371,23 +353,31 @@ describe 'ruby gate' do
       c.eval('res instanceof RubyGate').should == true
     end
 
-    it 'should gate classes' do
-      class Gated
-        attr :init_args
+    class Gated
+      attr :init_args
 
-        def initialize *args
-          @init_args = args
-        end
+      def initialize *args
+        @init_args = args
+      end
 
-        def inspect
-          "Gated<#{@init_args.inspect}>"
-        end
+      def inspect
+        "Gated<#{@init_args.inspect}>"
+      end
 
-        def to_str
-          inspect
-        end
+      def checkself
+        self
+      end
+
+      def checkself2 *args
+        self
       end
 
+      def to_str
+        inspect
+      end
+    end
+
+    it 'should gate classes' do
       cxt = H8::Context.new RClass: Gated
       c   = cxt.eval 'new RClass()'
       c.should be_a(Gated)
@@ -400,6 +390,40 @@ describe 'ruby gate' do
       c.init_args.should == ['hello', 'world']
       cxt.eval('rc.init_args').should == ['hello', 'world']
     end
+
+    it 'should not die on calling wrong arity' do
+      cxt = H8::Context.new RClass: Gated
+      g1 = cxt.eval 'var g1 = new RClass(1,2.3); g1'
+
+      # We call gated ruby object with wrong number of args
+      # which in turn causes attempt to call not callable result:
+      expect(-> {cxt.eval('g1.checkself(12)')}).to raise_error(NoMethodError)
+    end
+
+    it 'should return self from gated class' do
+      cxt = H8::Context.new RClass: Gated
+      g1 = cxt.eval 'var g1 = new RClass(1,2.3); g1'
+      g1.should be_a(Gated)
+      g2 = cxt.eval 'g1.checkself'
+      g2.should be_a(Gated)
+      g1.equal?(g2).should == true
+      cxt.eval('g1 instanceof RClass').should == true
+      # p cxt.eval('g1.checkself.toString()')
+      cxt.eval('g1.checkself instanceof RClass').should == true
+      cxt.eval('g1.checkself === g1').should == true
+
+      # This checks how id map works (lite check)
+      cxt.eval('g1.checkself2(1) instanceof RClass').should == true
+      cxt.eval('g1.checkself2(2) === g1').should == true
+    end
+
+    it 'should expendable gate classes' do
+      cxt = H8::Context.new RClass: Gated
+      expect(-> { cxt.eval 'new RClass().mm(1)' }).to raise_error(H8::JsError)
+      cxt.eval('RClass.prototype.mm = function(a) { return "bar" + a; };')
+      cxt.eval('var x = new RClass(11); x.mm("hi!");').should == 'barhi!';
+    end
+
   end
 
   it 'should survive recursive constructions' do

metadata

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