h8 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b76a42b3323f67318a62c30a351b47af58ed43c
-  data.tar.gz: ee264fbcde18819ba8056828f6cda504f4f36e56
+  metadata.gz: 157a38dc54ce46cae280e12cd780c074d1b40c4c
+  data.tar.gz: 769f4a9417ae920f2b293b8bff43d10b8dbe2925
 SHA512:
-  metadata.gz: 77365dcf82c9ff0e7832cb915080b18aacc280e9a9e91cddb917da72168afdbf53be7445082721c539ca71a424e6fb013958ae118317a3274c0b1629c3341842
-  data.tar.gz: 397d66435fbd04f1ec3b72f5cce6b1d876e316533c4063c8a9288bab96ee97c68022313181075283aa614e7365f02084387793e9325e6402650adcc22fc7dde0
+  metadata.gz: 2cae98765a9949524355278bde88517b11aeaeac1ce539f912a4e71ad3515795861898e3e87acc7431cee1c947a0298dbb1117308f383cbacf226ff279447982
+  data.tar.gz: 013268e403ee3be27c74656aef90287c3ea04cab5199fca72480c7c7289a4f115429da0ba11f46846b79be8a9ea98410d2bab8534ce6a235e68492e7beae000d

data/README.md

@@ -1,11 +1,21 @@
 # Hybrid8, aka H8
 
-_Warning_ this gem functionality is almost complete but it lacks of testing and some features
-(see below). This is a working (or better say, test passing) alpha. Beta suitable versions
-will start from 0.1.*.
+_Warning_ this gem is a public beta at the moment - beta testers are welcome!It means, it is not
+yet production stable - we haven't yet tried.
 
-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.
+This gem was intended to replace therubyracer for many reasons:
+
+* therubyracer has critical bugs that are not fixed for a long time, under load it produces
+numerous frequent crashes.
+
+* therubyracer still uses antique version of V8, H8 uses the latest 3.31 branch
+
+* H8 is designed to provide very tight and effective integration of two allocation systems and
+object models, passing the same objects between different systems wrapping and unwrapping them
+rather than copying and changing
+
+* We hope that by the cost non significant changes we will provide faster execution. And might v8
+modern branch will help us with it ;)
 
 Special features:
 
@@ -26,19 +36,50 @@ uncaught javascript exceptions raise ruby error in ruby code.
 
 ## Main difference from therubyracer/features not ready
 
-*This version is not (yet?) thread safe*. For the sake of effectiveness, do not access same
-H8::Context and its returned values from concurrent threads. Use Mutexes!
+- This version is not (yet?) thread safe*. For the sake of effectiveness, do not access same
+H8::Context and its returned values from concurrent threads. Use Mutexes if need.
+
+The pity thing is, if we will Lock() the context on each call to it, the performance degradation
+will be notable and no matter whether you need threading with it. So, if you really need it, you
+wrap it with Mutex or whatever you want, without slowing down all the rest of us.
+
+- Script is executed in the calling ruby thread without unblocking it (other ruby threads can not
+ perform on this core while javascript code runs).
+
+The same performance reason. If we release gvl on script start and reacquire it every time the ruby
+object, callback, class, whatever is referenced from JS, the execution will considerably degrade. As
+this gem is intended to let javascript/coffescript tightly integrate with ruby objects we have
+decided to not to slow down everything. If it is a problem, lets discuss it.
 
 - correct and accurate object tracking in both JS and Ruby VMs, GC aware.
 
-- passed thru objects and exceptions in js -> ruby -> js -> ruby chains are usually kept unchanged,
-e.g. wrapped in one language then unwrapped when passed to the original language
+- labmda/proc passed as var to the context **does not receives first (this) argument
+automatically!**
+
+E.g. rubyracer code
+
+    cxt[:fn] = -> (this, a, b) { a + b }
+
+Becomes
+
+    cxt[:fn] = -> (a, b) { a + b }
+
+it looks prettier, doesn't it? And, if you really need `this` in the callable, just mention it in
+the call:
+
+    cxt[:fn] = -> (this, a, b) { a + b + this.offset }
+    cxt.eval 'fn(this, 10, 20)'
+
+This, again, is done for execution speed. Always wrapping `this` to pass it to ruby is a costly
+procedure which is always performed in rubyracer - no matter is it really needed. In H8 you can
+spend your resources only when it worth extra processing. From my experience, it is a rare situation
+when such a lambda needs javascript's this - but, no problem, pass it this, or whatever else
+you need ;)
+
+- there is no 'Context object initialization' - it does not work well in rubyracer so it is not
+likely used widely. We can add it later, though.
 
-- Not Yet: source information in uncaught exception in js
 
