h8 0.2.2 → 0.2.3

data/benchmark/knightsmove.coffee

@@ -0,0 +1,48 @@
+pad = (n, len) ->
+  len ?= 3
+  res = n.toString()
+  res = ' '+res while res.length < len
+  res
+
+shifts = [[-2, +1], [-1, +2], [+1, +2], [+2, +1], [+2, -1], [-2, -1]]
+
+class Solver
+
+  constructor: (@n, @left_free) ->
+    @nn = @n * @n
+    @n2 = @n + @n
+    @desk = []
+    @depth = 0
+    for r in [0...@n]
+      @desk.push (0 for col in [0...@n])
+    @solve 0, 0
+
+  solve: (r, c) ->
+    @desk[r][c] = ++@depth
+    return true if @depth + @left_free >= @nn
+    for [r1, c1] in @moves(r, c)
+      return true if @solve(r1, c1)
+    @desk[r][c] = 0
+    @depth--
+    false
+
+  # Coffeescript does not support generators
+  moves: (r, c) ->
+    res = []
+    for [sr, sc] in shifts
+      r1 = r + sr
+      if 0 <= r1 < @n
+        c1 = c + sc
+        if 0 <= c1 < @n && @desk[r1][c1]==0
+          res.push [r1, c1]
+    res
+
+  toString: ->
+    res = []
+    for r in [0...@n]
+      res.push ( (if x==0 then '  .' else pad(x,3)) for x in @desk[r]).join('')
+    res.join "\n"
+
+return (n, left) ->
+  new Solver(n, left).toString()
+

data/benchmark/knigthsmove.rb

@@ -0,0 +1,70 @@
+require './tools'
+
+class Solver
+
+  def initialize rank, leave_free=0
+    @n, @nn     = rank, rank*rank
+    @n2         = @n+@n
+    @leave_free = leave_free
+    @desk       = []
+    @n.times { @desk << [0] * @n }
+    @depth = 0
+    solve 0, 0
+  end
+
+  def solve r, c
+    @desk[r][c] = (@depth+=1)
+    return true if @depth == @nn-@leave_free
+    moves(r, c) { |r1, c1|
+      return true if solve(r1, c1)
+    }
+    @desk[r][c] = 0
+    @depth      -= 1
+    false
+  end
+
+  @@shifts = [[-2, +1], [-1, +2], [+1, +2], [+2, +1], [+2, -1], [-2, -1]]
+
+  def moves r, c
+    @@shifts.each { |sr, sc|
+      r1 = r + sr
+      if r1 >= 0 && r1 < @n
+        c1 = c + sc
+        if c1 >= 0 && c1 < @n
+          yield r1, c1 if @desk[r1][c1] == 0
+        end
+      end
+    }
+  end
+
+  def to_s
+    res = []
+    @n.times do |row|
+      res << @n.times.map { |col|
+        d = @desk[row][col]
+        d == 0 ? '  .' : ("%3d" % d)
+      }.join('')
+    end
+    res.join "\n"
+  end
+
+end
+
+cs = js_context.eval coffee(:knightsmove)
+
+N, L = 7, 3
+
+res1 = res2 = 0
+timing('total') {
+  tt = []
+  tt << Thread.start { timing('ruby') { res1 = Solver.new(N, L).to_s } }
+  tt << Thread.start { timing('coffee') { res2 = cs.call(N, L) } }
+  tt.each &:join
+}
+
+if res1 != res2
+  puts "WRONG RESULTS test data can not be trusted"
+  puts "Ruby:\n#{res1}"
+  puts "Coffee:\n#{res2}"
+end
+

data/benchmark/process_text.coffee

@@ -0,0 +1,12 @@
+return (text) ->
+  words = {}
+  freq = []
+  for w in text.split(/\s+/)
+    w = w.toLowerCase()
+    continue if w == 'which' || w == 'from' || w.length < 4
+    w = w[2..-1]
+    unless (rec = words[w])?.count++
+      freq.push (words[w] = { word: w, count: 1})
+  freq.sort (a,b) ->
+    b.count - a.count
+  freq[0..10]

