rkelly-turbo 0.1.0

data/test/statements/test_12_5-1.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + "/../helper"
+
+class Statement_12_5_1_Test < ExecuteTestCase
+  def setup
+    @runtime = RKelly::Runtime.new
+  end
+
+  def test_if_true
+    assert_execute({ 'x' => 'pass' },
+      "var x; if(true) x = 'pass'; else x = 'fail';")
+  end
+
+  def test_if_false
+    assert_execute({ 'x' => 'pass' },
+      "var x; if(false) x = 'fail'; else x = 'pass';")
+  end
+
+  def test_if_zero
+    assert_execute({ 'x' => 'pass' },
+      "var x; if(0) x = 'fail'; else x = 'pass';")
+  end
+
+  def test_if_one
+    assert_execute({ 'x' => 'pass' },
+      "var x; if(1) x = 'pass'; else x = 'fail';")
+  end
+end

data/test/test_add_node.rb

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

data/test/test_arguments_node.rb

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

data/test/test_array_node.rb

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

data/test/test_assign_expr_node.rb

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

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