rkelly-remix 0.0.1

data/test/test_automatic_semicolon_insertion.rb

@@ -0,0 +1,137 @@
+require File.dirname(__FILE__) + "/helper"
+
+class AutomaticSemicolonInsertionTest < Test::Unit::TestCase
+  def setup
+    @parser = RKelly::Parser.new
+  end
+
+  def test_basic_statement
+    assert_sexp(
+      [
+        [:return,
+          [:lit, 12]]
+      ],
+      @parser.parse('return 12'))
+  end
+
+  def test_multiline_expression
+    assert_sexp(
+      [
+        [:expression,
+          [:add,
+            [:lit, 1],
+            [:lit, 1]
+          ]
+        ]
+      ],
+      @parser.parse("1 +\n1"))
+  end
+
+  def test_multiple_statements
+    assert_sexp(
+      [
+        [:var,
+          [
+            [:var_decl, :foo, nil]
+          ]
+        ],
+        [:var,
+          [
+            [:var_decl, :bar, nil]
+          ]
+        ]
+      ],
+      @parser.parse("var foo\nvar bar"))
+  end
+
+  def test_bracketed_statement
+    assert_sexp(
+      [
+        [:block,
+          [
+            [:var,
+              [
+                [:var_decl, :foo, nil]
+              ]
+            ]
+          ]
+        ]
+      ],
+      @parser.parse("{var foo}"))
+  end
+
+  def test_insertion_before_plus_plus
+    assert_sexp(
+      [
+        [:expression,
+          [:op_equal,
+            [:resolve, "a"],
+            [:resolve, "b"]
+          ]
+        ],
+        [:expression,
+          [:prefix, [:resolve, "c"], "++"]
+        ]
+      ],
+      @parser.parse("a = b\n++c"))
+  end
+
+  def test_insertion_before_minus_minus
+    assert_sexp(
+      [
+        [:expression,
+          [:op_equal,
+            [:resolve, "a"],
+            [:resolve, "b"]
+          ]
+        ],
+        [:expression,
+          [:prefix, [:resolve, "c"], "--"]
+        ]
+      ],
+      @parser.parse("a = b\n--c"))
+  end
+
+  def test_insertion_after_continue
+    assert_sexp(
+      [
+        [:continue],
+        [:expression, [:resolve, "foo"]]
+      ],
+      @parser.parse("continue\nfoo"))
+  end
+
+  def test_insertion_after_break
+    assert_sexp(
+      [
+        [:break],
+        [:expression, [:resolve, "foo"]]
+      ],
+      @parser.parse("break\nfoo"))
+  end
+
+  def test_insertion_after_return
+    assert_sexp(
+      [
+        [:return],
+        [:expression, [:resolve, "foo"]]
+      ],
+      @parser.parse("return\nfoo"))
+  end
+
+  def test_insertion_after_throw
+    assert_nil @parser.parse("throw\nfoo")
+  end
+
+  def test_no_empty_statement_insertion
+    assert_nil @parser.parse("if (a > b)\nelse c = d")
+  end
+
+  def test_no_for_insertion
+    assert_nil @parser.parse("for (a;b\n){}")
+  end
+
+  def assert_sexp(expected, node)
+    assert_equal(expected, node.to_sexp)
+  end
+end

data/test/test_bit_and_node.rb

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

data/test/test_bit_or_node.rb

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

data/test/test_bit_x_or_node.rb

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

data/test/test_bitwise_not_node.rb

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

data/test/test_block_node.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + "/helper"
+
+class BlockNodeTest < NodeTestCase
+  def test_to_sexp
+    initializer = AssignExprNode.new(NumberNode.new(10))
+    var_foo = VarDeclNode.new('foo', initializer)
+
+    node = BlockNode.new(SourceElementsNode.new([]))
+    assert_sexp([:block, []], node)
+
+    node = BlockNode.new(SourceElementsNode.new([var_foo]))
+    assert_sexp([:block, [[:var_decl, :foo, [:assign, [:lit, 10]]]]], node)
+  end
+end

