execjs-xtrn 1.0.0

data/lib/execjs/wsh/repl.js

@@ -0,0 +1,41 @@
+!function(){
+
+var
+  w = WScript,
+  i = w.StdIn,
+  o = w.StdErr
+
+!function()
+{
+  var
+    fso = new ActiveXObject("Scripting.FileSystemObject"),
+    j2 = fso.GetParentFolderName(w.ScriptFullName)+"/json2.js"
+  new Function(fso.OpenTextFile(j2).ReadAll())()
+}()
+
+while(!i.AtEndOfStream)
+  o.WriteLine(wrap(i.ReadLine()))
+
+function wrap(s)
+{
+  try { s=compile(s) }
+  catch(e) { s={err: e.message || 'General error'} }
+
+  try { return JSON.stringify(s) }
+  catch(e) { return '{"err":"JSON.stringify error"}' }
+}
+
+function compile(s)
+{
+  s = JSON.parse(s)
+  if('string'!=typeof s)
+    throw Error('String expected!')
+  return ok(new Function(s)())
+}
+
+function ok(v)
+{
+  return 'undefined'==typeof v ? {} : {ok: v}
+}
+
+}()

data/lib/execjs/xtrn.rb

@@ -0,0 +1,9 @@
+%w(
+version
+engine
+child
+wsh
+node
+nvm
+init
+).each{|x| require_relative "xtrn/#{x}"}

data/lib/execjs/xtrn/child.rb

@@ -0,0 +1,57 @@
+require 'json'
+
+class ExecJS::Xtrn::Child
+
+  @@stats={c: 0} # children
+
+  def say(obj)
+    delta={
+      n: 1, # say calls
+      o: 0, # out bytes
+      i: 0, # in bytes
+      t: Time.now # time spent
+    }
+    @stdin.puts delta[:o]=JSON.generate([obj])[1...-1]
+    i=@stdout.gets
+
+    delta[:t]=Time.now-delta[:t]
+    delta[:i]=i.length
+    delta[:o]=delta[:o].length
+    @stats.each{|var| delta.each{|k, v| var[k]||=0; var[k]+=v}}
+    @stats.reject!{|var| var.delete :once }
+
+    JSON.load i
+  end
+
+  def self.stats
+    @@stats.dup
+  end
+
+  def stats(*recs)
+    @stats+=recs
+    @stats[0].dup
+  end
+
+  private
+
+  def initialize(options)
+    i=IO.pipe
+    o=IO.pipe
+
+    @pid=spawn *options[:args],
+      chdir: File.expand_path("../../#{options[:path]}", __FILE__),
+      in:    i[0],
+      err:   o[1]
+    i[0].close
+    o[1].close
+    @stdin=i[1]
+    @stdout=o[0]
+    if options[:encoding]
+      @stdin.set_encoding options[:encoding]
+      @stdout.set_encoding options[:encoding]
+    end
+    @@stats[:c]+=1
+    @stats=[{}, @@stats]
+  end
+
+end

data/lib/execjs/xtrn/engine.rb

@@ -0,0 +1,61 @@
+class ExecJS::Xtrn::Error < RuntimeError
+end
+
+class ExecJS::Xtrn::Engine
+
+  Error = ExecJS::Xtrn::Error
+
+  Run=nil # Abstract class
+
+  @stats=@@stats={c: 0}
+
+  def exec(code)
+    return if (code=code.to_s.strip).length==0
+    result=child.say code
+    result={'err'=>'Invalid JS result'} unless Hash===result
+    raise Error, result['err'] if result['err']
+    result['ok']
+  end
+
+  def eval(code)
+    return if (code=code.to_s.strip).length==0
+    exec "return eval(#{JSON.generate([code])[1...-1]})"
+  end
+
+  def call(fn, *args)
+    eval "(#{fn}).apply(this, #{JSON.dump args})"
+  end
+
+  def self.exec(code)
+    new.exec code
+  end
+
+  def self.eval(code)
+    new.eval code
+  end
+
+  def self.compile(code='')
+    new.tap{|ctx| ctx.exec code}
+  end
+
+  def self.stats
+    (@stats||{}).dup
+  end
+
+  def stats
+    (@stats||{}).dup
+  end
+
+  private
+
+  def child
+    return @child if @child
+    raise NotImplementedError, self.class unless self.class::Run
+    @child=child=ExecJS::Xtrn::Child.new(self.class::Run)
+    child.stats @stats={}, @@stats, classStats=self.class.class_eval{@stats||={c: 0}}
+    @@stats[:c]+=1
+    classStats[:c]+=1
+    child
+  end
+
+end

