h8 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a72940e0db998af017aa93553d91b90eefe2662c
-  data.tar.gz: b2d87d6c19c23c983cdc00b60bf874d921133f29
+  metadata.gz: 9b76a42b3323f67318a62c30a351b47af58ed43c
+  data.tar.gz: ee264fbcde18819ba8056828f6cda504f4f36e56
 SHA512:
-  metadata.gz: 713eedbe21d86dcaeac35d3d3d052af41bb36fc9ff434c096fa1c15f95299194c1fce45945150ac8f8ad77fb8732fa2acbbe7e6c9a4d37aa6fca82e3cf075387
-  data.tar.gz: d0ff9c201ae06798b57d1c80bcb471f72a5bc29b8e4e3404b33df1ec689422472efc2e547836df50846f955d6aca441e2ab81488853d3e26af25f63ab85dec15
+  metadata.gz: 77365dcf82c9ff0e7832cb915080b18aacc280e9a9e91cddb917da72168afdbf53be7445082721c539ca71a424e6fb013958ae118317a3274c0b1629c3341842
+  data.tar.gz: 397d66435fbd04f1ec3b72f5cce6b1d876e316533c4063c8a9288bab96ee97c68022313181075283aa614e7365f02084387793e9325e6402650adcc22fc7dde0

data/README.md

@@ -57,7 +57,7 @@ install v8 from sources 3.31.77 (or try newer), then execute:
     export CXXFLAGS='-std=c++11 -stdlib=libc++ -mmacosx-version-min=10.9'
     export LDFLAGS=-lc++
     make native
-    exportexport V8_3_31_ROOT=`pwd` # or somehow else set it
+    export V8_3_31_ROOT=`pwd` # or somehow else set it
 
 Note that exporting symbols is a hack that may not be in need anymore. After that the gem should
 install normally.
@@ -70,7 +70,7 @@ Install first a valid v8 version. We provide a ready package!
 
 It should install prerequisites, if not, manually install
 
-   sudo apt-get install libicu-dev
+    sudo apt-get install libicu-dev
 
 You might also need to install GMP.
 

data/ext/h8/h8.h

@@ -159,8 +159,11 @@ public:
 			return v8::Undefined(isolate);
 		case T_NIL:
 			return v8::Null(isolate);
+		case T_ARRAY:
+		case T_HASH:
 		case T_DATA:
 		case T_OBJECT:
+		case T_CLASS:
 			return gateObject(ruby_value);
 		default:
 			VALUE msg = rb_str_new2("can't gate to js (unknown): ");

data/ext/h8/js_gate.h

@@ -124,6 +124,17 @@ public:
 		return h8->to_ruby(object()->Get(v8_name));
 	}
 
