h8 0.0.2 → 0.0.4

data/lib/h8/context.rb

@@ -1,21 +1,54 @@
 module H8
   class Context
+    # Create new context optionally providing variables hash
     def initialize timout: nil, **kwargs
-      set **kwargs
+      set_all **kwargs
     end
 
-    def set **kwargs
+    # set variables from keyword arguments to this context
+    def set_all **kwargs
       kwargs.each { |name, value|
         set_var(name.to_s, value)
       }
     end
 
+    # Set variable for the context
     def []= name, value
-      set name => value
+      set_all name => value
     end
 
-    def self.eval script
-      Context.new.eval script
+    # 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
+    # @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
+    end
+
+    # Execute script in a new context with optionally set vars. @see H8#set_all
+    # @return [Value] wrapped object returned by the script
+    def self.eval script, **kwargs
+      Context.new(** kwargs).eval script
+    end
+
+    # Secure gate for JS to securely access ruby class properties (methods with no args)
+    # and methods.
+    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] == '='
+          if m.arity != 0
+            return -> (*args) { m.call *args }
+          else
+            return m.call *args
+          end
+        end
+      rescue NameError
+      end
+      H8::Undefined
     end
   end
 end

data/lib/h8/value.rb

@@ -2,62 +2,108 @@ module H8
 
   # Wrapper for javascript objects.
   #
-  # Important: when accessin fields of the object, respond_to? will not work due to
-  # js notation, instead, check the returned value to be value.undefined?
+  # Important: when accessing fields of the object, respond_to? will not work due to
+  # js notation, instead, check the returned value (there will be always one) to not to be
+  # value.undefined?
+  #
+  # Precaution! Values are always bounded to the context where they are created. You can not
+  # 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.
   class Value
 
     include Comparable
 
     def inspect
-      "<H8::Value #{to_s}>"
+      "<H8::Value #{to_ruby}>"
     end
 
-    # Get js object attribute by its name or index (should be Fixnum instance). It always
+    # Get js object attribute by either name or index (should be Fixnum instance). It always
     # return H8::Value instance, check it to (not) be undefined? to see if there is such attribute
+    #
+    # @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)
     end
 
-    # Optimized JS member access. Do not yet support calls!
-    # use only to get fields
+    # Optimized JS member access. Support class members and member functions - will call them
+    # automatically. Use val['attr'] to get callable instead
     def method_missing(method_sym, *arguments, &block)
       name = method_sym.to_s
       instance_eval <<-End
               def #{name} *args, **kwargs
                 res = _get_attr('#{name}')
-                res.function? ? res.apply(res,*args) : res
+                (res.is_a?(H8::Value) && res.function?) ? res.apply(self,*args) : res
               end
       End
       send method_sym, *arguments
     end
 
-    # def each_key
-    #   p eval("Object.keys(this)");
-    # end
-    #
-    # def keys
-    #   cxt = self._context
-    #   cxt['__self'] =
-    # end
-
+    # Compare to other object, either usual or another Value instance. Does its best.
     def <=> other
       other = other.to_ruby if other.is_a?(H8::Value)
       to_ruby <=> other
     end
 
+    # Call javascript function represented by this instance (which should be function())
+    # with given (or no) arguments.
+    # @return [H8::Value] function return which might be undefined
     def call *args
       _call args
     end
 
-    def apply to, *args
-      _apply to, args
+    # Like JS apply: call the value that should be function() bounded to a given object
+    # @param [Object] this object to bound call to
+    # @param args any arguments
+    # @return [H8::Value] result returned by the function which might be undefined
+    def apply this, *args
+      _apply this, args
     end
 
+    # Tries to convert JS object to ruby array
+    # @raise H8::Error if the JS object is not an array
     def to_ary
       raise Error, 'Is not an array' unless array?
       to_ruby
     end
 
+    alias :to_a :to_ary
+
+    # Generate set of keys of the wrapped object
+    def keys
+      context[:__obj] = self
+      Set.new context.eval("(Object.keys(__obj));").to_a
+    end
+
+    # enumerate |key, value| pairs for javascript object attributes
+    def each
+      return enum_for(:each) unless block_given? # Sparkling magic!
+      keys.each { |k|
+        yield k, _get_attr(k)
+      }
+    end
+
+    # Try to convert javascript object to a ruby hash
+    def to_h
+      each.reduce({}) { |all, kv| all[kv[0]] = kv[1].to_ruby; all }
+    end
+
+    # Iterate over javascript object keys
+    def each_key
+      keys.each
+    end
+
+    # @return [Array] values array. does NOT convert values to_ruby()
+    def values
+      each.reduce([]) { |all, kv| all << kv[1]; all }
+    end
+
+    # iterate over values of the javascript object attributes
+    def each_value
+      values.each
+    end
+
+    # Tries to convert wrapped JS object to ruby primitive (Fixed, String, Float, Array, Hash)
     def to_ruby
       case
         when integer?