data/test/test_bracket_accessor_node.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + "/helper"
+
+class BracketAccessorNodeTest < NodeTestCase
+  def test_sexp
+    resolve = ResolveNode.new('foo')
+    index = NumberNode.new(10)
+    node = BracketAccessorNode.new(resolve, index)
+    assert_sexp(
+      [:bracket_access,
+        [:resolve, 'foo'],
+        [:lit, 10],
+      ],
+      node
+    )
+  end
+end

data/test/test_break_node.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + "/helper"
+
+class BreakNodeTest < NodeTestCase
+  def test_to_sexp
+    node = BreakNode.new(nil)
+    assert_sexp([:break], node)
+
+    node = BreakNode.new('foo')
+    assert_sexp([:break, 'foo'], node)
+  end
+end

data/test/test_case_block_node.rb

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

data/test/test_case_clause_node.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + "/helper"
+
+class CaseClauseNodeTest < NodeTestCase
+  def test_to_sexp
+    node = CaseClauseNode.new(ResolveNode.new('foo'))
+    assert_sexp([:case, [:resolve, 'foo'], []], node)
+
+    node = CaseClauseNode.new(nil)
+    assert_sexp([:case, nil, []], node)
+
+    node = CaseClauseNode.new(  ResolveNode.new('foo'),
+                                SourceElementsNode.new([ResolveNode.new('bar')]))
+    assert_sexp([:case, [:resolve, 'foo'], [[:resolve, 'bar']]], node)
+  end
+end

data/test/test_char_pos.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + "/helper"
+
+class CharPosTest < NodeTestCase
+  def test_advancing_empty_position
+    a = RKelly::CharPos::EMPTY
+    b = a.next("foo")
+
+    assert_equal(1, b.line)
+    assert_equal(3, b.char)
+    assert_equal(2, b.index)
+  end
+
+  def test_advancing_with_single_line_string
+    a = RKelly::CharPos.new(3,5,22)
+    b = a.next("foo bar")
+
+    assert_equal(3, b.line)
+    assert_equal(12, b.char)
+    assert_equal(29, b.index)
+  end
+
+  def test_advancing_with_multi_line_string
+    a = RKelly::CharPos.new(3,5,22)
+    b = a.next("\nfoo\nbar\nbaz")
+
+    assert_equal(6, b.line)
+    assert_equal(3, b.char)
+    assert_equal(34, b.index)
+  end
+
+  def test_advancing_with_multi_line_string_ending_with_newline
+    a = RKelly::CharPos.new(3,5,22)
+    b = a.next("\nfoo\nbar\n")
+
+    assert_equal(6, b.line)
+    assert_equal(0, b.char)
+    assert_equal(31, b.index)
+  end
+end

data/test/test_char_range.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + "/helper"
+
+class CharRangeTest < NodeTestCase
+  def test_advancing_empty_range
+    a = RKelly::CharRange::EMPTY
+    b = a.next("foo")
+
+    assert_equal(1, b.from.line)
+    assert_equal(1, b.from.char)
+    assert_equal(0, b.from.index)
+
+    assert_equal(1, b.to.line)
+    assert_equal(3, b.to.char)
+    assert_equal(2, b.to.index)
+  end
+
+  def test_advancing_with_multiline_string
+    a = RKelly::CharRange.new(RKelly::CharPos.new(1,1,0), RKelly::CharPos.new(1,1,0))
+    b = a.next("foo\nblah")
+
+    assert_equal(1, b.from.line)
+    assert_equal(2, b.from.char)
+    assert_equal(1, b.from.index)
+
+    assert_equal(2, b.to.line)
+    assert_equal(4, b.to.char)
+    assert_equal(8, b.to.index)
+  end
+end

data/test/test_comma_node.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/helper"
+
+class CommaNodeTest < NodeTestCase
+  def test_to_sexp
+    left = OpEqualNode.new(ResolveNode.new('foo'), NumberNode.new(10))
+    right = OpEqualNode.new(ResolveNode.new('bar'), NumberNode.new(11))
+    node = CommaNode.new(left, right)
+    assert_sexp([:comma,
+                [:op_equal, [:resolve, 'foo'], [:lit, 10]],
+                [:op_equal, [:resolve, 'bar'], [:lit, 11]]],
+                node)
+  end
+end