+	/**
+	 * Set JS object attribute to ruby value
+	 *
+	 */
+	void set_attribute(VALUE name, VALUE value) {
+		H8::Scope scope(h8);
+		Local<Value> v8_name = v8::String::NewFromUtf8(isolate(),
+				StringValueCStr(name));
+		object()->Set(v8_name, h8->to_js(value));
+	}
+
 	VALUE get_index(VALUE index) {
 		H8::Scope scope(h8);
 		return h8->to_ruby(object()->Get(NUM2INT(index)));

data/ext/h8/main.cpp

@@ -79,6 +79,13 @@ static VALUE rvalue_get_index(VALUE self, VALUE index) {
 	return rv(self)->get_index(index);
 }
 
+static VALUE rvalue_set_attr(VALUE self, VALUE name, VALUE value) {
+	return protect_ruby([&] {
+		rv(self)->set_attribute(name, value);
+		return Qnil;
+	});
+}
+
 static VALUE rvalue_is_string(VALUE self) {
 	return rv(self)->is_string();
 }
@@ -170,7 +177,7 @@ void Init_h8(void) {
 	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, 2);
-	rb_define_method(context_class, "set_var", (ruby_method) context_set_var,
+	rb_define_method(context_class, "_set_var", (ruby_method) context_set_var,
 			2);
 
 	value_class = rb_define_class_under(h8, "Value", rb_cObject);
@@ -191,6 +198,8 @@ void Init_h8(void) {
 			1);
 	rb_define_method(value_class, "_get_index", (ruby_method) rvalue_get_index,
 			1);
+	rb_define_method(value_class, "_set_attr", (ruby_method) rvalue_set_attr,
+			2);
 	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",

data/ext/h8/ruby_gate.cpp

@@ -14,7 +14,8 @@ h8::RubyGate::RubyGate(H8* _context, VALUE object) :
 	templ->SetInternalFieldCount(2);
 	templ->SetCallAsFunctionHandler(&ObjectCallback);
 
-	templ->SetNamedPropertyHandler(h8::RubyGate::mapGet, h8::RubyGate::mapSet);
+	templ->SetNamedPropertyHandler(RubyGate::mapGet, RubyGate::mapSet);
+	templ->SetIndexedPropertyHandler(RubyGate::indexGet,RubyGate::indexSet);
 
 	v8::Handle<v8::Object> handle = templ->NewInstance();
 	handle->SetAlignedPointerInInternalField(1, RUBYGATE_ID);
@@ -36,6 +37,21 @@ void h8::RubyGate::mapSet(Local<String> name,
 	rg->setProperty(name, value, info);
 }
 
+void h8::RubyGate::indexGet(uint32_t index,
+		const PropertyCallbackInfo<Value> &info) {
+	RubyGate *rg = RubyGate::unwrap(info.This());
+	assert(rg != 0);
+	rg->getIndex(index, info);
+}
+
+void h8::RubyGate::indexSet(uint32_t index,
+		Local<Value> value,
+		const PropertyCallbackInfo<Value> &info) {
+	RubyGate *rg = RubyGate::unwrap(info.This());
+	assert(rg != 0);
+	rg->setIndex(index, value, info);
+}
+
 void h8::RubyGate::ObjectCallback(
 		const v8::FunctionCallbackInfo<v8::Value>& args) {
 	v8::HandleScope scope(args.GetIsolate());
@@ -115,3 +131,27 @@ void h8::RubyGate::setProperty(Local<String> name,
 		});
 }
 
+void h8::RubyGate::getIndex(uint32_t index,
+		const PropertyCallbackInfo<Value> &info) {
+	VALUE rb_args = rb_ary_new2(3);
+	rb_ary_push(rb_args, INT2FIX(index));
+	rb_ary_push(rb_args, ruby_object);
+	rb_ary_push(rb_args, rb_str_new2("[]"));
+	return rescued_call(rb_args, secure_call, [&] (VALUE res) {
+		info.GetReturnValue().Set(context->to_js(res));
+		});
+}
+
+void h8::RubyGate::setIndex(uint32_t index,
+		Local<Value> value,
+		const PropertyCallbackInfo<Value> &info) {
+	VALUE rb_args = rb_ary_new2(4);
+	rb_ary_push(rb_args, INT2FIX(index));
+	rb_ary_push(rb_args, context->to_ruby(value));
+	rb_ary_push(rb_args, ruby_object);
+	rb_ary_push(rb_args, rb_str_new2("[]="));
+	return rescued_call(rb_args, secure_call, [&] (VALUE res) {
+		info.GetReturnValue().Set(context->to_js(res));
+		});
+}
+

data/ext/h8/ruby_gate.h

@@ -94,14 +94,21 @@ protected:
 
 	void getProperty(Local<String> name, const PropertyCallbackInfo<Value> &info);
 	void setProperty(Local<String> name, Local<Value> value,const PropertyCallbackInfo<Value> &info);
+
+	void getIndex(uint32_t index, const PropertyCallbackInfo<Value> &info);
+	void setIndex(uint32_t index, 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);
 
+	static void indexGet(uint32_t index, const PropertyCallbackInfo<Value> &info);
+	static void indexSet(uint32_t index, Local<Value> value, const PropertyCallbackInfo<Value> &info);
+
 	void throw_js();
 
 

data/hybrid8.gemspec

@@ -7,14 +7,18 @@ require "rake/extensiontask"
 require 'rubygems/package_task'
 
 spec = Gem::Specification.new do |spec|
-  spec.name          = "h8"
-  spec.version       = H8::VERSION
-  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 ruby 2.1+ }
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.name        = "h8"
+  spec.version     = H8::VERSION
+  spec.authors     = ["sergeych"]
+  spec.email       = ["real.sergeych@gmail.com"]
+  spec.summary     = %q{Minimalistic and fast Ruby <--> V8 integration}
+  spec.description = <<-End
+    Synergy of ruby and javascript code, almost completely integrates both languages, their
+    garbage collection models, object models and so on. Effective for tight ruby-javascript
+    integration where objects can be passed between different languages several times.
+  End
+  spec.homepage    = "https://github.com/sergeych/hybrid8"
+  spec.license     = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
@@ -37,9 +41,9 @@ Gem::PackageTask.new(spec) do |pkg|
 end
 
 Rake::ExtensionTask.new "h8", spec do |ext|