data/benchmark/text_process.rb

@@ -0,0 +1,51 @@
+require 'h8'
+require 'pp'
+require './tools'
+
+def process_text text
+  words = {}
+  text.split(/\s+/).each { |w|
+    w.downcase!
+    next if w == 'which' || w == 'from' || w.length < 4
+    w           = w[2..-1]
+    rec         = words[w] ||= { word: w, count: 0 }
+    rec[:count] += 1
+  }
+  words.values.sort { |a, b| b[:count] <=> a[:count] }[0..10]
+end
+
+base = File.dirname(File.expand_path(__FILE__))
+
+text = open(base+'/big.txt').read
+text = text * 2
+
+cxt = js_context
+
+coffee_process = cxt.eval coffee(:process_text)
+
+coffee_res = ruby_res = nil
+
+t1 = Thread.start {
+  timing "ruby" do
+    ruby_res = process_text text
+  end
+}
+
+t2 = Thread.start {
+  timing "coffee" do
+    coffee_res = coffee_process.call text
+  end
+}
+
+timing 'total' do
+  t1.join
+  t2.join
+end
+
+# pp coffee_res.to_ruby[0..4]
+# pp ruby_res[0..4]
+5.times { |n|
+  coffee_res[n].word == ruby_res[n][:word] or raise "Words are different"
+  coffee_res[n].count == ruby_res[n][:count] or raise "counts are different"
+}
+

data/benchmark/tools.rb

@@ -0,0 +1,21 @@
+require 'h8'
+
+def timing name
+  s = Time.now
+  yield
+  puts "#{name}\t: #{Time.now - s}"
+rescue
+  puts "*** #{$!}"
+  raise
+end
+
+def js_context
+  cxt         = H8::Context.new
+  cxt[:print] = -> (*args) { puts args.join(' ') }
+  cxt
+end
+
+def coffee script_file_name
+  @base ||= File.dirname(File.expand_path(__FILE__))
+  H8::Coffee.compile open("#{@base}/#{script_file_name}.coffee").read
+end

data/bin/h8

@@ -0,0 +1,12 @@
+#!/bin/env ruby
+require 'h8'
+require 'h8/command'
+
+cmd = nil
+begin
+  cmd = H8::Command.new(*ARGV)
+rescue Exception => e
+  STDERR.puts "Error: #{e}\n\n#{e.backtrace.join("\n")}"
+  STDERR.puts cmd.usage
+  exit 10
+end

data/ext/h8/h8.cpp

@@ -99,14 +99,16 @@ void h8::H8::invoke(v8::Handle<v8::Script> script, Local<Value>& result) {
 #endif
 }
 
-v8::Handle<v8::Value> h8::H8::eval(const char* script_utf, unsigned max_ms) {
+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;
 
 	Handle<v8::String> script_source = String::NewFromUtf8(isolate, script_utf);
 	v8::Handle<v8::Script> script;
 	JsCatcher try_catch(this);
-	v8::ScriptOrigin origin(String::NewFromUtf8(isolate, "eval"));
+	if( source_name == NULL)
+		source_name = "eval";
+	v8::ScriptOrigin origin(String::NewFromUtf8(isolate, source_name));
 
 	script = v8::Script::Compile(script_source, &origin);
 

data/ext/h8/h8.h

@@ -125,11 +125,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,const char* script_name=NULL);
 
