rkelly 1.0.0

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

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

data/test/test_null_node.rb

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

data/test/test_number_node.rb

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

data/test/test_object_literal_node.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + "/helper"
+
+class ObjectLiteralNodeTest < NodeTestCase
+  def test_to_sexp
+    property = PropertyNode.new('foo', NumberNode.new(10))
+    node = ObjectLiteralNode.new([property])
+    assert_sexp([:object, [[:property, :foo, [:lit, 10]]]], node)
+  end
+end

data/test/test_op_and_equal_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class OpAndEqualNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    number  = NumberNode.new(10)
+    node = OpAndEqualNode.new(resolve, number)
+    assert_sexp([:op_and_equal, [:resolve, 'foo'], [:lit, 10]], node)
+  end
+end

data/test/test_op_divide_equal_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class OpDivideEqualNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    number  = NumberNode.new(10)
+    node = OpDivideEqualNode.new(resolve, number)
+    assert_sexp([:op_divide_equal, [:resolve, 'foo'], [:lit, 10]], node)
+  end
+end

data/test/test_op_equal_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class OpEqualNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    number  = NumberNode.new(10)
+    node = OpEqualNode.new(resolve, number)
+    assert_sexp([:op_equal, [:resolve, 'foo'], [:lit, 10]], node)
+  end
+end

data/test/test_op_l_shift_equal_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class OpLShiftEqualNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    number  = NumberNode.new(10)
+    node = OpLShiftEqualNode.new(resolve, number)
+    assert_sexp([:op_lshift_equal, [:resolve, 'foo'], [:lit, 10]], node)
+  end
+end

data/test/test_op_minus_equal_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class OpMinusEqualNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    number  = NumberNode.new(10)
+    node = OpMinusEqualNode.new(resolve, number)
+    assert_sexp([:op_minus_equal, [:resolve, 'foo'], [:lit, 10]], node)
+  end
+end

data/test/test_op_mod_equal_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class OpModEqualNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    number  = NumberNode.new(10)
+    node = OpModEqualNode.new(resolve, number)
+    assert_sexp([:op_mod_equal, [:resolve, 'foo'], [:lit, 10]], node)
+  end
+end

data/test/test_op_multiply_equal_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class OpMultiplyEqualNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    number  = NumberNode.new(10)
+    node = OpMultiplyEqualNode.new(resolve, number)
+    assert_sexp([:op_multiply_equal, [:resolve, 'foo'], [:lit, 10]], node)
+  end
+end

data/test/test_op_or_equal_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class OpOrEqualNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    number  = NumberNode.new(10)
+    node = OpOrEqualNode.new(resolve, number)
+    assert_sexp([:op_or_equal, [:resolve, 'foo'], [:lit, 10]], node)
+  end
+end

data/test/test_op_plus_equal_node.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + "/helper"
+
+class OpPlusEqualNodeTest < NodeTestCase
+  def test_to_sexp
+    resolve = ResolveNode.new('foo')
+    number  = NumberNode.new(10)
+    node = OpPlusEqualNode.new(resolve, number)
+    assert_sexp([:op_plus_equal, [:resolve, 'foo'], [:lit, 10]], node)
+  end
+end