rkelly-turbo 0.1.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,285 @@
+# -*- coding: utf-8 -*-
+require File.dirname(__FILE__) + "/helper"
+
+class TokenizerTest < Test::Unit::TestCase
+  def setup
+    @tokenizer = RKelly::Tokenizer.new
+  end
+
+  {
+    :space  => " ",
+    :tab => "\t",
+    :form_feed  => "\f",
+    :vertical_tab  => "\v",
+    :no_break_space  => [0x00A0].pack("U"),
+    :ogham_space_mark => [0x1680].pack("U"),
+    :en_quad => [0x2000].pack("U"),
+    :em_quad => [0x2001].pack("U"),
+    :en_space => [0x2002].pack("U"),
+    :em_space => [0x2003].pack("U"),
+    :three_per_em_space => [0x2004].pack("U"),
+    :four_per_em_space => [0x2005].pack("U"),
+    :six_per_em_space => [0x2006].pack("U"),
+    :figure_space => [0x2007].pack("U"),
+    :punctuation_space => [0x2008].pack("U"),
+    :thin_space => [0x2009].pack("U"),
+    :hair_space => [0x200a].pack("U"),
+    :narrow_no_break_space => [0x202f].pack("U"),
+    :medium_mathematical_space => [0x205f].pack("U"),
+    :ideographic_space => [0x3000].pack("U"),
+
+    # Line terminators
+    :newline  => "\n",
+    :carriage_return  => "\r",
+    :line_separator => [0x2028].pack("U"),
+    :paragraph_separator => [0x2029].pack("U"),
+  }.each do |name, char|
+    define_method(:"test_whitespace_#{name}") do
+      assert_equal([[:S, char]], @tokenizer.tokenize(char))
+    end
+  end
+
+  def assert_tokens(expected, actual)
+    assert_equal(expected, actual.select { |x| x[0] != :S })
+  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_regular_expression
+    tokens = @tokenizer.tokenize("foo = /=asdf/;")
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 ['=', '='],
+                 [:REGEXP, '/=asdf/'],
+                 [';', ';'],
+    ], tokens)
+  end
+
+  def test_regular_expression_invalid
+    tokens = @tokenizer.tokenize("foo = (1 / 2) / 3")
+    assert_tokens([[:IDENT, "foo"],
+                   ["=", "="],
+                   ["(", "("],
+                   [:NUMBER, 1],
+                   ["/", "/"],
+                   [:NUMBER, 2],
+                   [")", ")"],
+                   ["/", "/"],
+                   [:NUMBER, 3]
+                  ], tokens)
+  end
+
+  def test_regular_expression_escape
+    tokens = @tokenizer.tokenize('foo = /\/asdf/gi;')
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 ['=', '='],
+                 [:REGEXP, '/\/asdf/gi'],
+                 [';', ';'],
+    ], tokens)
+  end
+
+  def test_regular_expression_with_slash_inside_charset
+    tokens = @tokenizer.tokenize('foo = /[/]/;')
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 ['=', '='],
+                 [:REGEXP, '/[/]/'],
+                 [';', ';'],
+    ], tokens)
+  end
+
+  def test_regular_expression_is_not_found_if_prev_token_implies_division
+    {:IDENT => 'foo',
+     :TRUE => 'true',
+     :NUMBER => 1,
+     ')' => ')',
+     ']' => ']',
+     '}' => '}'}.each do |name, value|
+      tokens = @tokenizer.tokenize("#{value}/2/3")
+      assert_tokens([
+                  [name, value],
+                   ["/", "/"],
+                   [:NUMBER, 2],
+                   ["/", "/"],
+                   [:NUMBER, 3],
+      ], tokens)
+    end
+  end
+
+  def test_regular_expression_is_found_if_prev_token_is_non_literal_keyword
+    {:RETURN => 'return',
+     :THROW => 'throw'}.each do |name, value|
+      tokens = @tokenizer.tokenize("#{value}/2/")
+      assert_tokens([
+                  [name, value],
+                   [:REGEXP, "/2/"],
+      ], tokens)
+    end
+  end
+
+  def test_regular_expression_is_not_found_if_block_comment_with_re_modifier
+    tokens = @tokenizer.tokenize("/**/i")
+    assert_tokens([
+      [:COMMENT, "/**/"],
+      [:IDENT, "i"]
+    ], 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 test_unicode_string
+    tokens = @tokenizer.tokenize("foo = 'öäüõ';")
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 ['=', '='],
+                 [:STRING, "'öäüõ'"],
+                 [';', ';'],
+    ], tokens)
+  end
+
+  def test_unicode_regex
+    tokens = @tokenizer.tokenize("foo = /öäüõ/;")
+    assert_tokens([
+                 [:IDENT, 'foo'],
+                 ['=', '='],
+                 [:REGEXP, "/öäüõ/"],
+                 [';', ';'],
+    ], tokens)
+  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
+
+  %w{
+    class enum extends super export import
+  }.each do |rw|
+    define_method(:"test_future_reserved_word_#{rw}_is_reserved") do
+      tokens = @tokenizer.tokenize(rw)
+      assert_equal 1, tokens.length
+      assert_equal([[:RESERVED, rw]], tokens)
+    end
+  end
+
+  %w{
+    implements let private public yield
+    interface package protected static
+  }.each do |rw|
+    define_method(:"test_future_reserved_word_#{rw}_is_identifier") do
+      tokens = @tokenizer.tokenize(rw)
+      assert_equal 1, tokens.length
+      assert_equal([[:IDENT, rw]], 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