rkelly_for_reef 1.0.8

data/test/test_do_while_node.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/helper"
+
+class DoWhileNodeTest < NodeTestCase
+  def test_to_sepx
+    initializer = AssignExprNode.new(NumberNode.new(10))
+    decl = VarDeclNode.new('foo', initializer)
+    stmt = VarStatementNode.new([decl])
+    node = DoWhileNode.new(stmt, TrueNode.new('true'))
+
+    assert_sexp([:do_while, [:var, [[:var_decl, :foo, [:assign, [:lit, 10]]]]],
+                [:true]], node)
+  end
+end

data/test/test_dot_accessor_node.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + "/helper"
+
+class DotAccessorNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    node = DotAccessorNode.new(resolve, 'bar')
+    assert_sexp([:dot_access, [:resolve, 'foo'], 'bar', ], node)
+  end
+end

data/test/test_ecma_visitor.rb

@@ -0,0 +1,210 @@
+require File.dirname(__FILE__) + "/helper"
+
+class ECMAVisitorTest < Test::Unit::TestCase
+  def setup
+    @parser = RKelly::Parser.new
+  end
+
+  def test_anonymous_function_expr
+    assert_to_ecma('a = function() { };')
+  end
+
+
+  def test_this_node
+    assert_to_ecma('this.foo;')
+  end
+
+  def test_bitwise_not_node
+    assert_to_ecma('~10;')
+  end
+
+  def test_delete_node
+    assert_to_ecma('delete foo;')
+  end
+
+  def test_element_node
+    assert_to_ecma('var foo = [1];')
+  end
+
+  def test_logical_not_node
+    assert_to_ecma('!foo;')
+  end
+
+  def test_unary_minus_node
+    assert_to_ecma('-0;')
+  end
+
+  def test_return_node
+    assert_to_ecma('return foo;')
+    assert_to_ecma('return;')
+  end
+
+  def test_throw_node
+    assert_to_ecma('throw foo;')
+  end
+
+  def test_type_of_node
+    assert_to_ecma('typeof foo;')
+  end
+
+  def test_unary_plus_node
+    assert_to_ecma('+10;')
+  end
+
+  def test_void_node
+    assert_to_ecma('void(0);')
+  end
+
+  [
+    [:add, '+'],
+    [:and_equal, '&='],
+    [:bit_and, '&'],
+    [:bit_or, '|'],
+    [:bit_xor, '^'],
+    [:divide, '/'],
+    [:divide_equal, '/='],
+    [:equal_equal, '=='],
+    [:greater, '>'],
+    [:greater_or_equal, '>='],
+    [:left_shift, '<<'],
+    [:left_shift_equal, '<<='],
+    [:less_or_equal, '<='],
+    [:logical_and, '&&'],
+    [:logical_or, '||'],
+    [:minus_equal, '-='],
+    [:mod, '%'],
+    [:mod_equal, '%='],
+    [:multiply, '*'],
+    [:multiply_equal, '*='],
+    [:not_equal, '!='],
+    [:not_strict_equal, '!=='],
+    [:or_equal, '|='],
+    [:plus_equal, '+='],
+    [:right_shift, '>>'],
+    [:right_shift_equal, '>>='],
+    [:strict_equal, '==='],
+    [:subtract, '-'],
+    [:ur_shift, '>>>'],
+    [:uright_shift_equal, '>>>='],
+    [:xor_equal, '^='],
+    [:instanceof, 'instanceof'],
+  ].each do |name, value|
+    define_method(:"test_#{name}_node") do
+      assert_to_ecma("10 #{value} 20;")
+    end
+  end
+
+  def test_while_node
+    assert_to_ecma("while(true) { foo(); }")
+  end
+
+  def test_switch_node
+    assert_to_ecma("switch(a) { }")
+  end
+
+  def test_switch_case_node
+    assert_to_ecma("switch(a) {
+                   case 1:
+                    foo();
+                   break;
+    }")
+  end
+
+  def test_switch_default_node
+    assert_to_ecma("switch(a) {
+                   case 1:
+                    foo();
+                   break;
+                   default:
+                    bar();
+                   break;
+    }")
+  end
+
+  def test_do_while_node
+    assert_to_ecma("do { foo(); } while(true);")
+  end
+
+  def test_with_node
+    assert_to_ecma("with(o) { foo(); }")
+  end
+
+  def test_const_statement_node
+    assert_to_ecma("const foo;")
+  end
+
+  def test_label_node
+    assert_to_ecma("foo: var foo;")
+  end
+
+  def test_object_literal
+    assert_to_ecma("var foo = { };")
+  end
+
+  def test_property
+    assert_to_ecma("var foo = { bar: 10 };")
+  end
+
+  def test_getter_node
+    assert_to_ecma("var foo = { get a() { } };")
+  end
+
+  def test_setter_node
+    assert_to_ecma("var foo = { set a(b) { } };")
+  end
+
+  def test_bracket_access_node
+    assert_to_ecma("var foo = foo.bar[10];")
+  end
+
+  def test_new_expr_node
+    assert_to_ecma("var foo = new Array();")
+    assert_to_ecma("var foo = new Array(10);")
+    assert_to_ecma("var foo = new Array(a, 10);")
+  end
+
+  def test_try_finally
+    assert_to_ecma('try { var x = 10; } finally { var x = 20; }')
+  end
+
+  def test_try_catch
+    assert_to_ecma('try { var x = 10; } catch(a) { var x = 20; }')
+  end
+
+  def test_comma_node
+    assert_to_ecma('i = 10, j = 11;')
+  end
+
+  def test_in_node
+    assert_to_ecma('var x = 0 in foo;')
+  end
+
+  def test_if_node
+    assert_to_ecma('if(5 && 10) var foo = 20;')
+    assert_to_ecma('if(5 && 10) { var foo = 20; }')
+    assert_to_ecma('if(5 && 10) { var foo = 20; } else var foo = 10;')
+    assert_to_ecma('if(5 && 10) { var foo = 20; } else { var foo = 10; }')
+  end
+
+  def test_conditional_node
+    assert_to_ecma('var x = 5 < 10 ? 20 : 30;')
+  end
+
+  def test_for_in_node
+    assert_to_ecma('for(foo in bar) { var x = 10; }')
+    assert_to_ecma('for(var foo in bar) { var x = 10; }')
+  end
+
+  def test_for_node
+    assert_to_ecma('for(var i = 0; i < 10; i++) { var x = 10; }')
+    assert_to_ecma('var i = 0; for(; i < 10; i++) { var x = 10; }')
+    assert_to_ecma('var i; for(i = 0; i < 6; ++i) { var x = 10; }')
+  end
+
+  def assert_to_ecma(expected, actual = nil)
+    ecma = @parser.parse(actual || expected).to_ecma
+    ecma = ecma.gsub(/\n/, ' ').gsub(/\s+/, ' ')
+    expected = expected.gsub(/\n/, ' ').gsub(/\s+/, ' ')
+    assert_equal(expected, ecma)
+  end
+end