data/test/test_comments.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + "/helper"
+
+class CommentsTest < NodeTestCase
+  def test_some_comments
+    parser = RKelly::Parser.new
+    ast = parser.parse(<<-eojs)
+      /**
+       * This is an awesome test comment.
+       */
+      function aaron() { // This is a side comment
+        var x = 10;
+        return 1 + 1; // America!
+      }
+    eojs
+
+    assert ast
+    assert_equal(3, ast.comments.length)
+    assert_match('awesome', ast.comments[0].value)
+    assert_match('side', ast.comments[1].value)
+    assert_match('America', ast.comments[2].value)
+  end
+
+  def test_only_comments
+    parser = RKelly::Parser.new
+    ast = parser.parse(<<-eojs)
+      /**
+       * The first comment
+       */
+      /**
+       * This is an awesome test comment.
+       */
+    eojs
+
+    assert ast
+    assert_equal(2, ast.comments.length)
+  end
+
+  def test_empty_source_results_in_zero_comments
+    parser = RKelly::Parser.new
+    ast = parser.parse("")
+
+    assert ast
+    assert_equal(0, ast.comments.length)
+  end
+end

data/test/test_conditional_node.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + "/helper"
+
+class ConditionalNodeTest < 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 = ConditionalNode.new(and_node, stmt, stmt)
+    assert_sexp([:conditional,
+                [:and, [:lit, 5], [:lit, 10]],
+                [:var, [[:var_decl, :foo, [:assign, [:lit, 20]]]]],
+                [:var, [[:var_decl, :foo, [:assign, [:lit, 20]]]]]
+                ],
+                node)
+  end
+end

data/test/test_const_statement_node.rb

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

data/test/test_continue_node.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + "/helper"
+
+class ContinueNodeTest < NodeTestCase
+  def test_to_sexp
+    node = ContinueNode.new(nil)
+    assert_sexp([:continue], node)
+
+    node = ContinueNode.new('foo')
+    assert_sexp([:continue, 'foo'], node)
+  end
+end

data/test/test_delete_node.rb

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

data/test/test_divide_node.rb

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

data/test/test_do_while_node.rb

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

data/test/test_dot_accessor_node.rb

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

data/test/test_ecma_visitor.rb

