rkelly-turbo 0.1.0

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

data/test/test_function_visitor.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + "/helper"
+
+class FunctionVisitorTest < Test::Unit::TestCase
+  def setup
+    @parser = RKelly::Parser.new
+    @scope = RKelly::Runtime::ScopeChain.new
+    @visitor = RKelly::Visitors::FunctionVisitor.new(@scope)
+  end
+
+  def test_function
+    tree = @parser.parse('function foo() { var x = 10; }')
+    @visitor.accept(tree)
+    assert @visitor.scope_chain['foo']
+
+    tree = @parser.parse('function foo() { var x = 10; function bar() {}; }')
+    @visitor.accept(tree)
+    assert @visitor.scope_chain['foo']
+    assert !@visitor.scope_chain.has_property?('bar')
+  end
+
+  def test_function_call
+    tree = @parser.parse('var x = foo(); function foo() { return 10; }')
+    @visitor.accept(tree)
+    assert @visitor.scope_chain['foo']
+  end
+end

data/test/test_getter_property_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class GetterPropertyNodeTest < NodeTestCase
+  def test_to_sexp
+    body = FunctionBodyNode.new(SourceElementsNode.new([]))
+    function = FunctionExprNode.new(nil, body)
+    node = GetterPropertyNode.new('foo', function)
+    assert_sexp([:getter, :foo, [:func_expr, nil, [], [:func_body, []]]], node)
+  end
+end

data/test/test_global_object.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + "/helper"
+
+class GlobalObjectTest < Test::Unit::TestCase
+  include RKelly::JS
+
+  def setup
+    @object = GlobalObject.new
+  end
+
+  def test_initialize
+    assert_equal :undefined, @object['prototype'].value
+    assert_equal 'GlobalObject', @object['class'].value
+  end
+
+  def test_braces
+    @object['foo'] = 'blah'
+    assert @object.has_property?('foo')
+    assert @object['foo']
+    assert_equal('blah', @object['foo'].value)
+  end
+
+  def test_undefined_brace
+    #assert_equal :undefined, @object['foo'].value
+  end
+
+  def test_delete
+    assert !@object.has_property?('foo')
+    @object['foo'] = 'blah'
+    assert @object.has_property?('foo')
+    assert @object.delete('foo')
+    assert !@object.has_property?('foo')
+  end
+
+  def test_can_put
+    @object['foo'] = 'blah'
+    @object['foo'].attributes << :read_only
+    assert @object['foo'].read_only?
+  end
+
+  def test_prototype
+    proto = GlobalObject.new
+    proto['foo'] = 'bar'
+    assert proto.has_property?('foo')
+
+    assert !@object.has_property?('foo')
+    @object['prototype'] = proto
+    assert @object.has_property?('foo')
+  end
+end

data/test/test_greater_node.rb

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

data/test/test_greater_or_equal_node.rb

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

data/test/test_if_node.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + "/helper"
+
+class IfNodeTest < NodeTestCase
+  def test_to_sexp
+    initializer = AssignExprNode.new(NumberNode.new(20))
+    decl = VarDeclNode.new('foo', initializer)
+    stmt = VarStatementNode.new([decl])
+    and_node = LogicalAndNode.new(NumberNode.new(5), NumberNode.new(10))
+    node = IfNode.new(and_node, stmt)
+
+    assert_sexp([:if,
+                [:and, [:lit, 5], [:lit, 10]],
+                [:var, [[:var_decl, :foo, [:assign, [:lit, 20]]]]]],
+                node)
+                
+  end
+end

data/test/test_in_node.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/helper"
+
+class InNodeTest < NodeTestCase
+  def test_to_sexp
+    node = InNode.new(NumberNode.new(5), ResolveNode.new('foo'))
+    assert_sexp([:in, [:lit, 5], [:resolve, 'foo']], node)
+  end
+end

data/test/test_instance_of_node.rb

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

data/test/test_label_node.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/helper"
+
+class LabelNodeTest < NodeTestCase
+  def test_to_sexp
+    initializer = AssignExprNode.new(NumberNode.new(10))
+    var = VarDeclNode.new('bar', initializer)
+    node = LabelNode.new('foo', var)
+    assert_sexp(
+                [:label, :foo,
+                  [:var_decl, :bar, [:assign, [:lit, 10]]],
+                ], node)
+  end
+end

data/test/test_left_shift_node.rb

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

data/test/test_less_node.rb

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

data/test/test_less_or_equal_node.rb

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

data/test/test_line_number.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + "/helper"
+
+class LineNumberTest < NodeTestCase
+  def test_line_numbers
+    parser = RKelly::Parser.new
+    ast = parser.parse(<<-eojs)
+      /**
+       * This is an awesome test comment.
+       */
+      function aaron() {
+        var x = 10;
+        return 1 + 1;
+      }
+    eojs
+    func = ast.pointcut(FunctionDeclNode).matches.first
+    assert func
+    assert_equal(4, func.line)
+
+    return_node = ast.pointcut(ReturnNode).matches.first
+    assert return_node
+    assert_equal(6, return_node.line)
+  end
+
+  def test_ranges
+    parser = RKelly::Parser.new
+    ast = parser.parse(<<-eojs)
+      /**
+       * This is an awesome test comment.
+       */
+      function aaron() {
+        var x = 10;
+        return 1 + 1;
+      }
+    eojs
+    func = ast.pointcut(FunctionDeclNode).matches.first
+    assert func
+    assert_equal("<{line:4 char:7 (68)}...{line:7 char:7 (135)}>", func.range.to_s)
+
+    return_node = ast.pointcut(ReturnNode).matches.first
+    assert return_node
+    assert_equal("<{line:6 char:9 (115)}...{line:6 char:21 (127)}>", return_node.range.to_s)
+  end
+
+  def test_range_of_var_statement_with_semicolon
+    parser = RKelly::Parser.new
+    ast = parser.parse(<<-eojs)
+      var x = {
+        foo: 10,
+        bar: "blah"
+      };
+    eojs
+    stmt = ast.pointcut(VarStatementNode).matches.first
+    assert_equal("<{line:1 char:7 (6)}...{line:4 char:8 (60)}>", stmt.range.to_s)
+  end
+
+  def test_range_of_var_statement_without_semicolon
+    parser = RKelly::Parser.new
+    ast = parser.parse(<<-eojs)
+      var x = {
+        foo: 10,
+        bar: "blah"
+      }
+    eojs
+    stmt = ast.pointcut(VarStatementNode).matches.first
+    assert_equal("<{line:1 char:7 (6)}...{line:4 char:7 (59)}>", stmt.range.to_s)
+  end
+
+  def test_range_of_empty_function_body
+    parser = RKelly::Parser.new
+    ast = parser.parse(<<-eojs)
+      function f () {
+      }
+    eojs
+
+    stmt = ast.pointcut(FunctionDeclNode).matches.first
+    assert_equal("<{line:1 char:7 (6)}...{line:2 char:7 (28)}>", stmt.range.to_s)
+
+    stmt = ast.pointcut(FunctionBodyNode).matches.first
+    assert_equal("<{line:1 char:21 (20)}...{line:2 char:7 (28)}>", stmt.range.to_s)
+  end
+end

data/test/test_logical_and_node.rb

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

data/test/test_logical_not_node.rb

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

data/test/test_logical_or_node.rb

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

data/test/test_modulus_node.rb

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

data/test/test_multiply_node.rb

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

data/test/test_new_expr_node.rb

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

data/test/test_not_equal_node.rb

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

data/test/test_not_strict_equal_node.rb

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