rkelly-turbo 0.1.0

data/lib/rkelly/visitors/visitor.rb

@@ -0,0 +1,149 @@
+module RKelly
+  module Visitors
+    class Visitor
+      TERMINAL_NODES = %w{
+        Break Continue EmptyStatement False Null Number Parameter Regexp Resolve
+        String This True
+      }
+      SINGLE_VALUE_NODES = %w{
+        Parenthetical AssignExpr BitwiseNot Block Delete Element ExpressionStatement
+        FunctionBody LogicalNot Return Throw TypeOf UnaryMinus UnaryPlus Void
+      }
+      BINARY_NODES = %w{
+        Add BitAnd BitOr BitXOr CaseClause Comma Divide DoWhile Equal Greater
+        GreaterOrEqual In InstanceOf LeftShift Less LessOrEqual LogicalAnd
+        LogicalOr Modulus Multiply NotEqual NotStrictEqual OpAndEqual
+        OpDivideEqual OpEqual OpLShiftEqual OpMinusEqual OpModEqual
+        OpMultiplyEqual OpOrEqual OpPlusEqual OpRShiftEqual OpURShiftEqual
+        OpXOrEqual RightShift StrictEqual Subtract Switch UnsignedRightShift
+        While With
+      }
+      ARRAY_VALUE_NODES = %w{
+        Arguments Array CaseBlock ConstStatement ObjectLiteral SourceElements
+        VarStatement
+      }
+      NAME_VALUE_NODES = %w{
+        Label Property GetterProperty SetterProperty VarDecl
+      }
+      PREFIX_POSTFIX_NODES  = %w{ Postfix Prefix }
+      CONDITIONAL_NODES     = %w{ If Conditional }
+      FUNC_CALL_NODES       = %w{ NewExpr FunctionCall }
+      FUNC_DECL_NODES       = %w{ FunctionExpr FunctionDecl }
+      ALL_NODES = %w{ For ForIn Try BracketAccessor DotAccessor } +
+        TERMINAL_NODES + SINGLE_VALUE_NODES + BINARY_NODES + ARRAY_VALUE_NODES +
+        NAME_VALUE_NODES + PREFIX_POSTFIX_NODES + CONDITIONAL_NODES +
+        FUNC_CALL_NODES + FUNC_DECL_NODES
+
+      def accept(target)
+        target.accept(self)
+      end
+
+      TERMINAL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") { |o| o.value }
+      end
+
+      BINARY_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [o.left && o.left.accept(self), o.value && o.value.accept(self)]
+        end
+      end
+
+      ARRAY_VALUE_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          return nil unless o.value
+          out = Array.new(length = o.value.length); i=-1
+          while (i+=1) < length
+            val = o.value[i]
+            out[i] = val ? val.accept(self) : nil
+          end
+          out
+          #o.value && o.value.map { |v| v ? v.accept(self) : nil }
+        end
+      end
+
+      NAME_VALUE_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          val = o.value
+          [o.name.to_s.to_sym, val ? val.accept(self) : nil]
+        end
+      end
+
+      SINGLE_VALUE_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          o.value.accept(self) if o.value
+        end
+      end
+
+      PREFIX_POSTFIX_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          o.operand.accept(self)
+        end
+      end
+
+      CONDITIONAL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [ o.conditions.accept(self),
+            o.value.accept(self),
+            o.else ? o.else.accept(self) : nil
+          ]
+        end
+      end
+      FUNC_CALL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          [o.value.accept(self), o.arguments.accept(self)]
+        end
+      end
+      FUNC_DECL_NODES.each do |type|
+        define_method(:"visit_#{type}Node") do |o|
+          out = Array.new(length = o.arguments.length); i = -1
+          while (i += 1) < length
+            out[i] = o.arguments[i].accept(self)
+          end
+          val = o.value
+          [
+            val ? val : nil,
+            out, #o.arguments.map { |x| x.accept(self) },
+            o.function_body.accept(self)
+          ]
+        end
+      end
+
+      def visit_ForNode(o)
+        [
+          o.init ? o.init.accept(self) : nil,
+          o.test ? o.test.accept(self) : nil,
+          o.counter ? o.counter.accept(self) : nil,
+          o.value.accept(self)
+        ]
+      end
+
+      def visit_ForInNode(o)
+        [
+          o.left.accept(self),
+          o.right.accept(self),
+          o.value.accept(self)
+        ]
+      end
+
+      def visit_TryNode(o)
+        [
+          o.value.accept(self),
+          o.catch_var ? o.catch_var : nil,
+          o.catch_block ? o.catch_block.accept(self) : nil,
+          o.finally_block ? o.finally_block.accept(self) : nil
+        ]
+      end
+
+      def visit_BracketAccessorNode(o)
+        [
+          o.value.accept(self),
+          o.accessor.accept(self)
+        ]
+      end
+
+      def visit_DotAccessorNode(o)
+        o.value.accept(self)
+      end
+    end
+  end
+end