data/lib/execjs/xtrn/init.rb

@@ -0,0 +1,25 @@
+module ExecJS::Xtrn
+
+  Engines=[Nvm, Node, Wsh]
+
+  class << self
+    attr_accessor :engine
+  end
+
+  # Find best available Engine
+  self.engine=Engines.find{|k| k::Valid} || Engine
+
+  # Install into ExecJS
+  def self.init
+    slf=self
+    sc=(class<<ExecJS;self;end)
+    Engine.methods(false).each{|m| sc.instance_eval{define_method(m){|*args| slf.engine.send m, *args }}}
+  end
+
+  init
+
+  def self.stats
+    Hash[([Child, Engine]+Engines).map{|k| [k.name.sub(/.*\W/, ''), k.stats]}]
+  end
+
+end

data/lib/execjs/xtrn/node.rb

@@ -0,0 +1,21 @@
+class ExecJS::Xtrn::Node < ExecJS::Xtrn::Engine
+
+  Run={
+    args: %w(? .),
+    path: 'node',
+  }
+
+  Names=%w(nodejs node)
+
+  def self.valid?
+    i=Names.index do |n|
+      Run[:args][0]=n
+      {"ok"=>42}==ExecJS::Xtrn::Child.new(Run).say('return 7*6') rescue nil
+    end
+    Run[:args][0]='!' unless i
+    !!i
+  end
+
+  Valid=valid?
+
+end

data/lib/execjs/xtrn/nvm.rb

@@ -0,0 +1,43 @@
+# Interface to Node's vm
+class ExecJS::Xtrn::Nvm < ExecJS::Xtrn::Node
+
+  def exec(code)
+    return if (code=code.to_s.strip).length==0
+    result=say vm: vm, js: code
+    result={'err'=>'Invalid JS result'} unless Hash===result
+    raise Error, result['err'] if result['err']
+    result['ok']
+  end
+
+  private
+
+  def child
+    @@child||=super
+  end
+
+  def say(code)
+    ch=@@child
+    @stats[:once]=1
+    ch.stats @stats
+    ch.say code
+  end
+
+  def vm
+    return @vm if @vm
+    c=child
+    @stats[:once]=1 if @stats # Remove @stats, added by Engine
+    @stats={}                 # Our new stats
+    vm=say({vm: 0})['vm']
+    raise Error, 'Cannot create VM' unless vm
+    cs=self.class.class_eval{@stats}
+    cs[:m]||=0
+    cs[:m]+=1
+    ObjectSpace.define_finalizer(self)do
+      cs[:x]||=0
+      cs[:x]+=1
+      c.say vm: vm rescue nil
+    end
+    @vm=vm
+  end
+
+end

data/lib/execjs/xtrn/version.rb

@@ -0,0 +1,5 @@
+module ExecJS
+  module Xtrn
+    VERSION = "1.0.0"
+  end
+end

data/lib/execjs/xtrn/wsh.rb