-  ext.lib_dir  = "lib/h8"
+  ext.lib_dir        = "lib/h8"
   ext.source_pattern = "*.{c,cpp}"
-  ext.gem_spec = spec
+  ext.gem_spec       = spec
 end
 
 spec

data/lib/h8/context.rb

@@ -1,29 +1,43 @@
 module H8
   class Context
     # Create new context optionally providing variables hash
-    def initialize timout: nil, **kwargs
+    def initialize **kwargs
+      @idcount = 0
       set_all **kwargs
+      _set_var '___create_ruby_class', -> (cls, args) {
+        _do_cretate_ruby_class cls, args
+      }
     end
 
     # set variables from keyword arguments to this context
+    # see #[]= for details
     def set_all **kwargs
       kwargs.each { |name, value|
         set_var(name.to_s, value)
       }
     end
 
-    # Set variable for the context
+    # Set variable/class for the context. It can set variable to hold:
+    #  * primitive type (like string, integer, nil, float and like) - by value!
+    #  * any other ruby object - by reference
+    #  * ruby Class - creating a javascript constructor function that creates ruby
+    #    class instance (any arguments) and gates it to use with js.
     def []= name, value
       set_all name => value
     end
 
     # Execute a given script on the current context with optionally limited execution time.
     #
-    # @param [Float] timeout if is not 0 then maximum execution time in seconds
+    # @param [Int] timeout if is not 0 then maximum execution time in millis (therubyracer
+    #              compatibility)
+    # @param [Float] max_time if is not 0 then maximum execution time in seconds. Has precedence
+    #                over timeout
+    #
     # @return [Value] wrapped object returned by the script
     # @raise [H8::TimeoutError] if the timeout was set and expired
-    def eval script, timeout: 0
-      _eval script, (timeout*1000).to_i
+    def eval script, max_time: 0, timeout: 0
+      timeout = max_time * 1000 if max_time > 0
+      _eval script, timeout.to_i
     end
 
     # Execute script in a new context with optionally set vars. @see H8#set_all
@@ -33,13 +47,17 @@ module H8
     end
 
     # Secure gate for JS to securely access ruby class properties (methods with no args)
-    # and methods.
+    # and methods. This class implements security policy! Overriding this method could
+    # breach security and provide full access to ruby object trees.
+    #
+    # It has very complex logic so the security model update should be done somehow
+    # else.
     def self.secure_call instance, method, args=nil
       method = method.to_sym
       begin
         m = instance.public_method(method)
         if m.owner == instance.class
-          return m.call(*args) if method[-1] == '='
+          return m.call(*args) if method[0] == '[' || method[-1] == '='
           if m.arity != 0
             return -> (*args) { m.call *args }
           else
@@ -47,8 +65,47 @@ module H8
           end
         end
       rescue NameError
+        # No exact method, calling []/[]= if any
+        method, args = if method[-1] == '='
+                         [:[]=, [method[0..-2].to_s, args[0]] ]
+                       else
+                         [:[], [method.to_s]]
+                       end
+        begin
+          m = instance.public_method(method)
+          if m.owner == instance.class
+            return m.call(*args)
+          end
+        rescue NameError
+          # It means there is no [] or []=, e.g. undefined
+        end
       end
       H8::Undefined
     end
+
+    private
+
+    # Set var that could be either a callable, class instance, simple value or a Class class
+    # 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
+      else
+        _set_var name, value
+      end
+    end
+
+    # create class instance passing it arguments stored in javascript 'arguments' object
+    # (so it repacks them first)
+    def _do_cretate_ruby_class(klass, arguments)
+      klass.new *arguments.to_ruby.values
+    end
+
   end
 end

data/lib/h8/value.rb

@@ -10,6 +10,10 @@ module H8
   # pass values between context, as they often map native Javascript objects. If you need, you
   # can copy, for example, by converting it H8::Value#to_ruby first. Another approach is to
   # use JSON serialization from the script.
+  #
+  # Interesting thing about H8::Value is that when passed back to some javascript environment
+  # (say, callback parameted or as a global variable), it unwraps source javascript object -
+  # no copying, no modifying.
   class Value
 
     include Comparable
@@ -23,23 +27,40 @@ module H8
     #
     # @return [H8::Value] instance, which is .undefined? if does not exist
     def [] name_index
-      name_index.is_a?(Fixnum) ? _get_index(name_index) : _get_attr(name_index)
+      name_index.is_a?(Fixnum) ? _get_index(name_index) : _get_attr(name_index.to_s)
+    end
+
+    # Set js object attribute by either name or index (should be Fixnum instance).
+    def []= name_index, value
+      # name_index.is_a?(Fixnum) ? _get_index(name_index) : _get_attr(name_index.to_s)
+      _set_attr(name_index.to_s, value)
     end
 
