modulr 0.1.0

data/vendor/rkelly/test/test_pointcut_visitor.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + "/helper"
+
+class PointcutVisitorTest < Test::Unit::TestCase
+  include RKelly::Visitors
+  include RKelly::Nodes
+
+  def setup
+    @parser = RKelly::Parser.new
+  end
+
+  def test_visit_NumberNode
+    ast = @parser.parse('Element.update(10, 10)')
+    assert_equal(2, ast.pointcut('10').matches.length)
+  end
+
+  def test_visit_RegexpNode
+    ast = @parser.parse('Element.update(/asdf/, /asdf/)')
+    assert_equal(2, ast.pointcut('/asdf/').matches.length)
+  end
+
+  def test_visit_ContinueNode
+    ast = @parser.parse('function foo() { continue; }')
+    cut = ast.pointcut('continue')
+    assert_equal(1, cut.matches.length)
+    assert cut.matches.first.is_a?(ContinueNode)
+  end
+
+  def test_try_catch
+    ast = @parser.parse('try { Element.update(10, 10); } catch(e) { }')
+    assert_equal(1, ast.pointcut('Element.update(10, 10)').matches.length)
+    ast = @parser.parse('try { Element.update("foo", "bar"); } catch(e) { }')
+    assert_equal(1, ast.pointcut('Element.update(String, String)').matches.length)
+  end
+end

data/vendor/rkelly/test/test_postfix_node.rb

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

data/vendor/rkelly/test/test_prefix_node.rb

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

data/vendor/rkelly/test/test_property_node.rb

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

data/vendor/rkelly/test/test_regexp_node.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/helper"
+
+class RegexpNodeTest < NodeTestCase
+  def test_to_sexp
+    node = RegexpNode.new('/yay!/')
+    assert_sexp [:lit, '/yay!/'], node
+  end
+end

data/vendor/rkelly/test/test_resolve_node.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + "/helper"
+
+class ResolveNodeTest < NodeTestCase
+  def test_to_sexp
+    node = ResolveNode.new('foo')
+    assert_sexp [:resolve, 'foo'], node
+  end
+
+  def test_match
+    node = ResolveNode.new('foo')
+    node2 = ResolveNode.new('foo')
+    assert(node =~ node2)
+
+    assert(node !~ NumberNode.new(10))
+  end
+
+  def test_is_a
+    node = ResolveNode.new('foo')
+    node3 = ResolveNode.new('String')
+    assert(node3 =~ node)
+  end
+end

data/vendor/rkelly/test/test_return_node.rb

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

data/vendor/rkelly/test/test_right_shift_node.rb

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

data/vendor/rkelly/test/test_rkelly.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + "/helper"
+
+class RKellyTest < Test::Unit::TestCase
+  def test_array_access
+    assert_sexp(
+      [
+        [:var,
+          [[:var_decl, :a,
+            [:assign, [:bracket_access, [:resolve, "foo"], [:lit, 10]]],
+          ]]
+        ]
+      ],
+      RKelly.parse('var a = foo[10];'))
+  end
+
+  def assert_sexp(expected, node)
+    assert_equal(expected, node.to_sexp)
+  end
+end

data/vendor/rkelly/test/test_runtime.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + "/helper"
+
+class RuntimeTest < Test::Unit::TestCase
+  def setup
+    @runtime = RKelly::Runtime.new
+  end
+
+  def test_call_function
+    @runtime.execute("function foo(a) { return a + 2; }")
+    assert_equal(12, @runtime.call_function("foo", 10))
+  end
+end