-- Script is executed in the calling ruby thread without unblocking it (for the sake of
-effectiveness). If we would release GIL and reacquire it, it would take more time. And there is no
-multithreading support yet (this one might be added soon).
 
 ## Installation
 

data/ext/h8/h8.cpp

@@ -21,13 +21,13 @@ void h8::JsError::raise() {
 				// Passing thru the Ruby exception
 				ruby_exception = rg->rubyObject();
 			} else {
-				Local<String> s = message()->Get();
+				Local<Message> m = message();
+				Local<String> s = m->Get();
 				String::Utf8Value res(s->ToString());
 				ruby_exception = ruby_exception = rb_exc_new2(js_exception,
-						*res ? *res : "test");
+						*res ? *res : "unknown javascript exception");
 				rb_iv_set(ruby_exception, "@message", h8->to_ruby(s));
-				// TODO: Pass also all information from Message instance
-				rb_iv_set(ruby_exception, "@source", h8->to_ruby(source));
+				rb_iv_set(ruby_exception, "@javascript_error", h8->to_ruby(jsx));
 			}
 		}
 		rb_exc_raise(ruby_exception);

data/ext/h8/h8.h

@@ -45,7 +45,7 @@ public:
 		reason = str_reason;
 	}
 
-	JsError(H8* h8, v8::Local<v8::Message> message, v8::Local<v8::Value> exception);
+	JsError(H8* h8, Local<Message> message, Local<Value> exception);
 
 	/**
 	 * Call it with a proper exception class and be careful - after this call no code will be executed!
@@ -56,6 +56,8 @@ public:
 
 	Local<Value> exception() const;
 
+	Local<Value> stacktrace() const;
+
 	virtual ~JsError() noexcept {
 		_message.Reset();
 		_exception.Reset();
@@ -68,9 +70,11 @@ protected:
 	v8::Persistent<v8::Value, v8::CopyablePersistentTraits<v8::Value>> _exception;
 };
 
-class JsTimeoutError : public JsError {
+class JsTimeoutError: public JsError {
 public:
-	JsTimeoutError(H8* h8) : JsError(h8, NULL) {}
+	JsTimeoutError(H8* h8) :
+			JsError(h8, NULL) {
+	}
 	virtual void raise();
 };
 
@@ -97,6 +101,7 @@ public:
 		isolate = Isolate::New();
 		Isolate::Scope isolate_scope(isolate);
 		HandleScope handle_scope(isolate);
+		isolate->SetCaptureStackTraceForUncaughtExceptions(true);
 
 		v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(
 				isolate);
@@ -113,11 +118,11 @@ public:
 	 * 				 to this value, JsTimeoutError will be thrown if exceeded
 	 * \return the value returned by the script.
 	 */
-	Handle<Value> eval(const char* script_utf,unsigned max_ms=0);
+	Handle<Value> eval(const char* script_utf, unsigned max_ms = 0);
 
