superchris-rubyjs 0.8.2

data/test/run_benchs.rb

@@ -0,0 +1,58 @@
+require 'yaml'
+require 'tempfile'
+params = YAML.load(File.read('test/benchmark/params.yaml'))
+benchs = Dir["test/benchmark/bm_*.{rb,js}"]
+OPTS = "--opt NoArgumentArityChecks --opt OptimizeArithOps"
+
+def run_rubyjs(param, klassname, file)
+  par = param ? param.inspect : "nil" 
+  cmd_rubyjs_gen = 
+    %{./rubyjs_gen -I./test -o - -o /tmp/#{klassname} -r common -r benchmark/common #{OPTS} -m #{klassname} -a "main(undefined, #{par})" #{file}}
+
+  cmd_run_js = %{/usr/bin/time ./utils/js/run.sh 2>&1} 
+
+  result = `#{cmd_rubyjs_gen} | #{cmd_run_js}`
+  arr = result.split("\n")
+  time = arr.pop.split(" ")[2].sub(",", ".").to_f # user
+  return [file, klassname, param, time.to_f, arr.join("\n")]
+end
+
+def run_js(param, klassname, file)
+  par = param ? param.inspect : "null" 
+
+  script = ""
+  script << File.read('./test/benchmark/common.js')
+  script << "\n"
+  script << File.read(file)
+  script << "\n"
+  script << "main(#{par});"
+
+  jscode = Tempfile.new('rubyjs')
+  jscode.write(script)
+  jscode.close(false)
+
+  cmd_run_js = %{/usr/bin/time ./utils/js/run.sh 2>&1} 
+
+  result = `#{cmd_run_js} < #{jscode.path}`
+  arr = result.split("\n")
+  time = arr.pop.split(" ")[2].sub(",", ".").to_f # user
+  return [file, klassname, param, time.to_f, arr.join("\n")]
+end
+
+benchs.sort.each do |file|
+  basename = File.basename(file)[0..-4]
+  klassname = basename.gsub(/(^|_)./) {|m| m[-1,1].upcase}
+  humanname = basename.gsub('_', ' ').capitalize
+  ext = File.extname(file)
+
+  (params[klassname] || [nil]).each do |i|
+    case ext
+    when '.rb'
+      p run_rubyjs(i, klassname, file)
+    when '.js'
+      p run_js(i, klassname, file)
+    else
+      raise
+    end
+  end
+end

data/test/run_tests.rb

@@ -0,0 +1,22 @@
+require 'tempfile'
+require 'test/gen_test_suite'
+
+if ARGV.empty?
+  tests = Dir['test/test_*.rb']
+else
+  tests = Dir["test/test_{" + ARGV.join(',') + "}.rb"] 
+end
+
+rubycode = Tempfile.new('rubyjs')
+script = gen_test_suite(tests) 
+rubycode.write(script)
+rubycode.close(false)
+
+jsout = `./bin/rubyjs -I./test -a ";main()" -m TestSuite #{rubycode.path} | ./utils/js/run.sh`
+rbout = `ruby -I./test < #{rubycode.path}`
+
+if jsout == rbout
+else
+  puts "FAILED"
+  exit 1
+end

data/test/test_args.rb

@@ -0,0 +1,24 @@
+class TestArgs
+  def m(a, b=1, c="hallo", *args) 
+    p a
+    p b
+    p c
+    p args
+  end
+
+  def self.main
+    obj = new()
+
+    obj.m(0)
+    puts "--"
+    obj.m(1,2)
+    puts "--"
+    obj.m(1,2,9)
+    puts "--"
+    obj.m(1,2,9,5)
+    puts "--"
+    obj.m(1,2,9,5,6)
+    puts "--"
+    obj.m(1,2,9,5,6,7,8,9,10,11,12)
+  end
+end

data/test/test_array.rb

@@ -0,0 +1,22 @@
+require 'microunit'
+
+class TestArray < MicroUnit::TestCase
+
+  def test_array
+    a = [1, 2, `null`, [`null`, `null`, 4]]
+    assert_equal a, [1, 2, nil, [nil, nil, 4]]
+    assert a.eql? [1, 2, nil, [nil, nil, 4]] 
+  end
+  
+  def test_delete
+    a = [ "a", "b", "b", "b", "c" ]
+    a.delete "b"
+    assert_equal a, ["a", "c"]
+  end
+  
+  def test_include
+    assert [1, 2, 3].include? 5
+    assert ! [1, 3].include?(2)
+  end
+  
+end

data/test/test_case.rb

@@ -0,0 +1,35 @@
+class TestCase
+  def test
+    case 1+1
+    when 1, 3
+      puts "NOT OKAY"
+    when 2
+      puts "OKAY"
+    else
+      puts "NOT OKAY"
+    end
+
+    p (Array === [])
+    p (RuntimeError === RuntimeError.new)
+
+    case 1
+    when Fixnum 
+      puts "OK"
+    when 1
+      puts "OK"
+    end
+
+    case 4
+    when 0..3
+      puts "NOT OKAY"
+    when 1...4
+      puts "NOT OKAY"
+    when 2..4
+      puts "OKAY"
+    end
+  end
+
+  def self.main
+    new.test
+  end
+end

data/test/test_class.rb

@@ -0,0 +1,55 @@
+module X
+end
+
+class A
+  include X
+end
+
+class B < A
+end
+
+class C < B
+end
+
+class D
+end
+
+class TestClass
+  def self.main
+    p A.new.instance_of?(A) # => true
+    p A.new.instance_of?(B) # => false
+    p B.new.instance_of?(A) # => false
+    p A.new.instance_of?(X) # => false
+    p B.new.instance_of?(X) # => false
+
+    p A.new.kind_of?(A) # => true
+    p A.new.kind_of?(B) # => false
+    p B.new.kind_of?(A) # => true
+    p A.new.kind_of?(X) # => true
+    p B.new.kind_of?(X) # => true
+
+    p C.new.kind_of?(X) # => true
+    p C.new.kind_of?(A) # => true
+    p C.new.kind_of?(B) # => true
+    p C.new.kind_of?(C) # => true
+    p C.new.kind_of?(D) # => false
+    p C.new.kind_of?(Object) # => true
+    p C.new.kind_of?(Kernel) # => true
+    p C.new.kind_of?(Class) # => false
+
+    p ("hallo".class.name)
+    p (nil.class.name)
+    p (nil.instance_of?(NilClass))
+    p ("hallo".instance_of?(String))
+    p ("hallo".class)
+    p A
+    p B
+    p C
+    p D
+    p X
+
+    p X.name
+    p A.name
+    p B.name
+  end
+end

data/test/test_eql.rb

@@ -0,0 +1,9 @@
+class TestEql
+  def self.main
+    p "a".eql?("a")      # => true
+    p "a".eql?(1)        # => false
+    p "1".eql?(1)        # => false
+    p [1,2].eql?([1,2])  # => true
+    p 1.eql?("1")        # => false
+  end
+end

data/test/test_exception.rb

@@ -0,0 +1,61 @@
+class TestException
+  def self.main
+
+    p "before block"
+    begin
+      p "in block"
+    end
+    p "after block"
+
+    ###
+    begin
+      p "block"
+    rescue
+      p "rescue"
+    rescue Exception => a
+      p "another rescue"
+      p a
+    else
+      p "else"
+    end
+
+    p RuntimeError.new("test")
+
+    puts "before begin"
+    begin
+      puts "before raise"
+      raise Exception, "blah" 
+      puts "after raise"
+    rescue
+      puts "noooo"
+    rescue Exception => a
+      p a
+      puts "yes"
+    ensure
+      puts "ensure"
+    end
+    puts "after begin"
+
+    puts "--"
+
+    begin
+      puts "abc"
+      raise "r"
+    rescue
+      p $!
+      puts "b"
+    ensure
+      puts "e"
+    end
+
+    #
+    # Test arity checks
+    #
+
+    begin
+      p("hallo".to_s(2))
+    rescue ArgumentError => a
+      p a
+    end
+  end
+end

data/test/test_expr.rb

@@ -0,0 +1,12 @@
+class TestExpr
+  def test
+    i = if true then 1 else 2 end
+    p i
+    i = true or return
+    p i
+  end
+
+  def self.main
+    new.test
+  end
+end

data/test/test_hash.rb

@@ -0,0 +1,29 @@
+class TestHash
+  if $RUBYJS
+    def hash
+      `var el = {}; el["1"] = null; return el`
+    end
+  else
+    def hash
+      {"1" => nil}
+    end
+  end
+
+  def test
+    h = {"a" => 6, "b" => 7, "1" => 1, 1 => 2, "1,2" => "hello", [1,2] => "good"} 
+    p h["a"]
+    p h["b"] 
+    p h["1"]
+    p h[1]
+    p h["1,2"]
+    p h[[1,2]] 
+
+    puts "test native JS hash"
+    a = hash()
+    #p a
+  end
+
+  def self.main
+    new.test
+  end
+end

data/test/test_hot_ruby.rb

@@ -0,0 +1,146 @@
+#
+# Examples taken from: http://hotruby.accelart.jp/
+#
+class TestHotRuby
+  def sort ary
+    puts "Before insertion sort:"
+    p ary
+
+    for i in 1..(ary.length-1) do
+      n = i
+      while n >= 1 && ary[n] < ary[n - 1] do
+        if ary[n] < ary[n - 1]
+          tmp = ary[n]
+          ary[n] = ary[n - 1]
+          ary[n - 1] = tmp
+        end
+        n -= 1
+      end
+    end
+
+    puts "After insertion sort:"
+    p ary
+  end
+
+  def addPrint a, b, c
+    puts a + b + c
+  end
+
+  def self.main
+    t = new()
+
+    puts "InsertionSort"
+    t.sort [3, 6, 2, 5, 3, 7, 1, 8]
+
+    puts "Array args"
+    ary = [' World ', '!']
+    t.addPrint 'Hello', *ary
+
+    puts "Block"
+    Foo.new.main
+
+    puts "Class"
+    puts Pi::PI
+    # different precision on Ruby vs. Javascript
+    puts Pi.new.calc.to_s[0,13] 
+
+
+    puts "Const"
+    # FIXME
+=begin
+    Bar_::Baz_.new.run 
+    Bar2.new.run
+    Object::Bar2.new.run
+    Bar3.new.run
+=end
+  end
+end
+
+#
+# Block
+#
+class Hoge
+  def add_msg &block
+    block.call "is"  # s/yield/call/
+  end
+end
+  
+class Foo
+  NAME = ' - William Shakespeare'
+  def main
+    pre = "Action"
+    @space = " "
+    Hoge.new.add_msg do |msg|
+      fuga = "eloquence"
+      puts pre + @space + msg + @space + fuga + NAME
+    end
+  end
+end
+
+#
+# Class
+#
+class Pi
+  def initialize
+    @a = 355.0
+  end
+  
+  def calc
+    b = 113.0
+    return @a / b
+  end
+  
+  PI = 'PI is about'
+end
+  
+#
+# Const
+# 
+class Foo_
+  CONST = 'Foo'
+end
+
+class Bar_
+  CONST = 'Bar'
+
+  class Baz_ < Foo_
+    def run
+      puts CONST             # => "Bar"      Outer class const
+      # In this case, you have to specify if you want to see parent class const.
+      puts Foo_::CONST        # => "Foo"
+    end
+  end
+end
+  
+class Foo2
+  CONST = 'Foo'
+end
+  
+CONST = 'Object'
+  
+class Bar2 < Foo2
+  def run
+    puts CONST               # => "Foo"
+  end
+end
+
+# If you specify "Object", then const in Object is searched before.
+class Object
+  class Bar2 < Foo2
+    def run
+      puts CONST             # => "Object"
+    end
+  end
+end
+  
+class Foo3
+  CONST = 'Foo'
+end
+class Bar3 < Foo3
+  def run
+    puts CONST               # => "Foo"
+    #CONST = 'Bar'            # Define Bar's const "CONST"
+    puts CONST               # => "Bar"  (Foo::CONST is hidden)
+    puts Foo3::CONST         # => "Foo"  (You can see by "::")
+  end
+end