data/vendor/rkelly/test/test_scope_chain.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + "/helper"
+
+class TestScopeChain < Test::Unit::TestCase
+  def setup
+    @scope_chain = RKelly::Runtime::ScopeChain.new
+    scope_1 = RKelly::JS::Scope.new
+    scope_1.properties[:foo] = 1
+    scope_2 = RKelly::JS::Scope.new
+    scope_2.properties[:bar] = 10
+    @scope_chain << scope_1
+    @scope_chain << scope_2
+  end
+
+  def test_global_object_in_chain
+    assert @scope_chain.has_property?('NaN')
+  end
+
+  def test_has_property
+    assert @scope_chain.has_property?(:foo)
+    assert @scope_chain.has_property?(:bar)
+    assert !@scope_chain.has_property?(:baz)
+    @scope_chain.pop
+    assert @scope_chain.has_property?(:bar).nil?
+  end
+
+  def test_find_property
+    assert_equal(10, @scope_chain[:bar])
+    assert_equal(1, @scope_chain[:foo])
+    @scope_chain.pop
+    assert(!@scope_chain.has_property?(:bar))
+  end
+
+  def test_add_property
+    assert !@scope_chain.has_property?(:baz)
+    @scope_chain[:baz] = 10
+    assert @scope_chain.has_property?(:baz)
+    @scope_chain.pop
+    assert !@scope_chain.has_property?(:baz)
+  end
+
+  def test_chain_in_block
+    assert !@scope_chain.has_property?(:baz)
+    @scope_chain.new_scope { |chain|
+      chain[:baz] = 10
+      assert @scope_chain.has_property?(:baz)
+      assert chain.has_property?(:baz)
+    }
+    assert @scope_chain.has_property?(:baz).nil?
+  end
+end

data/vendor/rkelly/test/test_setter_property_node.rb

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

data/vendor/rkelly/test/test_source_elements.rb

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

data/vendor/rkelly/test/test_strict_equal_node.rb

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

data/vendor/rkelly/test/test_string_node.rb

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

data/vendor/rkelly/test/test_subtract_node.rb

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

data/vendor/rkelly/test/test_switch_node.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + "/helper"
+
+class SwitchNodeTest < NodeTestCase
+  def test_to_sexp
+    clause = CaseClauseNode.new(  ResolveNode.new('foo'),
+                                SourceElementsNode.new([ResolveNode.new('bar')]))
+    block = CaseBlockNode.new([clause])
+    node = SwitchNode.new(ResolveNode.new('o'), block)
+    assert_sexp([:switch, [:resolve, 'o'],[:case_block, [[:case, [:resolve, 'foo'], [[:resolve, 'bar']]]]]],
+                node)
+  end
+end

data/vendor/rkelly/test/test_this_node.rb

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

data/vendor/rkelly/test/test_throw_node.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + "/helper"
+
+class ThrowNodeTest < NodeTestCase
+  def test_to_sexp
+    assert_sexp([:throw, [:lit, 10]], ThrowNode.new(NumberNode.new(10)))
+  end
+end

data/vendor/rkelly/test/test_tokenizer.rb