@@ -0,0 +1,12 @@
+class ExecJS::Xtrn::Wsh < ExecJS::Xtrn::Engine
+
+  Run={
+    args: %w(cscript //Nologo //U repl.js),
+    path: 'wsh',
+    encoding: 'UTF-16LE:UTF-8',
+  }
+
+  Valid=Gem.win_platform?
+
+  exec '//' rescue nil if Valid # Warm up
+end

data/test/child.rb

@@ -0,0 +1,32 @@
+require_relative 'shagi'
+
+class TestChild < Shagi
+
+  Children=[M::Node, M::Wsh]
+
+  def say(code)
+    @child.say code
+  end
+
+  def children
+    (1..Spawn).map do
+      Children.map{|k| k::Valid ? M::Child.new(k::Run) : nil }
+    end
+  end
+
+  def self.build
+    ancestors[1].instance_methods(false).grep(/^shag_/).each do |m|
+      Children.each_with_index  do |klass, idx|
+        (1..Spawn).each do |n|
+          define_method("test_#{m.to_s.sub /.*?_/, ''}_#{klass.name.split(/\W+/).last}_#{n}")do
+            skip unless @child=(@@children||=children)[n-1][idx]
+            send m
+          end
+        end
+      end
+    end
+  end
+
+  build
+
+end

data/test/engine.rb

@@ -0,0 +1,103 @@
+require 'coffee_script/source'
+
+class TestEngine < Minitest::Test
+
+  M=ExecJS::Xtrn
+
+  Spawn=5
+  Engines=M::Engines
+
+  def shag_methods
+    refute @engine.exec <<-EOJ
+      fib = function(n)
+      {
+        return n<2 ? 1 : fib(n-1)+fib(n-2)
+      }
+    EOJ
+    assert_equal 89, @engine.eval('fib(10)')
+    assert_equal 8,  @engine.call('fib', 5)
+    assert_equal 79, @engine.call('Math.max', 44, 27, 79, 73, 42, 4, 23, 24, 36, 13)
+  end
+
+  def shag_vars
+    assert_raises(M::Error){ @engine.eval 'localVar' }
+    refute @engine.exec 'var localVar=1'
+    assert_raises(M::Error){ @engine.eval 'localVar' }
+
+    assert_raises(M::Error){ @engine.eval 'globalVar' }
+    refute @engine.exec "globalVar=#{v=rand 1000}"
+    assert_equal v, @engine.eval('globalVar')
+  end
+
+  def shag_coffee
+    @engine.exec File.read CoffeeScript::Source.bundled_path
+    assert_equal 3, @engine.call('CoffeeScript.compile', "->").split(/\Wfunction\W/).length
+    r=rand 100
+    assert_equal [r], @engine.eval(@engine.call 'CoffeeScript.compile', "do->[#{r}]", bare: true)
+    assert_equal 3, @engine.call('CoffeeScript.eval', 'Math.round Math.PI')
+  end
+
+  def shag_stats
+    @engine.exec '//'
+    s=@engine.stats
+    @engine.exec ' '
+    assert_equal s[:n], @engine.stats[:n]
+    @engine.exec '[]'
+    assert_equal s[:n]+1, @engine.stats[:n]
+    assert_equal 1, M::Nvm.stats[:c]||1
+  end
+
+  def klas_methods
+    assert_equal 4, @class.exec('return 2*2')
+    assert_equal 6, @class.eval('({x: 1+2+3}).x')
+  end
+
+  def klas_compile
+    x=@class.compile <<-EOJ
+      inc = function(x)
+      {
+        return x+1
+      }
+    EOJ
+    assert_equal 6, x.call('inc', 5)
+  end
+
+  def engines
+    (1..Spawn).map do
+      Engines.map{|k| k::Valid ? k.compile : nil }
+    end
+  end
+
+  def self.build
+    instance_methods(false).grep(/^shag_/).each do |m|
+      Engines.each_with_index  do |klass, idx|
+        (1..Spawn).each do |n|
+          define_method("test_#{m.to_s.sub /.*?_/, ''}_#{klass.name.split(/\W+/).last}_#{n}")do
+            skip unless @engine=(@@engines||=engines)[n-1][idx]
+            send m
+          end
+        end
+      end
+    end
+
+    instance_methods(false).grep(/^klas_/).each do |m|
+      Engines.each do |klass|
+          define_method("test_#{m.to_s.sub /.*?_/, ''}_#{klass.name.split(/\W+/).last}_class")do
+            skip unless klass::Valid
+            @class=klass
+            send m
+          end
+      end
+    end
+  end
+
+  build
+
+  ObjectSpace.define_finalizer(M)do
+    puts "Statistics:"
+    s=M.stats
+    len=s.keys.map(&:length).max+1
+    s.each{|k, v| puts "#{' '*(len-k.length)}#{k}: "+v.map{|k, v| "#{k}=#{v.round(3).to_s.sub /[.]?0*$/, ''}"}*', ' }
+  end
+
+end

data/test/nvm.rb

@@ -0,0 +1,36 @@
+require_relative 'shagi'
+
+class TestNvm < Shagi
+
+  Child=M::Nvm
+
+  def say(code)
+    # puts "s: child=#{@child} vm=#{@vm}, code=#{code}"
+    r=@child.say vm: @vm, js: code
+    # puts "r: #{r}"
+    r
+  end
+
+  def buildVMs
+    @@child=child=M::Child.new(Child::Run)
+    (1..Spawn).map do
+      child.say(vm: 0)['vm']
+    end
+  end
+
+  def self.build
+    ancestors[1].instance_methods(false).grep(/^shag_/).each do |m|
+      (1..Spawn).each do |n|
+        define_method("test_#{m.to_s.sub /.*?_/, ''}_#{n}")do
+          skip unless Child::Valid
+          @vm=(@@vms||=buildVMs)[n-1]
+          @child=@@child
+          send m
+        end
+      end
+    end
+  end
+
+  build
+
+end