-	VALUE eval_to_ruby(const char* script_utf, int timeout = 0) {
+	VALUE eval_to_ruby(const char* script_utf, int timeout = 0,const char* script_name=NULL) {
 		// TODO: throw ruby exception on error
-		return to_ruby(eval(script_utf, timeout));
+		return to_ruby(eval(script_utf, timeout, script_name));
 	}
 
 	Handle<Context> getContext() {
@@ -159,6 +159,11 @@ public:
 		getContext()->Global()->Set(js(name), to_js(value));
 	}
 
+	void gc() {
+//		puts("H8 GC");
+		while(!isolate->IdleNotification(500)) {}
+	}
+
 	Local<Value> to_js(VALUE ruby_value) {
 		switch (TYPE(ruby_value)) {
 		case T_STRING:

data/ext/h8/js_gate.h

@@ -135,6 +135,9 @@ public:
 		object()->Set(v8_name, h8->to_js(value));
 	}
 
+	/**
+	 * Access indexed property from ruby environment
+	 */
 	VALUE get_index(VALUE index) {
 		H8::Scope scope(h8);
 		return h8->to_ruby(object()->Get(NUM2INT(index)));
@@ -148,11 +151,18 @@ public:
 		return value()->IsString() ? Qtrue : Qfalse;
 	}
 
+	/**
+	 * True if the wrapped object is a function
+	 */
 	VALUE is_function() {
 		H8::Scope scope(h8);
 		return value()->IsFunction();
 	}
 
+	/**
+	 * Usually unneeded function, as H8 converts undefined values to
+	 * H8::Undefined
+	 */
 	VALUE is_undefined() {
 		H8::Scope scope(h8);
 		return value()->IsUndefined() ? Qtrue : Qfalse;
@@ -166,11 +176,18 @@ public:
 		return apply(h8->getContext()->Global(), args);
 	}
 
+	/**
+	 * apply wrapped function to a given 'this' value and arguments
+	 * wrapped in the ruby array
+	 */
 	VALUE apply(VALUE self, VALUE args) const {
 		H8::Scope scope(h8);
 		return apply(h8->gateObject(self), args);
 	}
 
+	/**
+	 * @return bound ruby H8::Context instance
+	 */
 	VALUE ruby_context() const {
 		return h8->ruby_context();
 	}
@@ -185,6 +202,8 @@ public:
 		persistent_value.Reset();
 		AllocatedResource::free();
 		h8 = 0;
+		// It is used no more, and it will be GC'd by ruby, until then
+		// we can not delete it!
 	}
 
 	virtual void rb_mark_gc() {
@@ -202,9 +221,11 @@ public:
 	virtual ~JsGate() {
 		if( h8 ) {
 			Locker l(h8->getIsolate());
+//			puts("~JsGate1");
 			persistent_value.Reset();
 		}
 		else {
+//			puts("~JsGate2");
 			persistent_value.Reset();
 		}
 	}
@@ -220,6 +241,7 @@ private:
 }
 
 #include "ruby_gate.h"
+#include <ruby/encoding.h>
 
 template<class T>
 VALUE h8::JsGate::to_ruby(H8* h8, const Handle<T>& value) {
@@ -228,7 +250,9 @@ VALUE h8::JsGate::to_ruby(H8* h8, const Handle<T>& value) {
 	if (v->IsString()) {
 		H8::Scope scope(h8);
 		String::Utf8Value res(v);
-		return *res ? rb_str_new2(*res) : Qnil;
+		if( *res )
+			return rb_enc_str_new(*res, res.length(), rb_utf8_encoding());
+		return Qnil;
 	}
 	if (v->IsInt32()) {
 		return INT2FIX(v->Int32Value());

data/ext/h8/main.cpp

@@ -29,7 +29,7 @@ VALUE protect_ruby(const std::function<VALUE()> &block) {
 }
 
 static void rvalue_free(void* ptr) {
-	delete (JsGate*) ptr;
+	delete ((JsGate*) ptr);
 }
 
 static void rvalue_mark(void* ptr) {
@@ -126,21 +126,27 @@ inline H8* rc(VALUE self) {
 	return prcxt;
 }
 
-static VALUE context_eval(VALUE self, VALUE script,VALUE timeout) {
+static VALUE context_eval(VALUE self, VALUE script,VALUE timeout,VALUE script_name_ruby) {
 	return protect_ruby([&] {
 		H8* cxt = rc(self);//		v8::Locker l(cxt->getIsolate());
 		H8::Scope s(cxt);
-		return cxt->eval_to_ruby(StringValueCStr(script), FIX2INT(timeout));
+		const char* script_name = script_name_ruby != Qnil ? StringValueCStr(script_name_ruby) : NULL;
+		return cxt->eval_to_ruby(StringValueCStr(script), FIX2INT(timeout), script_name);
 	});
 }
 
 static VALUE context_set_var(VALUE self, VALUE name, VALUE value) {
-	return protect_ruby([=] {
+	return protect_ruby([&] {
 		rc(self)->set_var(name, value);
 		return Qnil;
 	});
 }
 
+static VALUE context_force_gc(VALUE self) {
+	rc(self)->gc();
+	return Qnil;
+}
+
 static void context_free(void* ptr) {
 	delete (H8*) ptr;
 }
@@ -176,9 +182,10 @@ void Init_h8(void) {
 	context_class = rb_define_class_under(h8, "Context", rb_cObject);
 	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, "_eval", (ruby_method) context_eval, 3);
 	rb_define_method(context_class, "_set_var", (ruby_method) context_set_var,
 			2);
+	rb_define_method(context_class, "javascript_gc", (ruby_method) context_force_gc, 0);
 
 	value_class = rb_define_class_under(h8, "Value", rb_cObject);
 	rb_define_alloc_func(value_class, rvalue_alloc);

data/ext/h8/object_wrap.h

@@ -26,111 +26,105 @@
 #include <include/v8.h>
 #include <assert.h>
 
-
 namespace h8 {
 
 class ObjectWrap {
- public:
-  ObjectWrap() {
-    refs_ = 0;
-  }
-
-
-  virtual ~ObjectWrap() {
-    if (persistent().IsEmpty())
-      return;
-    assert(persistent().IsNearDeath());
-    persistent().ClearWeak();
-    persistent().Reset();
-  }
-
-
-  template <class T>
-  static inline T* Unwrap(v8::Handle<v8::Object> handle) {
-    assert(!handle.IsEmpty());
-    assert(handle->InternalFieldCount() > 0);
-    // Cast to ObjectWrap before casting to T.  A direct cast from void
-    // to T won't work right when T has more than one base class.
-    void* ptr = handle->GetAlignedPointerFromInternalField(0);
-    ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);
-    return static_cast<T*>(wrap);
-  }
-
-
-  inline v8::Local<v8::Object> handle() {
-    return handle(v8::Isolate::GetCurrent());
-  }
-
-
-  inline v8::Local<v8::Object> handle(v8::Isolate* isolate) {
-    return v8::Local<v8::Object>::New(isolate, persistent());
-  }
-
-
-  inline v8::Persistent<v8::Object>& persistent() {
-    return handle_;
-  }
-
-
- protected:
-  inline void Wrap(v8::Handle<v8::Object> handle) {
-    assert(persistent().IsEmpty());
-    assert(handle->InternalFieldCount() > 0);
-    handle->SetAlignedPointerInInternalField(0, this);
-    persistent().Reset(v8::Isolate::GetCurrent(), handle);
-    MakeWeak();
-  }
-
-
-  inline void MakeWeak(void) {
-    persistent().SetWeak(this, WeakCallback);
-    persistent().MarkIndependent();
-  }
-
-  /* Ref() marks the object as being attached to an event loop.
-   * Refed objects will not be garbage collected, even if
-   * all references are lost.
-   */
-  virtual void Ref() {
-    assert(!persistent().IsEmpty());
-    persistent().ClearWeak();
-    refs_++;
-  }
-
-  /* Unref() marks an object as detached from the event loop.  This is its
-   * default state.  When an object with a "weak" reference changes from
-   * attached to detached state it will be freed. Be careful not to access
-   * the object after making this call as it might be gone!
-   * (A "weak reference" means an object that only has a
-   * persistant handle.)
-   *
-   * DO NOT CALL THIS FROM DESTRUCTOR
-   */
-  virtual void Unref() {
-    assert(!persistent().IsEmpty());
-    assert(!persistent().IsWeak());
-    assert(refs_ > 0);
-    if (--refs_ == 0)
-      MakeWeak();
-  }
-
-  int refs_;  // ro
-
- private:
-  static void WeakCallback(
-      const v8::WeakCallbackData<v8::Object, ObjectWrap>& data) {
-    v8::Isolate* isolate = data.GetIsolate();
-    v8::HandleScope scope(isolate);
-    ObjectWrap* wrap = data.GetParameter();
-    assert(wrap->refs_ == 0);
-    assert(wrap->handle_.IsNearDeath());
-    assert(
-        data.GetValue() == v8::Local<v8::Object>::New(isolate, wrap->handle_));
-    wrap->handle_.Reset();
-    delete wrap;
-  }
-
-  v8::Persistent<v8::Object> handle_;
+public:
+	ObjectWrap() {
+		refs_ = 0;
+	}
+
+	virtual ~ObjectWrap() {
+		if (persistent().IsEmpty())
+			return;
+		assert(persistent().IsNearDeath());
+		persistent().ClearWeak();
+		persistent().Reset();
+	}
+
+	template<class T>
+	static inline T* Unwrap(v8::Handle<v8::Object> handle) {
+		assert(!handle.IsEmpty());
+		assert(handle->InternalFieldCount() > 0);
+		// Cast to ObjectWrap before casting to T.  A direct cast from void
+		// to T won't work right when T has more than one base class.
+		void* ptr = handle->GetAlignedPointerFromInternalField(0);
+		ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);
+		return static_cast<T*>(wrap);
+	}
+
+	inline v8::Local<v8::Object> handle() {
+		return handle(v8::Isolate::GetCurrent());
+	}
+
+	inline v8::Local<v8::Object> handle(v8::Isolate* isolate) {
+		return v8::Local<v8::Object>::New(isolate, persistent());
+	}
+
+	inline v8::Persistent<v8::Object>& persistent() {
+		return handle_;
+	}
+
+protected:
+	inline void Wrap(v8::Handle<v8::Object> handle) {
+		assert(persistent().IsEmpty());
+		assert(handle->InternalFieldCount() > 0);
+		handle->SetAlignedPointerInInternalField(0, this);
+		persistent().Reset(v8::Isolate::GetCurrent(), handle);
+		MakeWeak();
+	}
+
+	inline void MakeWeak(void) {
+		persistent().SetWeak(this, WeakCallback);
+		persistent().MarkIndependent();
+	}
+
+	/* Ref() marks the object as being attached to an event loop.
+	 * Refed objects will not be garbage collected, even if
+	 * all references are lost.
+	 */
+	virtual void Ref() {
+		assert(!persistent().IsEmpty());
+		persistent().ClearWeak();
+		refs_++;
+	}
+
+	/* Unref() marks an object as detached from the event loop.  This is its
+	 * default state.  When an object with a "weak" reference changes from
+	 * attached to detached state it will be freed. Be careful not to access
+	 * the object after making this call as it might be gone!
+	 * (A "weak reference" means an object that only has a
+	 * persistant handle.)
+	 *
+	 * DO NOT CALL THIS FROM DESTRUCTOR
+	 */
+	virtual void Unref() {
+		assert(!persistent().IsEmpty());
+		assert(!persistent().IsWeak());
+		assert(refs_ > 0);
+		if (--refs_ == 0)
+			MakeWeak();
+	}
+
+	int refs_;  // ro
+
+private:
+	static void WeakCallback(
+			const v8::WeakCallbackData<v8::Object, ObjectWrap>& data) {
+		puts("WEAK CALLBACK!!");
+		v8::Isolate* isolate = data.GetIsolate();
+		v8::HandleScope scope(isolate);
+		ObjectWrap* wrap = data.GetParameter();
+		assert(wrap->refs_ == 0);
+		assert(wrap->handle_.IsNearDeath());
+		assert(
+				data.GetValue()
+						== v8::Local<v8::Object>::New(isolate, wrap->handle_));
+		wrap->handle_.Reset();
+		delete wrap;
+	}
+
+	v8::Persistent<v8::Object> handle_;
 };
 
 }  // namespace node