rkelly 1.0.0

data/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/test/test_tokenizer.rb

@@ -0,0 +1,143 @@
+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_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/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