-    # Optimized JS member access. Support class members and member functions - will call them
-    # automatically. Use val['attr'] to get callable instead
+    # Optimizing JS member access. Support class members and member functions - will call them
+    # automatically. Use val['attr'] to get callable instead.
+    #
+    # First invocation creates accessor method so future calls happen much faster
     def method_missing(method_sym, *arguments, &block)
       name = method_sym.to_s
-      instance_eval <<-End
-              def #{name} *args, **kwargs
-                res = _get_attr('#{name}')
-                (res.is_a?(H8::Value) && res.function?) ? res.apply(self,*args) : res
-              end
-      End
+      if name[-1] != '='
+        instance_eval <<-End
+                def #{name} *args, **kwargs
+                  res = _get_attr('#{name}')
+                  (res.is_a?(H8::Value) && res.function?) ? res.apply(self,*args) : res
+                end
+        End
+      else
+        instance_eval <<-End
+                def #{name} value
+                  _set_attr('#{name[0..-2]}', value)
+                end
+        End
+      end
       send method_sym, *arguments
     end
 
-    # Compare to other object, either usual or another Value instance. Does its best.
+    # Compare to other object, either usual or another Value instance. Tries its best.
+    # be sure to use it wisely and report any problems
     def <=> other
       other = other.to_ruby if other.is_a?(H8::Value)
       to_ruby <=> other
@@ -103,7 +124,8 @@ module H8
       values.each
     end
 
-    # Tries to convert wrapped JS object to ruby primitive (Fixed, String, Float, Array, Hash)
+    # Tries to convert wrapped JS object to ruby primitive (Fixed, String, Float, Array, Hash).
+    # Note that this conversion looses information about source javascript class (if any)
     def to_ruby
       case
         when integer?
@@ -114,6 +136,8 @@ module H8
           to_f
         when array?
           _get_attr('length').to_i.times.map { |i| _get_index(i).to_ruby }
+        when function?
+          to_proc
         when object?
           to_h
         else

data/lib/h8/version.rb

@@ -1,3 +1,3 @@
 module H8
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/context_spec.rb

@@ -68,7 +68,7 @@ describe 'context' do
     # end
     t = Time.now
     expect( -> {
-      c2 = cxt.eval script, timeout: 0.2
+      c2 = cxt.eval script, max_time: 0.2
     }).to raise_error(H8::TimeoutError)
     (Time.now - t).should < 0.25
     cxt.eval('(last-start)/1000').should < 250

data/spec/js_gate_spec.rb

@@ -237,5 +237,24 @@ describe 'js_gate' do
     }).to raise_error(MyException)
   end
 
+  it 'should dynamically add and remove properties to js objects' do
+    cxt = H8::Context.new
+    jobj = cxt.eval('jobj = {one: 1};')
+    jobj.one.should == 1
+    jobj['one'].should == 1
+    jobj[:one].should == 1
+    jobj.one = 101
+    cxt.eval('jobj.one').should == 101
+    jobj[:one].should == 101
+    jobj.two = 2
+    jobj[:two].should == 2
+    cxt.eval('jobj.two').should == 2
+    jobj[:three] = 3
+    jobj.three.should == 3
+    cxt.eval('jobj.three').should == 3
+    jobj[101] = 202
+    jobj[101].should == 202
+    cxt.eval('jobj[101]').should == 202
+  end
 
 end

data/spec/ruby_gate_spec.rb

@@ -19,7 +19,7 @@ describe 'ruby gate' do
   it 'should gate callables with varargs' do
     cxt      = H8::Context.new
     cxt[:fn] = -> (*args) {
-      args.reduce(0){|all,x| all+x }
+      args.reduce(0) { |all, x| all+x }
     }
 
     cxt.eval('fn(11, 22, 100);').should == 133
@@ -102,6 +102,8 @@ describe 'ruby gate' do
       def base
         raise "It should not be called"
       end
+
+      attr_accessor :do_throw
     end
 
     class Test < Base
@@ -109,14 +111,30 @@ describe 'ruby gate' do
       attr_accessor :rw
 
       def initialize
-        @ro = 'readonly'
-        @rw = 'not initialized'
+        @ro           = 'readonly'
+        @rw           = 'not initialized'
+        @val          = 'init[]'
+        self.do_throw = false
       end
 
       def test_args *args
         args.join('-')
       end
 