@@ -68,10 +114,49 @@ module H8
           to_f
         when array?
           _get_attr('length').to_i.times.map { |i| _get_index(i).to_ruby }
+        when object?
+          to_h
         else
-          raise Error, "Dont know how to convert H8::Value"
+          raise Error, "Dont know how to convert #{self.class}"
       end
     end
+
+    def function? # native method. stub for documentation
+    end
+
+    def object? # native method. stub for documentation
+    end
+
+    def undefined? # native method. stub for documentation
+    end
+
+    def array? # native method. stub for documentation
+    end
+
+    # @return [H8::Context] context to which this value is bounded
+    def context # native method. stub for documentation
+    end
+
+    # Convert to Proc instance so it could be used as &block parameter
+    # @raises (H8::Error) if !self.function?
+    def to_proc
+      function? or raise H8::Error, 'JS object is not a function'
+      -> (*args) { call *args }
+    end
+
+    def to_str
+      to_s
+    end
   end
 
 end
+
+# Ruby object's t_ruby does nothing (tree conversion optimization)
+class Object
+  # It is already a ruby object. Gate objects should override
+  # as need
+  def to_ruby
+    self
+  end
+end
+

data/lib/h8/version.rb

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

data/spec/context_spec.rb

@@ -5,7 +5,9 @@ describe 'context' do
 
   it 'should create' do
     cxt = H8::Context.new
-    cxt.eval("'Res: ' + (2+5);")
+    cxt[:one] = 1
+    cxt.eval("");
+    # cxt.eval("'Res: ' + (2+5);")
   end
 
   it 'should gate simple values to JS context' do
@@ -13,7 +15,7 @@ describe 'context' do
     cxt[:sign] = '!'
     res = cxt.eval "foo+' '+bar+sign;"
     res.should == 'hello world!'
-    cxt.set one: 101, real: 1.21
+    cxt.set_all one: 101, real: 1.21
     cxt.eval("one + one;").should == 202
     cxt.eval("real + one;").should == (101 + 1.21)
   end
@@ -28,12 +30,48 @@ describe 'context' do
 
   it 'should not gate H8::Values between contexts' do
     cxt = H8::Context.new
-    obj = cxt.eval "('che bel');"
+    obj = cxt.eval "({res: 'che bel'});"
+    # This should be ok
+    cxt[:first] = obj
+    res = cxt.eval "first.res + ' giorno';"
+    res.should == 'che bel giorno'
+    # And that should fail
     cxt1 = H8::Context.new
     expect( -> {
       cxt1[:first] = obj
-      res = cxt1.eval "first + ' giorno';"
+      res = cxt1.eval "first.res + ' giorno';"
     }).to raise_error(H8::Error)
   end
 
+  it 'should provide reasonable undefined logic' do
+    raise "bad !undefined" if !!H8::Undefined
+    H8::Undefined.should_not == true
+    H8::Undefined.should == false
+    H8::Undefined.should_not == 11
+    (H8::Undefined==nil).should == false
+    H8::Undefined.should be_undefined
+    (!H8::Undefined).should == true
+  end
+
+  it 'should limit script execution time' do
+    cxt = H8::Context.new
+    # cxt[:print] = -> (*args) { puts args.join(' ')}
+    script = <<-End
+      var start = new Date();
+      var last = null;
+      var counter = 0;
+      while((last=new Date().getTime()) - start < 1000 ) {
+        counter++;
+      }
+      counter;
+    End
+    # end
+    t = Time.now
+    expect( -> {
+      c2 = cxt.eval script, timeout: 0.2
+    }).to raise_error(H8::TimeoutError)
+    (Time.now - t).should < 0.25
+    cxt.eval('(last-start)/1000').should < 250
+  end
+
 end

data/spec/js_gate_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'h8'
+require 'weakref'
 
 describe 'js_gate' do
 
@@ -18,26 +19,25 @@ describe 'js_gate' do
     res.should_not be_integer
     res = cxt.eval("11+22;")
     res.to_i.should == 33
-    res.should be_integer
-    res.should be_float
-    res.should_not be_string
+    res.should be_kind_of(Fixnum)
   end
 
   it 'should return floats' do
     cxt = H8::Context.new
     res = cxt.eval("0.2 + 122.1;")
     res.to_s.should == '122.3'
-    res.should be_float
-    res.should_not be_integer
-    res.should_not be_string
+    res.should be_kind_of(Float)
   end
 
   it 'should return strings' do
     res = H8::Context.eval("'hel' + 'lo';")
     res.to_s.should == 'hello'
-    res.should be_string
-    res.should_not be_integer
-    res.should_not be_float
+    res.should be_kind_of(String)
+  end
+
+  it 'should return undefined and null' do
+    H8::Context.eval('undefined').should == H8::Undefined
+    H8::Context.eval('null').should == nil
   end
 
   it 'should retreive JS fieds as indexes' do
