jbarnette-johnson 1.0.0.200806240111

data/test/johnson/nodes/array_literal_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class ArrayLiteralNodeTest < Johnson::NodeTestCase
+  def test_array_literal
+    assert_sexp(
+                [[:var, [[:assign, [:name, "foo"], [:array, [[:lit, 1]]]]]]],
+                @parser.parse('var foo = [1];')
+               )
+    assert_ecma(
+                'var foo = [1];',
+                @parser.parse('var foo = [1];')
+               )
+  end
+
+  def test_paren
+    assert_ecma("(a && b);", @parser.parse("(a && b)"))
+  end
+
+  def test_array_with_commas
+    assert_sexp(
+                [[:var, [[:assign, [:name, "foo"], [:array, [
+                  [:nil],
+                  [:nil],
+                  [:lit, 1]
+                ]]]]]],
+                @parser.parse('var foo = [,,1];')
+               )
+    assert_ecma(
+                'var foo = [null, null, 1];',
+                @parser.parse('var foo = [,,1];')
+               )
+    assert_sexp(
+                [[:var, [[:assign, [:name, "foo"], [:array, [
+                  [:str, 'foo'],
+                  [:nil],
+                  [:lit, 1]
+                ]]]]]],
+                @parser.parse('var foo = ["foo",,1];')
+               )
+    assert_ecma(
+                'var foo = ["foo", null, 1];',
+                @parser.parse('var foo = ["foo",,1];')
+               )
+    assert_sexp(
+                [[:var, [[:assign, [:name, "foo"], [:array, [
+                  [:name, 'bar'],
+                  [:nil],
+                  [:lit, 1]
+                ]]]]]],
+                @parser.parse('var foo = [bar,,1];')
+               )
+    assert_ecma(
+                'var foo = [bar, null, 1];',
+                @parser.parse('var foo = [bar,,1];')
+               )
+  end
+end

data/test/johnson/nodes/array_node_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class ArrayNodeTest < Johnson::NodeTestCase
+  def test_function_call
+    assert_sexp([[:function_call, [[:name, "foo"], [:name, "a"]]]],
+                @parser.parse('foo(a)'))
+    assert_ecma("foo(a);", @parser.parse("foo(a);"))
+    assert_ecma("foo(a, b);", @parser.parse("foo(a,b);"))
+  end
+
+  def test_new
+    assert_sexp([[:new, [[:name, "foo"], [:name, "a"]]]],
+                @parser.parse('new foo(a)'))
+    assert_ecma('new foo(a);', @parser.parse('new foo(a);'))
+    assert_ecma('new foo(a, b);', @parser.parse('new foo(a,b);'))
+  end
+
+  def test_comma
+    assert_sexp([[:comma,
+      [[:op_add_equal, [:name, "result"], [:name, "source"]],
+      [:op_equal, [:name, "source"], [:str, ""]]]]],
+                @parser.parse('result += source, source = "";'))
+    assert_ecma('result += source, source = "";',
+                @parser.parse('result += source, source = "";'))
+  end
+end