+      def [] val
+        if val != 'foo'
+          raise('not foo') if do_throw
+          H8::Undefined
+        else
+          @val
+        end
+      end
+
+      def []= val, x
+        val != 'foo' && do_throw and raise "not foo"
+        @val = x
+      end
+
       protected
 
       def prot_method
@@ -152,8 +170,119 @@ describe 'ruby gate' do
       cxt.eval('foo.rw').should == 'hello'
     end
 
-    it 'should gate classes'
-  end
+    context 'no interceptors' do
+      class Test2 < Base
+        attr :ro
+        attr_accessor :rw
+
+        def initialize
+          @ro = 'readonly'
+          @rw = 'not initialized'
+        end
+
+        def test_args *args
+          args.join('-')
+        end
+
+        protected
+
+        def prot_method
+          raise 'should not be called'
+        end
+
+        private
+
+        def priv_method
+          raise 'should not be called'
+        end
+      end
+
+      it 'should access object properties and methods' do
+        cxt       = H8::Context.new
+        cxt[:foo] = Test2.new
+        cxt.eval('foo.ro').should == 'readonly'
+        cxt.eval('foo.rw').should == 'not initialized'
+        cxt.eval('foo.base').should == H8::Undefined
+        cxt.eval('foo.send').should == H8::Undefined
+        cxt.eval('foo.prot_method').should == H8::Undefined
+        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'
+      end
+
+      it 'should set ruby properties' do
+        cxt       = H8::Context.new
+        cxt[:foo] = t = Test2.new
+        cxt.eval('foo.rw="hello";')
+        t.rw.should == 'hello'
+        cxt.eval('foo.rw').should == 'hello'
+      end
+    end
 
-  it 'should retain ruby objects'
+    it 'should add and intercept property access' do
+      # pending
+      t          = Test.new
+      t.do_throw = true
+      cxt        = H8::Context.new t: t
+      cxt.eval("t['foo'];").should == 'init[]'
+      expect(-> { cxt.eval("t['foo1'];") }).to raise_error(RuntimeError)
+      cxt.eval("t['foo']='bar'");
+      # p t['foo']
+      # p cxt.eval "t['foo'] = 'bar';"
+    end
+
+    it 'should access plain arrays (provide numeric indexes)' do
+      cxt     = H8::Context.new
+      array   = [10, 20, 30]
+      cxt[:a] = array
+      cxt.eval('a.length').should == 3
+      cxt.eval('a[1]').should == 20
+      cxt.eval('a[0] = 100; a[0]').should == 100
+      array[0].should == 100
+    end
+
+    it 'should access plain hashes' do
+      cxt     = H8::Context.new
+      h       = { 'one' => 2 }
+      cxt[:h] = h
+      cxt.eval("h['one']").should == 2
+      eval("h['one']=1;")
+      h['one'].should == 1
+    end
+
+    it 'should pass varargs' do
+      cxt = H8::Context.new
+      cxt[:test] = -> (args) {
+        # Sample how to deal with javascript 'arguments' vararg object:
+        args.to_ruby.values.join(',')
+      }
+      res = cxt.eval <<-End
+        function test2() {
+          return test(arguments);
+        }
+        test2(1,2,'ho');
+      End
+      res.should == '1,2,ho'
+    end
+
+    it 'should gate classes' do
+      class Gated
+        attr :init_args
+
+        def initialize *args
+          @init_args = args
+        end
+      end
+
+      cxt = H8::Context.new RClass: Gated
+      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)
+      c.init_args.should == ['hello', 'world']
+      cxt.eval('rc.init_args').should == ['hello', 'world']
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: h8
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - sergeych
@@ -66,8 +66,10 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.14.0
-description: 'Should be more or less replacement for broken therubyracer gem and ruby
-  2.1+ '
+description: |2
+      Synergy of ruby and javascript code, almost completely integrates both languages, their
+      garbage collection models, object models and so on. Effective for tight ruby-javascript
+      integration where objects can be passed between different languages several times.
 email:
 - real.sergeych@gmail.com
 executables: []
@@ -106,7 +108,7 @@ files:
 - spec/js_gate_spec.rb
 - spec/ruby_gate_spec.rb
 - spec/spec_helper.rb
-homepage: ''
+homepage: https://github.com/sergeych/hybrid8
 licenses:
 - MIT
 metadata: {}
@@ -130,7 +132,7 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Minimalistic and sane v8 bindings
+summary: Minimalistic and fast Ruby <--> V8 integration
 test_files:
 - spec/context_spec.rb
 - spec/js_gate_spec.rb