data/test/ecma_script_test_case.rb

@@ -0,0 +1,21 @@
+class ECMAScriptTestCase < Test::Unit::TestCase
+  include RKelly::JS
+
+  if method_defined? :default_test
+    undef :default_test
+  end
+
+  def setup
+    @runtime = RKelly::Runtime.new
+    @runtime.define_function(:assert_equal) do |*args|
+      assert_equal(*args)
+    end
+    @runtime.define_function(:assert_in_delta) do |*args|
+      assert_in_delta(*args)
+    end
+  end
+
+  def js_assert_equal(expected, actual)
+    @runtime.execute("assert_equal(#{expected}, #{actual});")
+  end
+end

data/test/execute_test_case.rb

@@ -0,0 +1,16 @@
+class ExecuteTestCase < Test::Unit::TestCase
+  include RKelly::Nodes
+
+  if method_defined? :default_test
+    undef :default_test
+  end
+
+  def assert_execute(expected, code)
+    scope_chain = @runtime.execute(code)
+    expected.each do |name, value|
+      assert scope_chain.has_property?(name)
+      assert_equal value, scope_chain[name].value
+    end
+  end
+end
+

data/test/execution_contexts/test_10_1_3-1.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class ExecutionContext_10_1_3_1_Test < Test::Unit::TestCase
+  def setup
+    @runtime = RKelly::Runtime.new
+    @runtime.define_function(:assert_equal) do |*args|
+      assert_equal(*args)
+    end
+  end
+
+  def test_myfun3_void_0
+    scope_chain = @runtime.execute("
+                     function myfun3(a, b, a) {
+                      return a;
+                     }
+                     var x = myfun3(2,4);
+                     ")
+    assert scope_chain.has_property?('x')
+    #assert_equal :undefined, scope_chain['x'].value
+  end
+
+  def test_myfun3
+    scope_chain = @runtime.execute("
+                     function myfun3(a, b, a) {
+                      return a;
+                     }
+                     var x = myfun3(2,4,8);
+                     ")
+    assert scope_chain.has_property?('x')
+    assert_equal 8, scope_chain['x'].value
+  end
+end

data/test/expressions/test_11_3_1.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class Expressions_11_3_1_Test < ECMAScriptTestCase
+  def test_uninitialized
+    @runtime.execute("var MYVAR; assert_equal(NaN, MYVAR++); assert_equal(NaN, MYVAR);")
+  end
+
+  @@tests = [
+    :undefined          => [ '(void 0)', 'NaN', 'NaN'],
+    :null               => [ 'null',  '0', '1'],
+    :true               => [ 'true',  '1', '2'],
+    :false              => [ 'false', '0', '1'],
+    :positive_infinity  => [ 'Number.POSITIVE_INFINITY',
+                              'Number.POSITIVE_INFINITY',
+                              'Number.POSITIVE_INFINITY'],
+    :negative_infinity  => [ 'Number.NEGATIVE_INFINITY',
+                              'Number.NEGATIVE_INFINITY',
+                              'Number.NEGATIVE_INFINITY'],
+    :nan                => [ 'Number.NaN', 'Number.NaN', 'Number.NaN'],
+    :zero               => [ '0', '0', '1'],
+    :boolean_false      => ['new Boolean(false)', '0', '1'],
+    :boolean_true       => ['new Boolean(true)', '1', '2'],
+    :string_string      => ["'string'", 'Number.NaN', 'Number.NaN'],
+    :number_s           => ["'12345'", '12345', '12346'],
+    :negative_s         => ["'-12345'", '-12345', '-12344'],
+    :hex_s              => ["'0Xf'", '15', '16'],
+    :num_0_s            => ["'077'", '77', '78'],
+    :empty_s            => ["''", '0', '1'],
+    :obj_string_string  => ['new String("string")', 'Number.NaN', 'Number.NaN'],
+    :obj_string_num     => ['new String("12345")', '12345', '12346'],
+    :obj_negative       => ['new String("-12345")', '-12345', '-12344'],
+    :obj_hex            => ['new String("0Xf")', '15', '16'],
+    :obj_0_s            => ['new String("077")', '77', '78'],
+    :obj_empty          => ['new String("")', '0', '1'],
+  ]
+
+  def test_positive_float
+    @runtime.execute("
+                     var MYVAR=0.2345;
+                     assert_equal(0.2345, MYVAR++);
+                     assert_in_delta(1.2345, MYVAR, 0.00001);
+                     ")
+  end
+
+  def test_negative_float
+    @runtime.execute("
+                     var MYVAR=-0.2345;
+                     assert_equal(-0.2345, MYVAR++);
+                     assert_in_delta(0.7655, MYVAR, 0.00001);
+                     ")
+  end
+
+  @@tests.each do |testing|
+    testing.each do |name, values|
+      define_method(:"test_#{name}") do
+        @runtime.execute("
+                         var MYVAR=#{values[0]};
+                         assert_equal(#{values[1]}, MYVAR++);
+                         assert_equal(#{values[2]}, MYVAR);
+                         ")
+      end
+    end
+  end
+end

data/test/expressions/test_11_3_2.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class Expressions_11_3_2_Test < ECMAScriptTestCase
+  def test_uninitialized
+    @runtime.execute("var MYVAR; assert_equal(NaN, MYVAR--); assert_equal(NaN, MYVAR);")
+  end
+
+  @@tests = [
+    :undefined          => [ '(void 0)', 'NaN', 'NaN'],
+    :null               => [ 'null',  '0', '-1'],
+    :true               => [ 'true',  '1', '0'],
+    :false              => [ 'false', '0', '-1'],
+    :positive_infinity  => [ 'Number.POSITIVE_INFINITY',
+                              'Number.POSITIVE_INFINITY',
+                              'Number.POSITIVE_INFINITY'],
+    :negative_infinity  => [ 'Number.NEGATIVE_INFINITY',
+                              'Number.NEGATIVE_INFINITY',
+                              'Number.NEGATIVE_INFINITY'],
+    :nan                => [ 'Number.NaN', 'Number.NaN', 'Number.NaN'],
+    :zero               => [ '0', '0', '-1'],
+    :boolean_false      => ['new Boolean(false)', '0', '-1'],
+    :boolean_true       => ['new Boolean(true)', '1', '0'],
+    :string_string      => ["'string'", 'Number.NaN', 'Number.NaN'],
+    :number_s           => ["'12345'", '12345', '12344'],
+    :negative_s         => ["'-12345'", '-12345', '-12346'],
+    :hex_s              => ["'0Xf'", '15', '14'],
+    :num_0_s            => ["'077'", '77', '76'],
+    :empty_s            => ["''", '0', '-1'],
+    :obj_string_string  => ['new String("string")', 'Number.NaN', 'Number.NaN'],
+    :obj_string_num     => ['new String("12345")', '12345', '12344'],
+    :obj_negative       => ['new String("-12345")', '-12345', '-12346'],
+    :obj_hex            => ['new String("0Xf")', '15', '14'],
+    :obj_0_s            => ['new String("077")', '77', '76'],
+    :obj_empty          => ['new String("")', '0', '-1'],
+  ]
+
+  def test_positive_float
+    @runtime.execute("
+                     var MYVAR=0.2345;
+                     assert_equal(0.2345, MYVAR--);
+                     assert_in_delta(-0.7655, MYVAR, 0.00001);
+                     ")
+  end
+
+  def test_negative_float
+    @runtime.execute("
+                     var MYVAR=-0.2345;
+                     assert_equal(-0.2345, MYVAR--);
+                     assert_in_delta(-1.2345, MYVAR, 0.00001);
+                     ")
+  end
+
+  @@tests.each do |testing|
+    testing.each do |name, values|
+      define_method(:"test_#{name}") do
+        @runtime.execute("
+                         var MYVAR=#{values[0]};
+                         assert_equal(#{values[1]}, MYVAR--);
+                         assert_equal(#{values[2]}, MYVAR);
+                         ")
+      end
+    end
+  end
+end

data/test/expressions/test_11_4_2.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class Expressions_11_4_2_Test < Test::Unit::TestCase
+  def setup
+    @runtime = RKelly::Runtime.new
+  end
+
+  def test_void_1
+    scope_chain = @runtime.execute("var x = void(10);")
+    assert scope_chain.has_property?('x')
+    assert_equal :undefined, scope_chain['x'].value
+  end
+end

data/test/expressions/test_11_4_3.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class Typeof_11_4_3_Test < ExecuteTestCase
+  def setup
+    @runtime = RKelly::Runtime.new
+  end
+
+  def test_typeof_null
+    assert_execute({ 'x' => 'object' },
+      "var x = typeof(null);")
+  end
+
+  def test_typeof_void_0
+    assert_execute({ 'x' => 'undefined' },
+      "var x = typeof(void(0));")
+  end
+
+  def test_typeof_true
+    assert_execute({ 'x' => 'boolean' },
+      "var x = typeof(true);")
+  end
+
+  def test_typeof_false
+    assert_execute({ 'x' => 'boolean' },
+      "var x = typeof(false);")
+  end
+
+  def test_typeof_nan
+    assert_execute({ 'x' => 'number' },
+      "var x = typeof(NaN);")
+  end
+
+  def test_typeof_zero
+    assert_execute({ 'x' => 'number' }, "var x = typeof(0);")
+  end
+
+  def test_typeof_one
+    assert_execute({ 'x' => 'number' }, "var x = typeof(1);")
+  end
+
+  def test_typeof_minus_one
+    assert_execute({ 'x' => 'number' }, "var x = typeof(-1);")
+  end
+
+  def test_typeof_plus_one
+    assert_execute({ 'x' => 'number' }, "var x = typeof(+1);")
+  end
+
+  def test_typeof_zero_string
+    assert_execute({ 'x' => 'string' }, "var x = typeof('0');")
+  end
+end

data/test/expressions/test_11_4_4.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class Expressions_11_4_4_Test < ECMAScriptTestCase
+  def test_uninitialized
+    @runtime.execute("
+                     var MYVAR;
+                     assert_equal(NaN, ++MYVAR);
+                     assert_equal(NaN, MYVAR);
+                     ")
+  end
+
+  @@tests = [
+    :undefined          => ['(void 0)', 'NaN'],
+    :null               => ['null', '1'],
+    :true               => ['true', '2'],
+    :false              => ['false', '1'],
+    :positive_infinity  => ['Number.POSITIVE_INFINITY',
+                            'Number.POSITIVE_INFINITY'],
+    :negative_infinity  => ['Number.NEGATIVE_INFINITY',
+                            'Number.NEGATIVE_INFINITY'],
+    :nan                => ['Number.NaN', 'Number.NaN'],
+    :zero               => ['0', '1'],
+    #:pos_float          => ['0.2345', '1.2345'],
+    #:neg_float          => ['-0.2345', '0.7655'],
+    :boolean_false      => ['new Boolean(false)', '1'],
+    :boolean_true       => ['new Boolean(true)', '2'],
+    :string_string      => ["'string'", 'Number.NaN'],
+    :number_s           => ["'12345'", '12346'],
+    :negative_s         => ["'-12345'", '-12344'],
+    :hex_s              => ["'0Xf'", '16'],
+    :num_0_s            => ["'077'", '78'],
+    :empty_s            => ["''", '1'],
+    :obj_string_string  => ['new String("string")', 'Number.NaN'],
+    :obj_string_num     => ['new String("12345")', '12346'],
+    :obj_negative       => ['new String("-12345")', '-12344'],
+    :obj_hex            => ['new String("0Xf")', '16'],
+    :obj_0_s            => ['new String("077")', '78'],
+    :obj_empty          => ['new String("")', '1'],
+  ]
+
+  def test_positive_float
+    @runtime.execute("
+                     var MYVAR=0.2345;
+                     assert_in_delta(1.2345, ++MYVAR, 0.00001);
+                     assert_in_delta(1.2345, MYVAR, 0.00001);
+                     ")
+  end
+
+  def test_negative_float
+    @runtime.execute("
+                     var MYVAR=-0.2345;
+                     assert_in_delta(0.7655, ++MYVAR, 0.00001);
+                     assert_in_delta(0.7655, MYVAR, 0.00001);
+                     ")
+  end
+
+  @@tests.each do |testing|
+    testing.each do |name, values|
+      define_method(:"test_#{name}") do
+        @runtime.execute("
+                         var MYVAR=#{values[0]};
+                         assert_equal(#{values[1]}, ++MYVAR);
+                         assert_equal(#{values[1]}, MYVAR);
+                         ")
+      end
+    end
+  end
+end