@@ -46,7 +46,7 @@ describe 'js_gate' do
     res['bar'].to_i.should == 122
   end
 
-  it 'should retreive JS fieds as properties' do
+  it 'should retreive JS fields as properties' do
     res = H8::Context.eval("({ 'foo': 'bar', 'bar': 122 });")
     res.bar.to_i.should == 122
     res.foo.to_s.should == 'bar'
@@ -55,6 +55,9 @@ describe 'js_gate' do
     # cached method check
     res.foo.to_s.should == 'bar'
     res.bar.to_i.should == 122
+
+    res.bad.should == H8::Undefined
+    # res.bad.bad ?
   end
 
   it 'should access arrays' do
@@ -67,11 +70,16 @@ describe 'js_gate' do
       res[1].to_s.should == 'foo'
       res[2].to_s.should == 'bar'
     }
+    res[3].should == H8::Undefined
   end
 
   it 'should eval and keep context alive' do
-    obj = H8::Context.eval("({ 'foo': 'bar', 'bar': 122 });")
-    GC.start # Here Context of obj that is not referenced should be kept
+    cxt = H8::Context.new
+    wr  = WeakRef.new cxt
+    obj = cxt.eval("({ 'foo': 'bar', 'bar': 122 });")
+    cxt = nil
+    GC.start # cxt is now kept only by H8::Value obj
+    wr.weakref_alive?.should be_true
     obj.foo.should == 'bar'
   end
 
@@ -94,13 +102,21 @@ describe 'js_gate' do
     res = H8::Context.eval("[-10, 'foo', 'bar'];")
     res.to_ruby.should == [-10, 'foo', 'bar']
     res.to_ary.should == [-10, 'foo', 'bar']
-    expect(-> { H8::Context.eval("'not array'").to_ary}).to raise_error(H8::Error)
   end
 
   it 'should provide hash methods' do
-    pending
     obj = H8::Context.eval("({ 'foo': 'bar', 'bar': 122 });")
-    obj.keys.should == ['foo', 'bar']
+    obj.keys.should == Set.new(['foo', 'bar'])
+
+    hash = {}
+    obj.each { |k, v| hash[k] = v.to_ruby }
+    hash.should == { "foo" => "bar", "bar" => 122 }
+    obj.to_h.should == { "foo" => "bar", "bar" => 122 }
+    obj.to_ruby.should == { "foo" => "bar", "bar" => 122 }
+
+    Set.new(obj.each_key).should == Set.new(['foo', 'bar'])
+    Set.new(obj.values.map(&:to_ruby)).should == Set.new(['bar', 122])
+    Set.new(obj.each_value.map(&:to_ruby)).should == Set.new(['bar', 122])
   end
 
   it 'should convert compare to ruby objects' do
@@ -137,7 +153,7 @@ describe 'js_gate' do
   end
 
   it 'should raise error on syntax' do
-    expect( -> {
+    expect(-> {
       H8::Context.eval 'this is not a valid js'
     }).to raise_error(H8::Error)
   end
@@ -159,4 +175,67 @@ describe 'js_gate' do
     res.doAdd(10, 1).should == 111
   end
 
+  it 'should pass exceptions from member function calls' do
+    res = H8::Context.eval <<-End
+      function cls(base) {
+        this.base = base;
+        this.doAdd = function(a, b) {
+          throw Error("Test error")
+          return a + b + base;
+        }
+      }
+      new cls(100);
+    End
+    expect(-> {
+      res.doAdd(10, 1).should == 111
+    }).to raise_error(H8::JsError) { |e|
+            e.message.should == "Uncaught Error: Test error"
+          }
+  end
+
+  it 'should call js functions' do
+    res = H8::Context.eval <<-End
+      var fn = function cls(a, b) {
+        return a + ":" + b;
+      }
+      fn;
+    End
+    res.call('foo', 'bar').should == 'foo:bar'
+
+    def xx(val, &block)
+      "::" + val + "-" + block.call('hello', 'world')
+    end
+
+    xx("123", &res.to_proc).should == "::123-hello:world"
+  end
+
+  it 'should gate uncaught exceptions from js callbacks' do
+    res = H8::Context.eval <<-End
+      var fn = function cls(a, b) {
+        throw Error("the test error");
+      }
+      fn;
+    End
+    expect(-> {
+      res.call('foo', 'bar').should == 'foo:bar'
+    }).to raise_error(H8::JsError)
+  end
+
+  it 'should pass thru uncaught ruby exceptions from js->ruby callbacks' do
+    class MyException < StandardError;
+    end;
+    cxt            = H8::Context.new
+    cxt[:bad_call] = -> { raise MyException }
+    res            = cxt.eval <<-End
+      var fn = function cls(a, b) {
+        bad_call();
+      }
+      fn;
+    End
+    expect(-> {
+      res.call('foo', 'bar').should == 'foo:bar'
+    }).to raise_error(MyException)
+  end
+
+
 end