data/test/test_element_node.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/helper"
+
+class ElementNodeTest < NodeTestCase
+  def test_to_sexp
+    node = ElementNode.new(NumberNode.new(10))
+    assert_sexp([:element, [:lit, 10]], node)
+  end
+end

data/test/test_empty_statement_node.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/helper"
+
+class EmptyStatementNodeTest < NodeTestCase
+  def test_to_to_sexp
+    node = EmptyStatementNode.new(';')
+    assert_sexp([:empty], node)
+  end
+end

data/test/test_equal_node.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/helper"
+
+class EqualNodeTest < NodeTestCase
+  def test_to_sexp
+    node = EqualNode.new(NumberNode.new(5), NumberNode.new(10))
+    assert_sexp([:equal, [:lit, 5], [:lit, 10]], node)
+  end
+end

data/test/test_evaluation_visitor.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + "/helper"
+
+class EvaluationVisitorTest < Test::Unit::TestCase
+  def setup
+    @parser = RKelly::Parser.new
+    @scope = RKelly::Runtime::ScopeChain.new
+    @visitor = RKelly::Visitors::EvaluationVisitor.new(@scope)
+  end
+
+  def assert_properties(actual, js_code)
+    tree = @parser.parse(js_code)
+    @visitor.accept(tree)
+    actual.each do |property, value|
+      assert @visitor.scope_chain.has_property?(property)
+      assert_equal value, @visitor.scope_chain[property].value
+    end
+  end
+
+  def test_variable
+    assert_properties({
+      'foo' => 10,
+    }, 'var foo = 10;')
+  end
+
+  def test_add
+    assert_properties({
+      'foo' => 6,
+    }, 'var foo = 1 + 5;')
+  end
+
+  def test_subtract
+    assert_properties({
+      'foo' => 3,
+    }, 'var foo = 4 - 1;')
+  end
+
+  def test_multiply
+    assert_properties({
+      'foo' => 8,
+    }, 'var foo = 4 * 2;')
+  end
+
+  def test_divide
+    assert_properties({
+      'foo' => 2,
+    }, 'var foo = 4 / 2;')
+  end
+
+  def test_a_bunch
+    assert_properties({
+      'foo' => 2,
+    }, 'var foo = 1 + 2 * 2 / 4;')
+  end
+
+  def test_add_resolve
+    assert_properties({
+      'foo' => 3,
+    }, 'foo = 1 + 2;')
+  end
+
+  def test_plus_equal
+    assert_properties({
+      'foo' => 3,
+    }, 'var foo = 1; foo += 2;')
+  end
+end