data/test/johnson/nodes/binary_node_test.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class BinaryNodeTest < Johnson::NodeTestCase
+  {
+    :op_equal           => '=',
+    :op_multiply_equal  => '*=',
+    :op_divide_equal    => '/=',
+    :op_add_equal       => '+=',
+    :op_subtract_equal  => '-=',
+    :op_lshift_equal    => '<<=',
+    :op_rshift_equal    => '>>=',
+    :op_urshift_equal   => '>>>=',
+    :op_bitand_equal    => '&=',
+    :op_bitxor_equal    => '^=',
+    :op_bitor_equal     => '|=',
+    :op_mod_equal       => '%=',
+    :op_multiply        => '*',
+    :op_divide          => '/',
+    :op_add             => '+',
+    :op_subtract        => '-',
+    :op_mod             => '%',
+    :op_bitand          => '&',
+    :op_lshift          => '<<',
+    :op_rshift          => '>>',
+    :op_urshift         => '>>>',
+    :op_bitxor          => '^',
+    :op_bitor           => '|',
+    :and                => '&&',
+    :or                 => '||',
+    :not_equal          => '!=',
+    :equal              => '==',
+    :strict_equal       => '===',
+    :strict_not_equal   => '!==',
+    :lt                 => '<',
+    :lt_equal           => '<=',
+    :gt                 => '>',
+    :gt_equal           => '>=',
+    :instanceof         => 'instanceof',
+  }.each do |op,sym|
+    define_method(:"test_#{op}_to_sexp") do
+      assert_sexp(
+                  [[op, [:name, 'i'], [:lit, 10]]],
+                  @parser.parse("i #{sym} 10")
+                 )
+
+      # Test optimized nodes. === and !== are not optimized
+      unless [:strict_equal, :strict_not_equal].include?(op)
+        assert_sexp(
+                    [[op, [:name, "h"], [op, [:name, 'i'], [:name, 'j']]]],
+                    @parser.parse("h #{sym} i #{sym} j")
+                   )
+      end
+    end
+
+    define_method(:"test_#{op}_to_ecma") do
+      assert_ecma("i #{sym} 10;", @parser.parse("i #{sym} 10;"))
+      assert_ecma("i #{sym} j #{sym} k;",
+                  @parser.parse("i #{sym} j #{sym} k;"))
+    end
+  end
+end

data/test/johnson/nodes/bracket_access_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class BracketAccessTest < Johnson::NodeTestCase
+  def test_to_sexp
+    assert_sexp(
+      [
+        [:var,
+          [[:assign, [:name, 'a'],
+            [:bracket_access, [:name, "foo"], [:lit, 10]],
+          ]]
+        ]
+      ],
+      @parser.parse('var a = foo[10];'))
+    assert_ecma("var a = foo[10];", @parser.parse('var a = foo[10];'))
+  end
+end

data/test/johnson/nodes/delete_test.rb

@@ -0,0 +1,11 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class DeleteNodeTest < Johnson::NodeTestCase
+  def test_delete_sexp
+    assert_sexp(
+      [[:delete, [:name, 'foo']]],
+      @parser.parse('delete foo;')
+    )
+    assert_ecma('delete foo;', @parser.parse('delete foo;'))
+  end
+end

data/test/johnson/nodes/do_while_test.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class DoWhileTest < Johnson::NodeTestCase
+  def test_do_while
+    assert_sexp([[:do_while, [:var, [[:assign, [:name, "x"], [:lit, 10]]]], [:true]]],
+                @parser.parse('do var x = 10; while(true);'))
+    assert_ecma('do var x = 10; while(true);',
+                @parser.parse('do var x = 10; while(true);'))
+    assert_ecma("do {\n  var x = 10;\n  y = 20;\n} while(true);",
+                @parser.parse('do { var x = 10; y = 20; } while(true);'))
+  end
+end

data/test/johnson/nodes/dot_accessor_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class DotAccessorTest < Johnson::NodeTestCase
+  def test_expression_statement
+    assert_sexp(
+                [[:dot_accessor, [:name, "bar"], [:name, "foo"]]],
+                @parser.parse('foo.bar;')
+               )
+    assert_sexp(
+                [[:dot_accessor, [:name, "bar"], [:name, "foo"]]],
+                @parser.parse('foo.bar')
+               )
+    assert_ecma('foo.bar;', @parser.parse('foo.bar;'))
+  end
+end

data/test/johnson/nodes/export_test.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class ExportTest < Johnson::NodeTestCase
+  def test_export
+    assert_sexp([[:export, [[:name, "name1"], [:name, "name2"]]]],
+      @parser.parse('export name1, name2;'))
+    assert_ecma('export name1, name2;', @parser.parse('export name1, name2;'))
+  end
+end