@@ -0,0 +1,148 @@
+require File.dirname(__FILE__) + "/helper"
+
+class TokenizerTest < Test::Unit::TestCase
+  def setup
+    @tokenizer = RKelly::Tokenizer.new
+  end
+
+  def test_comments
+    tokens = @tokenizer.tokenize("/** Fooo */")
+    assert_tokens([[:COMMENT, '/** Fooo */']], tokens)
+  end
+
+  def test_string_single_quote
+    tokens = @tokenizer.tokenize("foo = 'hello world';")
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 ['=', '='],
+                 [:STRING, "'hello world'"],
+                 [';', ';'],
+    ], tokens)
+  end
+
+  def test_string_double_quote
+    tokens = @tokenizer.tokenize('foo = "hello world";')
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 ['=', '='],
+                 [:STRING, '"hello world"'],
+                 [';', ';'],
+    ], tokens)
+  end
+
+  def test_number_parse
+    tokens = @tokenizer.tokenize('3.')
+    assert_tokens([[:NUMBER, 3.0]], tokens)
+
+    tokens = @tokenizer.tokenize('3.e1')
+    assert_tokens([[:NUMBER, 30]], tokens)
+
+    tokens = @tokenizer.tokenize('.001')
+    assert_tokens([[:NUMBER, 0.001]], tokens)
+
+    tokens = @tokenizer.tokenize('3.e-1')
+    assert_tokens([[:NUMBER, 0.30]], tokens)
+  end
+
+  def test_identifier
+    tokens = @tokenizer.tokenize("foo")
+    assert_tokens([[:IDENT, 'foo']], tokens)
+  end
+
+  def test_ignore_identifier
+    tokens = @tokenizer.tokenize("0foo")
+    assert_tokens([[:NUMBER, 0], [:IDENT, 'foo']], tokens)
+  end
+
+  def test_increment
+    tokens = @tokenizer.tokenize("foo += 1;")
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 [:PLUSEQUAL, '+='],
+                 [:NUMBER, 1],
+                 [';', ';'],
+    ], tokens)
+  end
+
+  def test_regex
+    tokens = @tokenizer.tokenize("foo = /=asdf/;")
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 ['=', '='],
+                 [:REGEXP, '/=asdf/'],
+                 [';', ';'],
+    ], tokens)
+  end
+
+  def test_regular_expression_escape
+    tokens = @tokenizer.tokenize('foo = /\/asdf/gi;')
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 ['=', '='],
+                 [:REGEXP, '/\/asdf/gi'],
+                 [';', ';'],
+    ], tokens)
+  end
+
+  def test_comment_assign
+    tokens = @tokenizer.tokenize("foo = /**/;")
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 ['=', '='],
+                 [:COMMENT, '/**/'],
+                 [';', ';'],
+    ], tokens)
+
+    tokens = @tokenizer.tokenize("foo = //;")
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 ['=', '='],
+                 [:COMMENT, '//;'],
+    ], tokens)
+  end
+
+  def assert_tokens(expected, actual)
+    assert_equal(expected, actual.select { |x| x[0] != :S })
+  end
+
+  %w{
+    break case catch continue default delete do else finally for function
+    if in instanceof new return switch this throw try typeof var void while 
+    with 
+
+    const true false null debugger
+  }.each do |kw|
+    define_method(:"test_keyword_#{kw}") do
+      tokens = @tokenizer.tokenize(kw)
+      assert_equal 1, tokens.length
+      assert_equal([[kw.upcase.to_sym, kw]], tokens)
+    end
+  end
+  {
+    '=='  => :EQEQ,
+    '!='  => :NE,
+    '===' => :STREQ,
+    '!==' => :STRNEQ,
+    '<='   => :LE,
+    '>='   => :GE,
+    '||'  => :OR,
+    '&&'  => :AND,
+    '++'  => :PLUSPLUS,
+    '--'  => :MINUSMINUS,
+    '<<'  => :LSHIFT,
+    '>>'  => :RSHIFT,
+    '>>>' => :URSHIFT,
+    '+='  => :PLUSEQUAL,
+    '-='  => :MINUSEQUAL,
+    '*='  => :MULTEQUAL,
+    'null'  => :NULL,
+    'true'  => :TRUE,
+    'false' => :FALSE,
+  }.each do |punctuator, sym|
+    define_method(:"test_punctuator_#{sym}") do
+      tokens = @tokenizer.tokenize(punctuator)
+      assert_equal 1, tokens.length
+      assert_equal([[sym, punctuator]], tokens)
+    end
+  end
+end

data/vendor/rkelly/test/test_true_node.rb

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