data/test/test_expression_statement_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class ExpressionStatementNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    access = DotAccessorNode.new(resolve, 'bar')
+    node = ExpressionStatementNode.new(access)
+    assert_sexp([:expression, [:dot_access, [:resolve, 'foo'], 'bar', ]], node)
+  end
+end

data/test/test_false_node.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/helper"
+
+class FalseNodeTest < NodeTestCase
+  def test_to_sexp
+    node = FalseNode.new('false')
+    assert_sexp [:false], node
+  end
+end

data/test/test_for_in_node.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + "/helper"
+
+class ForInNodeTest < NodeTestCase
+  def test_to_sexp
+    initializer = AssignExprNode.new(NumberNode.new(10))
+    decl = VarDeclNode.new('foo', initializer)
+    stmt = VarStatementNode.new([decl])
+    block = BlockNode.new(SourceElementsNode.new([stmt]))
+
+    node = ForInNode.new(ResolveNode.new('foo'), ResolveNode.new('bar'), block)
+    assert_sexp([:for_in,
+                [:resolve, 'foo'],
+                [:resolve, 'bar'],
+                [:block, [[:var, [[:var_decl, :foo, [:assign, [:lit, 10]]]]]]]
+    ], node)
+  end
+end

data/test/test_for_node.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + "/helper"
+
+class ForNodeTest < NodeTestCase
+  def test_failure
+    initializer = AssignExprNode.new(NumberNode.new(10))
+    decl = VarDeclNode.new('foo', initializer)
+    stmt = VarStatementNode.new([decl])
+
+    compare = LessNode.new(ResolveNode.new('foo'), NumberNode.new(10))
+    exec = PostfixNode.new(ResolveNode.new('foo'), '++')
+
+    block = BlockNode.new(SourceElementsNode.new([stmt]))
+
+    node = ForNode.new(nil, nil, nil, block)
+    assert_sexp([:for, nil, nil, nil, [:block, [[:var, [[:var_decl, :foo, [:assign, [:lit, 10]]]]]]]], node)
+
+    node = ForNode.new(stmt, compare, exec, block)
+    assert_sexp([:for,
+                [:var, [[:var_decl, :foo, [:assign, [:lit, 10]]]]],
+                [:less, [:resolve, 'foo'], [:lit, 10]],
+                [:postfix, [:resolve, 'foo'], '++'],
+                [:block, [[:var, [[:var_decl, :foo, [:assign, [:lit, 10]]]]]]]], node)
+  end
+end

data/test/test_function_body_node.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/helper"
+
+class FunctionBodyNodeTest < NodeTestCase
+  def test_to_sexp
+    node = FunctionBodyNode.new(SourceElementsNode.new([]))
+    assert_sexp([:func_body, []], node)
+  end
+end

data/test/test_function_call_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class FunctionCallNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    args = ArgumentsNode.new([])
+    node = FunctionCallNode.new(resolve, args)
+    assert_sexp([:function_call, [:resolve, 'foo'], [:args, []]], node)
+  end
+end

data/test/test_function_decl_node.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + "/helper"
+
+class FunctionDeclNodeTest < NodeTestCase
+  def test_to_sexp
+    body = FunctionBodyNode.new(SourceElementsNode.new([]))
+    node = FunctionDeclNode.new(nil, body)
+    assert_sexp([:func_decl, nil, [], [:func_body, []]], node)
+  end
+
+  def test_to_sexp_with_args
+    body = FunctionBodyNode.new(SourceElementsNode.new([]))
+    node = FunctionDeclNode.new(nil, body, [ParameterNode.new('a')])
+    assert_sexp([:func_decl, nil, [[:param, 'a']], [:func_body, []]],
+                node)
+  end
+end

data/test/test_function_expr_node.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + "/helper"
+
+class FunctionExprNodeTest < NodeTestCase
+  def test_to_sexp
+    body = FunctionBodyNode.new(SourceElementsNode.new([]))
+    node = FunctionExprNode.new(nil, body)
+    assert_sexp([:func_expr, nil, [], [:func_body, []]], node)
+  end
+
+  def test_to_sexp_with_args
+    body = FunctionBodyNode.new(SourceElementsNode.new([]))
+    node = FunctionExprNode.new(nil, body, [ParameterNode.new('a')])
+    assert_sexp([:func_expr, nil, [[:param, 'a']], [:func_body, []]],
+                node)
+  end
+end