@@ -0,0 +1,210 @@
+require File.dirname(__FILE__) + "/helper"
+
+class ECMAVisitorTest < Test::Unit::TestCase
+  def setup
+    @parser = RKelly::Parser.new
+  end
+
+  def test_anonymous_function_expr
+    assert_to_ecma('a = function() { };')
+  end
+
+
+  def test_this_node
+    assert_to_ecma('this.foo;')
+  end
+
+  def test_bitwise_not_node
+    assert_to_ecma('~10;')
+  end
+
+  def test_delete_node
+    assert_to_ecma('delete foo;')
+  end
+
+  def test_element_node
+    assert_to_ecma('var foo = [1];')
+  end
+
+  def test_logical_not_node
+    assert_to_ecma('!foo;')
+  end
+
+  def test_unary_minus_node
+    assert_to_ecma('-0;')
+  end
+
+  def test_return_node
+    assert_to_ecma('return foo;')
+    assert_to_ecma('return;')
+  end
+
+  def test_throw_node
+    assert_to_ecma('throw foo;')
+  end
+
+  def test_type_of_node
+    assert_to_ecma('typeof foo;')
+  end
+
+  def test_unary_plus_node
+    assert_to_ecma('+10;')
+  end
+
+  def test_void_node
+    assert_to_ecma('void(0);')
+  end
+
+  [
+    [:add, '+'],
+    [:and_equal, '&='],
+    [:bit_and, '&'],
+    [:bit_or, '|'],
+    [:bit_xor, '^'],
+    [:divide, '/'],
+    [:divide_equal, '/='],
+    [:equal_equal, '=='],
+    [:greater, '>'],
+    [:greater_or_equal, '>='],
+    [:left_shift, '<<'],
+    [:left_shift_equal, '<<='],
+    [:less_or_equal, '<='],
+    [:logical_and, '&&'],
+    [:logical_or, '||'],
+    [:minus_equal, '-='],
+    [:mod, '%'],
+    [:mod_equal, '%='],
+    [:multiply, '*'],
+    [:multiply_equal, '*='],
+    [:not_equal, '!='],
+    [:not_strict_equal, '!=='],
+    [:or_equal, '|='],
+    [:plus_equal, '+='],
+    [:right_shift, '>>'],
+    [:right_shift_equal, '>>='],
+    [:strict_equal, '==='],
+    [:subtract, '-'],
+    [:ur_shift, '>>>'],
+    [:uright_shift_equal, '>>>='],
+    [:xor_equal, '^='],
+    [:instanceof, 'instanceof'],
+  ].each do |name, value|
+    define_method(:"test_#{name}_node") do
+      assert_to_ecma("10 #{value} 20;")
+    end
+  end
+
+  def test_while_node
+    assert_to_ecma("while(true) { foo(); }")
+  end
+
+  def test_switch_node
+    assert_to_ecma("switch(a) { }")
+  end
+
+  def test_switch_case_node
+    assert_to_ecma("switch(a) {
+                   case 1:
+                    foo();
+                   break;
+    }")
+  end
+
+  def test_switch_default_node
+    assert_to_ecma("switch(a) {
+                   case 1:
+                    foo();
+                   break;
+                   default:
+                    bar();
+                   break;
+    }")
+  end
+
+  def test_do_while_node
+    assert_to_ecma("do { foo(); } while(true);")
+  end
+
+  def test_with_node
+    assert_to_ecma("with(o) { foo(); }")
+  end
+
+  def test_const_statement_node
+    assert_to_ecma("const foo;")
+  end
+
+  def test_label_node
+    assert_to_ecma("foo: var foo;")
+  end
+
+  def test_object_literal
+    assert_to_ecma("var foo = { };")
+  end
+
+  def test_property
+    assert_to_ecma("var foo = { bar: 10 };")
+  end
+
+  def test_getter_node
+    assert_to_ecma("var foo = { get a() { } };")
+  end
+
+  def test_setter_node
+    assert_to_ecma("var foo = { set a(b) { } };")
+  end
+
+  def test_bracket_access_node
+    assert_to_ecma("var foo = foo.bar[10];")
+  end
+
+  def test_new_expr_node
+    assert_to_ecma("var foo = new Array();")
+    assert_to_ecma("var foo = new Array(10);")
+    assert_to_ecma("var foo = new Array(a, 10);")
+  end
+
+  def test_try_finally
+    assert_to_ecma('try { var x = 10; } finally { var x = 20; }')
+  end
+
+  def test_try_catch
+    assert_to_ecma('try { var x = 10; } catch(a) { var x = 20; }')
+  end
+
+  def test_comma_node
+    assert_to_ecma('i = 10, j = 11;')
+  end
+
+  def test_in_node
+    assert_to_ecma('var x = 0 in foo;')
+  end
+
+  def test_if_node
+    assert_to_ecma('if(5 && 10) var foo = 20;')
+    assert_to_ecma('if(5 && 10) { var foo = 20; }')
+    assert_to_ecma('if(5 && 10) { var foo = 20; } else var foo = 10;')
+    assert_to_ecma('if(5 && 10) { var foo = 20; } else { var foo = 10; }')
+  end
+
+  def test_conditional_node
+    assert_to_ecma('var x = 5 < 10 ? 20 : 30;')
+  end
+
+  def test_for_in_node
+    assert_to_ecma('for(foo in bar) { var x = 10; }')
+    assert_to_ecma('for(var foo in bar) { var x = 10; }')
+  end
+
+  def test_for_node
+    assert_to_ecma('for(var i = 0; i < 10; i++) { var x = 10; }')
+    assert_to_ecma('var i = 0; for(; i < 10; i++) { var x = 10; }')
+    assert_to_ecma('var i; for(i = 0; i < 6; ++i) { var x = 10; }')
+  end
+
+  def assert_to_ecma(expected, actual = nil)
+    ecma = @parser.parse(actual || expected).to_ecma
+    ecma = ecma.gsub(/\n/, ' ').gsub(/\s+/, ' ')
+    expected = expected.gsub(/\n/, ' ').gsub(/\s+/, ' ')
+    assert_equal(expected, ecma)
+  end
+end

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