data/test/johnson/nodes/for_test.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class ForTest < Johnson::NodeTestCase
+  def test_empty_for
+    assert_sexp([[:for, nil, nil, nil, [:var, [[:assign, [:name, "x"], [:lit, 10]]]]]],
+                @parser.parse('for( ; ; ) var x = 10;'))
+    assert_ecma('for( ; ; ) var x = 10;',
+                @parser.parse('for( ; ; ) var x = 10;'))
+  end
+
+  def test_in_no_bf
+    assert_sexp([[:in, [:lit, 0], [:name, "foo"]]],
+      @parser.parse('0 in foo')
+               )
+    assert_ecma('0 in foo;', @parser.parse('0 in foo'))
+  end
+
+  def test_for_in_loop
+    assert_sexp(
+      [
+        [:for_in,
+          [:in, [:var, [[:name, "foo"]]], [:name, "bar"]],
+          [
+            [:var, [[:assign, [:name, "x"], [:lit, 10]]]]
+          ]
+      ]],
+      @parser.parse('for(var foo in bar) { var x = 10; }')
+               )
+    assert_ecma("for(var foo in bar) {\n  var x = 10;\n}",
+      @parser.parse('for(var foo in bar) { var x = 10; }'))
+  end
+
+  def test_for_loop
+    assert_sexp([
+      [:for,
+        [:op_equal, [:name, "foo"], [:lit, 10]],
+        [:lt, [:name, "foo"], [:lit, 10]],
+        [:postfix_inc, [:name, "foo"]],
+        [
+          [:var, [[:assign, [:name, "x"], [:lit, 10]]]],
+          [:var, [[:assign, [:name, "y"], [:lit, 11]]]]
+        ]
+      ]],
+      @parser.parse('for(foo = 10; foo < 10; foo++) { 
+                    var x = 10;
+                    var y = 11; }')
+               )
+    assert_ecma("for(foo = 10; foo < 10; foo++) {\n  var x = 10;\n  var y = 11;\n}",
+      @parser.parse('for(foo = 10; foo < 10; foo++) { 
+                    var x = 10;
+                    var y = 11; }')
+    )
+  end
+end

data/test/johnson/nodes/function_test.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class FunctionTest < Johnson::NodeTestCase
+  def test_anon_function_no_args_to_sexp
+    assert_sexp(
+                [[:var,
+                  [[:assign, [:name, 'foo'],
+                    [:func_expr, nil, [], []]
+                  ]]
+                ]],
+                @parser.parse("var foo = function() { }"))
+    assert_ecma('var foo = function() {  };',
+                @parser.parse("var foo = function() { }"))
+  end
+
+  def test_anon_function_one_args_to_sexp
+    assert_sexp(
+                [[:var,
+                  [[:assign, [:name, 'foo'],
+                    [:func_expr, nil, ["a"], []]
+                  ]]
+                ]],
+                @parser.parse("var foo = function(a) { }"))
+    assert_ecma('var foo = function(a) {  };',
+                @parser.parse("var foo = function(a) { }"))
+  end
+
+  def test_anon_function_two_args_to_sexp
+    assert_sexp(
+                [[:var,
+                  [[:assign, [:name, 'foo'],
+                    [:func_expr, nil, ["a",'b'], []]
+                  ]]
+                ]],
+                @parser.parse("var foo = function(a,b) { }"))
+    assert_ecma('var foo = function(a, b) {  };',
+                @parser.parse("var foo = function(a,b) { }"))
+  end
+
+  # 8 args is a threshold in spidermonkey
+  def test_anon_function_nine_args_to_sexp
+    assert_sexp(
+                [[:var,
+                  [[:assign, [:name, 'foo'],
+                    [:func_expr, nil, ('a'..'i').to_a, []]
+                  ]]
+                ]],
+      @parser.parse("var foo = function(#{('a'..'i').to_a.join(',')}) { }"))
+    assert_ecma("var foo = function(#{('a'..'i').to_a.join(', ')}) {  };",
+      @parser.parse("var foo = function(#{('a'..'i').to_a.join(',')}) { }"))
+  end
+
+  def test_named_function
+    assert_sexp(
+                [[:func_expr, 'a', ['b'], []]],
+                @parser.parse("function a(b) { }")
+               )
+    assert_ecma("function a(b) {  }",
+                @parser.parse("function a(b) { }"))
+  end
+
+  def test_named_function_with_body
+    assert_sexp(
+                [[:func_expr, 'a', ['b'],
+                  [[:op_equal, [:name, 'b'], [:lit, 10]]]]],
+                @parser.parse("function a(b) { b = 10; }")
+               )
+    assert_ecma("function a(b) {\n  b = 10;\n}",
+                @parser.parse("function a(b) { b = 10 }"))
+  end
+end