data/vendor/rkelly/test/test_try_node.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + "/helper"
+
+class TryNodeTest < NodeTestCase
+  def test_failure
+    var_foo = VarStatementNode.new([
+      VarDeclNode.new('foo', AssignExprNode.new(NumberNode.new(10)))
+    ])
+
+    var_bar = VarStatementNode.new([
+      VarDeclNode.new('bar', AssignExprNode.new(NumberNode.new(20)))
+    ])
+
+    var_baz = VarStatementNode.new([
+      VarDeclNode.new('baz', AssignExprNode.new(NumberNode.new(69)))
+    ])
+
+    try_block = BlockNode.new(SourceElementsNode.new([var_baz]))
+    catch_block = BlockNode.new(SourceElementsNode.new([var_bar]))
+    finally_block = BlockNode.new(SourceElementsNode.new([var_foo]))
+
+    node = TryNode.new(try_block, nil, nil, finally_block)
+    assert_sexp([ :try,
+                  [:block,
+                    [[:var, [[:var_decl, :baz, [:assign, [:lit, 69]]]]]]
+                  ],
+                  nil,
+                  nil,
+                  [:block,
+                    [[:var, [[:var_decl, :foo, [:assign, [:lit, 10]]]]]]
+                  ]
+    ], node)
+
+    node = TryNode.new(try_block, 'a', catch_block)
+    assert_sexp([ :try,
+                  [:block,
+                    [[:var, [[:var_decl, :baz, [:assign, [:lit, 69]]]]]]
+                  ],
+                  'a',
+                  [:block,
+                    [[:var, [[:var_decl, :bar, [:assign, [:lit, 20]]]]]]
+                  ],
+                  nil,
+    ], node)
+
+    node = TryNode.new(try_block, 'a', catch_block, finally_block)
+    assert_sexp([ :try,
+                  [:block,
+                    [[:var, [[:var_decl, :baz, [:assign, [:lit, 69]]]]]]
+                  ],
+                  'a',
+                  [:block,
+                    [[:var, [[:var_decl, :bar, [:assign, [:lit, 20]]]]]]
+                  ],
+                  [:block,
+                    [[:var, [[:var_decl, :foo, [:assign, [:lit, 10]]]]]]
+                  ]
+    ], node)
+  end
+end

data/vendor/rkelly/test/test_type_of_node.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/helper"
+
+class TypeOfNodeTest < NodeTestCase
+  def test_to_sexp
+    node = TypeOfNode.new(ResolveNode.new('foo'))
+    assert_sexp([:typeof, [:resolve, 'foo']], node)
+  end
+end

data/vendor/rkelly/test/test_unary_minus_node.rb

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

data/vendor/rkelly/test/test_unary_plus_node.rb

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

data/vendor/rkelly/test/test_unsigned_right_shift_node.rb

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

data/vendor/rkelly/test/test_var_decl_node.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + "/helper"
+
+class VarDeclNodeTest < NodeTestCase
+  def test_to_sexp
+    initializer = AssignExprNode.new(NumberNode.new(10))
+    node = VarDeclNode.new('foo', initializer)
+    assert_sexp [:var_decl, :foo, [:assign, [:lit, 10]]], node
+
+    node = VarDeclNode.new('foo', nil)
+    assert_sexp [:var_decl, :foo, nil], node
+  end
+
+  def test_const_to_sexp
+    initializer = AssignExprNode.new(NumberNode.new(10))
+    node = VarDeclNode.new('foo', initializer, true)
+    assert_sexp [:const_decl, :foo, [:assign, [:lit, 10]]], node
+
+    node = VarDeclNode.new('foo', nil, true)
+    assert_sexp [:const_decl, :foo, nil], node
+  end
+end

data/vendor/rkelly/test/test_var_statement_node.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + "/helper"
+
+class VarStatementNodeTest < NodeTestCase
+  def test_to_sexp
+    initializer = AssignExprNode.new(NumberNode.new(10))
+    decl = VarDeclNode.new('foo', initializer)
+    stmt = VarStatementNode.new([decl])
+
+    assert_sexp(
+      [:var, [[:var_decl, :foo, [:assign, [:lit, 10]]]]],
+      stmt
+    )
+  end
+end

data/vendor/rkelly/test/test_void_node.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + "/helper"
+
+class VoidNodeTest < NodeTestCase
+  def test_to_sexp
+    node = VoidNode.new(ResolveNode.new('foo'))
+    assert_sexp([:void, [:resolve, 'foo']], node)
+  end
+end

data/vendor/rkelly/test/test_while_node.rb

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

data/vendor/rkelly/test/test_with_node.rb

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