tenderlove-rkelly 0.0.0.20080909095845

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

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,23 @@
+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
+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