data/test/johnson/nodes/if_test.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class IfTest < Johnson::NodeTestCase
+  def test_if_no_else
+    assert_sexp([
+      [:if, [:and, [:name, "x"], [:name, "y"]],
+        [:var, [[:assign, [:name, "foo"], [:lit, 20]]]],
+        nil
+      ]], @parser.parse('if(x && y) var foo = 20;')
+    )
+    assert_ecma('if(x && y) var foo = 20;',
+      @parser.parse('if(x && y) var foo = 20;')
+    )
+  end
+
+  def test_if_else
+    assert_sexp([
+      [:if, [:and, [:lit, 5], [:lit, 10]],
+        [:var, [[:assign, [:name, "foo"], [:lit, 20]]]],
+        [:var, [[:assign, [:name, "bar"], [:lit, 5]]]]
+      ]],
+      @parser.parse('if(5 && 10) var foo = 20; else var bar = 5;')
+    )
+    assert_ecma('if(x && y) var foo = 20; else var bar = 5;',
+      @parser.parse('if(x && y) var foo = 20; else var bar = 5;')
+    )
+  end
+
+  def test_if_else_block
+    assert_sexp([
+      [:if, [:and, [:lit, 5], [:lit, 10]],
+        [[:var, [[:assign, [:name, "foo"], [:lit, 20]]]]],
+        [:var, [[:assign, [:name, "bar"], [:lit, 5]]]]
+      ]],
+      @parser.parse('if(5 && 10){ var foo = 20; } else var bar = 5;')
+    )
+    assert_ecma("if(5 && 10) {\n  var foo = 20;\n} else var bar = 5;",
+      @parser.parse('if(5 && 10){ var foo = 20; } else var bar = 5;')
+    )
+  end
+end

data/test/johnson/nodes/import_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class ImportTest < Johnson::NodeTestCase
+  def test_import
+    assert_sexp([[:import,
+      [
+        [:dot_accessor, [:name, "name1"], [:name, "o"]],
+        [:dot_accessor, [:name, "name2"], [:name, "o"]]
+      ]]], @parser.parse('import o.name1, o.name2;'))
+    assert_ecma('import o.name1, o.name2;',
+      @parser.parse('import o.name1, o.name2;'))
+  end
+end

data/test/johnson/nodes/label_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class LabelTest < Johnson::NodeTestCase
+  def test_label_statement_to_sexp
+    assert_sexp([[:label,
+                  [:name, "foo"], [:var, [[:assign, [:name, "x"], [:lit, 10]]]]
+                ]],
+                @parser.parse('foo: var x = 10;')
+               )
+    assert_sexp([[:label,
+                  [:name, "foo"], [:var, [[:assign, [:name, "x"], [:lit, 10]]]]
+                ]],
+                @parser.parse('foo: var x = 10')
+               )
+    assert_ecma('foo: var x = 10;',
+                @parser.parse('foo: var x = 10;')
+               )
+  end
+end

data/test/johnson/nodes/object_literal_test.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class ObjectLiteralTest < Johnson::NodeTestCase
+  def test_object_literal
+    assert_sexp(
+                [[:var,
+                  [[:assign,
+                    [:name, "foo"],
+                    [:object, [[:property, [:name, "bar"], [:lit, 10]]]]
+                  ]]
+                ]],
+                @parser.parse('var foo = { bar: 10 }'))
+    assert_ecma('var foo = { bar: 10 };',
+                @parser.parse('var foo = { bar: 10 }')
+               )
+    assert_sexp(
+                [[:var,
+                  [[:assign,
+                    [:name, "foo"],
+                    [:object, []]
+                  ]]
+                ]],
+                @parser.parse('var foo = { }'))
+    assert_ecma('var foo = {  };',
+                @parser.parse('var foo = { }')
+               )
+    assert_sexp(
+                [[:var,
+                  [[:assign,
+                    [:name, "foo"],
+                    [:object, [[:property, [:str, "bar"], [:lit, 10]]]]
+                  ]]
+                ]],
+                @parser.parse('var foo = { "bar": 10 }'))
+    assert_ecma('var foo = { "bar": 10 };',
+                @parser.parse('var foo = { "bar": 10 }')
+               )
+    assert_sexp(
+                [[:var,
+                  [[:assign,
+                    [:name, "foo"],
+                    [:object, [[:property, [:lit, 5], [:lit, 10]]]]
+                  ]]
+                ]],
+                @parser.parse('var foo = { 5: 10 }'))
+    assert_ecma('var foo = { 5: 10 };',
+                @parser.parse('var foo = { 5: 10 }')
+               )
+  end
+
+  def test_object_literal_getter
+    assert_sexp(
+                [[:var,
+                  [[:assign,
+                    [:name, "foo"],
+                    [:object, [[:getter, [:name, 'a'], [:func_expr, nil, [], []]]]]
+                  ]]
+                ]],
+                @parser.parse('var foo = { get a() { } }'))
+    assert_ecma("var foo = { get a() {  } };",
+                @parser.parse('var foo = { get a() { } }')
+               )
+  end
+
+  def test_object_literal_setter
+    assert_sexp(
+                [[:var,
+                  [[:assign,
+                    [:name, "foo"],
+                    [:object, [[:setter, [:name, 'a'], [:func_expr, nil, ["bar"], []]]]]
+                  ]]
+                ]],
+                @parser.parse('var foo = { set a(bar) { } }'))
+    assert_ecma("var foo = { set a(bar) {  } };",
+                @parser.parse('var foo = { set a(bar) { } }')
+               )
+  end
+  
+  def test_to_sexp_multi_property
+    assert_sexp(
+                [[:var,
+                  [[:assign,
+                    [:name, "foo"],
+                    [:object, [
+                      [:property, [:lit, 5], [:lit, 10]],
+                      [:property, [:name, "a"], [:lit, 10]]
+                    ]]
+                  ]]
+                ]],
+                @parser.parse('var foo = { 5: 10, a: 10 }'))
+    assert_ecma("var foo = { f: 10,\n  a: 10 };",
+                @parser.parse('var foo = { f: 10, a: 10 }')
+               )
+  end
+
+  def test_ol_with_string_keys
+    assert_sexp([[:var,
+      [[:assign,
+        [:name, "foo"],
+        [:object,
+         [[:property, [:str, "\n"], [:lit, 10]],
+          [:property, [:str, "\t"], [:lit, 10]]]]]]]],
+                @parser.parse('var foo = { "\n": 10, "\t": 10 }')
+               )
+    assert_ecma("var foo = { \"\\n\": 10,\n  \"\\t\": 10 };",
+      @parser.parse('var foo = { "\n": 10, "\t": 10 }'))
+
+    assert_ecma('"\"";', @parser.parse('"\""'))
+  end
+end