-	VALUE eval_to_ruby(const char* script_utf,int timeout=0) {
+	VALUE eval_to_ruby(const char* script_utf, int timeout = 0) {
 		// TODO: throw ruby exception on error
-		return to_ruby(eval(script_utf,timeout));
+		return to_ruby(eval(script_utf, timeout));
 	}
 
 	Handle<Context> getContext() {
@@ -210,10 +215,13 @@ inline VALUE h8::H8::to_ruby(Handle<Value> value) {
 	return JsGate::to_ruby(this, value);
 }
 
-inline h8::JsError::JsError(H8* h8, v8::Local<v8::Message> message,
-		v8::Local<v8::Value> exception) :
-		h8(h8), _message(h8->getIsolate(), message), _exception(h8->getIsolate(),
-				exception), has_js_exception(true), reason(NULL) {
+inline h8::JsError::JsError(H8* h8, Local<Message> message,
+		Local<Value> exception) :
+		h8(h8),
+		_message(h8->getIsolate(), message),
+		_exception(h8->getIsolate(), exception),
+		has_js_exception(true),
+		reason(NULL) {
 }
 
 inline Local<Message> h8::JsError::message() const {
@@ -224,6 +232,4 @@ inline Local<Value> h8::JsError::exception() const {
 	return Local<Value>::New(h8->getIsolate(), _exception);
 }
 
-
-
 #endif

data/lib/h8/context.rb

@@ -37,6 +37,7 @@ module H8
     # @raise [H8::TimeoutError] if the timeout was set and expired
     def eval script, max_time: 0, timeout: 0
       timeout = max_time * 1000 if max_time > 0
+      yield(self) if block_given?
       _eval script, timeout.to_i
     end
 
@@ -83,7 +84,7 @@ module H8
       H8::Undefined
     end
 
-    private
+    protected
 
     # Set var that could be either a callable, class instance, simple value or a Class class
     # in which case constructor function will be created
@@ -106,6 +107,5 @@ module H8
     def _do_cretate_ruby_class(klass, arguments)
       klass.new *arguments.to_ruby.values
     end
-
   end
 end

data/lib/h8/value.rb

@@ -19,7 +19,7 @@ module H8
     include Comparable
 
     def inspect
-      "<H8::Value #{to_ruby}>"
+      "<H8::Value #{to_ruby rescue '(too deep)'}>"
     end
 
     # Get js object attribute by either name or index (should be Fixnum instance). It always
@@ -105,8 +105,8 @@ module H8
     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 }
+    def to_h depth=0
+      each.reduce({}) { |all, kv| all[kv[0]] = kv[1].to_ruby depth; all }
     end
 
     # Iterate over javascript object keys
@@ -125,8 +125,12 @@ module H8
     end
 
     # 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
+    # Note that this conversion looses information about source javascript class (if any).
+    #
+    # @raise H8::Error if the data structure is too deep (e.g. cyclic)
+    def to_ruby depth=0
+      depth += 1
+      raise H8::Error, "object tree too deep" if depth > 100
       case
         when integer?
           to_i
@@ -135,11 +139,11 @@ module H8
         when float?
           to_f
         when array?
-          _get_attr('length').to_i.times.map { |i| _get_index(i).to_ruby }
+          _get_attr('length').to_i.times.map { |i| _get_index(i).to_ruby depth }
         when function?
           to_proc
         when object?
-          to_h
+          to_h depth
         else
           raise Error, "Dont know how to convert #{self.class}"
       end
@@ -179,7 +183,7 @@ end
 class Object
   # It is already a ruby object. Gate objects should override
   # as need
-  def to_ruby
+  def to_ruby depth=0
     self
   end
 end

data/lib/h8/version.rb

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

data/lib/h8.rb

@@ -12,12 +12,26 @@ module H8
   # The general error caused by the script execution, e.g. uncaught javascript exceptinos and like.
   # Check #message to see the cause.
   class JsError < Error
+    # Error message
     attr :message
-    attr :source
+
+    # Javascript Error object. May be nil
+    attr :javascript_error
 
     def to_s
       message
     end
+
+    # Error name
+    def name
+      @javascript_error.name ? @javascript_error.name : message
+    end
+
+    # String that represents stack trace if any as multiline string (\n separated)
+    def javascript_backtrace
+      @javascript_error ? @javascript_error.stack : message
+    end
+
   end
 
   # Script execution is timed out (see H8::Context#eval timeout parameter)

data/spec/ruby_gate_spec.rb

@@ -16,6 +16,36 @@ describe 'ruby gate' do
     GC.start
   end
 
+  # it 'should gate callables in therubyrace mode' do
+  #   cxt      = H8::CompatibleContext.new
+  #   cxt[:fn] = -> (this, a, b) {
+  #     p this.to_s
+  #     this.offset + a + b
+  #   }
+  #
+  #   res = cxt.eval <<-End
+  #     function Test() {
+  #       this.offset = 110;
+  #       this.method = function(a,b) {
+  #         return fn(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) {
+      a + b
+    }
+    res = cxt.eval("fn(11, 22);") { |cxt|
+      cxt[:fn] = -> (a,b) { a - b }
+    }
+    res.to_i.should == -11
+  end
+
   it 'should gate callables with varargs' do
     cxt      = H8::Context.new
     cxt[:fn] = -> (*args) {
@@ -95,7 +125,29 @@ describe 'ruby gate' do
           }
   end
 
-  it 'should have information about javascript exceptions'
+  it 'should have information about javascript exceptions' do
+    # javascript_backtrace - list of strings?
+    begin
+      H8::Context.eval <<-End
+        // This is ok
+        var ok = true;
+        function bad() {
+          throw Error("test");
+        }
+        function good() {
+          bad();
+        }
+        // This is also ok
+        good();
+      End
+      fail 'did not raise error'
+    rescue H8::JsError => e
+      x  = e.javascript_error
+      e.name.should == 'Error'
+      e.message.should =~ /test/
+      e.javascript_backtrace.should =~ /at bad \(eval\:4\:17\)/
+    end
+  end
 
   context 'accessing ruby code' do
     class Base
@@ -285,4 +337,12 @@ describe 'ruby gate' do
       cxt.eval('rc.init_args').should == ['hello', 'world']
     end
   end
+
+  it 'should survive recursive constructions' do
+    a = H8::Context.eval 'a=[1,2]; a.push(a); a'
+    expect(-> { a.to_ruby }).to raise_error(H8::Error)
+    a = H8::Context.eval "a={on:2}; a['a']=a; a"
+    expect(-> { a.to_ruby }).to raise_error(H8::Error)
+    a.inspect.should =~ /too deep/
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: h8
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - sergeych
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-27 00:00:00.000000000 Z
+date: 2014-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler