johnson 1.1.0

data/test/johnson/nodes/return_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class ReturnTest < Johnson::NodeTestCase
+  def test_return
+    assert_sexp([[:func_expr, "foo", [], [[:return, nil]]]],
+      @parser.parse('function foo() { return; }'))
+    assert_ecma("function foo() {\n  return;\n}",
+      @parser.parse('function foo() { return; }'))
+
+
+    assert_sexp([[:func_expr, "foo", [], [[:return, [:lit, 10]]]]],
+      @parser.parse('function foo() { return 10; }'))
+    assert_ecma("function foo() {\n  return 10;\n}",
+      @parser.parse('function foo() { return 10; }'))
+  end
+end

data/test/johnson/nodes/semi_test.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class SemiTest < Johnson::NodeTestCase
+  def test_null_semi
+    assert_sexp([], @parser.parse(';'))
+    assert_ecma('', @parser.parse(';'))
+  end
+end

data/test/johnson/nodes/switch_test.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class SwitchTest < Johnson::NodeTestCase
+  def test_empty_switch
+    assert_sexp([[:switch, [:name, "o"], []]],
+                @parser.parse('switch(o) { }')
+               )
+    assert_ecma('switch(o) {  }',
+                @parser.parse('switch(o) { }')
+               )
+  end
+
+  def test_switch_with_body
+    assert_sexp([[:switch, [:name, "o"],
+                [
+                  [:case, [:name, "j"], [[:name, "foo"]]]
+                ]
+      ]], @parser.parse('switch(o) { case j: foo; }')
+    )
+    assert_ecma("switch(o) {\n  case j: {\n    foo;\n}\n}",
+                @parser.parse('switch(o) { case j: foo; }')
+               )
+  end
+
+  def test_switch_empty_case
+    assert_ecma("switch(o) {\n  case j: {  }\n}",
+                @parser.parse('switch(o) { case j: }')
+               )
+  end
+
+  def test_switch_with_body_2_case
+    assert_sexp([[:switch, [:name, "o"],
+                [
+                  [:case, [:name, "j"], [[:name, "foo"]]],
+                  [:case, [:name, "k"], [[:name, "bar"]]]
+                ]
+      ]], @parser.parse('switch(o) { case j: foo; case k: bar; }')
+    )
+  end
+
+  def test_switch_with_default
+    assert_sexp([[:switch, [:name, "o"], [[:default, nil, [[:name, "bar"]]]]]],
+                @parser.parse('switch(o) { default: bar; }')
+    )
+    assert_ecma("switch(o) {\n  default: {\n    bar;\n}\n}",
+                @parser.parse('switch(o) { default: bar; }')
+               )
+    assert_sexp([[:switch, [:name, "o"], [[:default, nil, []]]]],
+                @parser.parse('switch(o) { default: }')
+    )
+    assert_ecma("switch(o) {\n  default: {  }\n}",
+                @parser.parse('switch(o) { default: }')
+    )
+  end
+end

data/test/johnson/nodes/ternary_test.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class TernaryNodeTest < Johnson::NodeTestCase
+  def test_ternary
+    assert_sexp([
+      [:var, [[:assign,
+        [:name, "x"],
+        [:ternary,
+          [:lt, [:name, "y"], [:lit, 10]],
+          [:lit, 20],
+          [:lit, 30]
+        ]
+      ]]]],
+                @parser.parse('var x = y < 10 ? 20 : 30')
+               )
+    assert_ecma('var x = y < 10 ? 20 : 30;',
+                @parser.parse('var x = y < 10 ? 20 : 30')
+               )
+  end
+
+  def test_weird_rounding
+    ecma = @parser.parse('(value < 0.00001) ? 0 : value;').to_ecma
+    assert_match(/\(value < 1.0e-[0]*5\) \? 0 : value;/, ecma)
+  end
+end

data/test/johnson/nodes/throw_test.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class ThrowTest < Johnson::NodeTestCase
+  def test_to_sexp
+    assert_sexp([[:throw, [:lit, 10]]], @parser.parse('throw 10;'))
+    assert_sexp([[:throw, [:lit, 10]]], @parser.parse('throw 10'))
+    assert_ecma("throw 10;", @parser.parse('throw 10;'))
+  end
+end

data/test/johnson/nodes/try_node_test.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class TryTest < Johnson::NodeTestCase
+  def test_try_finally
+    assert_sexp([[:try,
+        [[:var, [[:assign, [:name, "x"], [:lit, 10]]]]],
+        nil,
+        [[:var, [[:assign, [:name, "x"], [:lit, 20]]]]]
+      ]],
+      @parser.parse('try { var x = 10; } finally { var x = 20; }'))
+    assert_ecma(
+      "try {\n  var x = 10;\n} finally {\n  var x = 20;\n}",
+      @parser.parse('try { var x = 10; } finally { var x = 20; }'))
+  end
+
+  def test_try_catch
+    assert_sexp([
+    [:try,
+      [[:var, [[:assign, [:name, "x"], [:lit, 10]]]]],
+      [[:catch, [:name, "a"], nil,
+      [
+        [:var, [[:assign, [:name, "x"], [:lit, 20]]]],
+        [:postfix_inc, [:name, "x"]]
+      ]
+      ]],
+    nil]],
+    @parser.parse('try { var x = 10; } catch(a) { var x = 20; x++; }'))
+    assert_ecma("try {\n  var x = 10;\n} catch(a) {\n  var x = 20;\n  x++;\n}",
+      @parser.parse('try { var x = 10; } catch(a) { var x = 20; x++; }'))
+  end
+
+  def test_try_multi_catch
+    assert_sexp([
+      [:try,
+        [[:var, [[:assign, [:name, "x"], [:lit, 10]]]]],
+      [
+        [:catch, [:name, "a"], [:true],
+        [
+          [:var, [[:assign, [:name, "x"], [:lit, 20]]]],
+          [:postfix_inc, [:name, "x"]]
+        ]],
+        [:catch, [:name, "b"], [:true],
+        [
+          [:var, [[:assign, [:name, "x"], [:lit, 20]]]],
+          [:postfix_inc, [:name, "x"]]
+        ]]
+      ],
+      nil]],
+      @parser.parse(' try { var x = 10; }
+                      catch(a if true) { var x = 20; x++; }
+                      catch(b if true) { var x = 20; x++; }
+                    '))
+    assert_ecma("try {\n  var x = 10;\n} catch(a) {\n  var x = 20;\n  x++;\n} catch(b) {\n  var x = 20;\n  x++;\n}",
+      @parser.parse(' try { var x = 10; }
+                      catch(a if true) { var x = 20; x++; }
+                      catch(b if true) { var x = 20; x++; }
+                    '))
+  end
+end

data/test/johnson/nodes/typeof_test.rb

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

data/test/johnson/nodes/unary_node_test.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class UnaryNodeTest < Johnson::NodeTestCase
+  def test_u_positive_sexp
+    assert_sexp([[:u_pos, [:name, 'foo']]], @parser.parse('+foo;'))
+    assert_ecma('+foo;', @parser.parse('+foo'))
+  end
+
+  def test_u_negative_sexp
+    assert_sexp([[:u_neg, [:name, 'foo']]], @parser.parse('-foo;'))
+    assert_ecma('-foo;', @parser.parse('-foo'))
+  end
+
+  def test_u_bit_not_sexp
+    assert_sexp([[:bitwise_not, [:name, 'foo']]], @parser.parse('~foo;'))
+    assert_ecma('~foo;', @parser.parse('~foo'))
+  end
+
+  def test_u_not_sexp
+    assert_sexp([[:not, [:name, 'foo']]], @parser.parse('!foo;'))
+    assert_ecma('!foo;', @parser.parse('!foo'))
+  end
+end

data/test/johnson/nodes/void_test.rb

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

data/test/johnson/nodes/while_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class WhileTest < Johnson::NodeTestCase
+  def test_while
+    assert_sexp([[:while, [:true], [:var, [[:assign, [:name, "x"], [:lit, 10]]]]]],
+                @parser.parse('while(true) var x = 10;'))
+    assert_ecma('while(true) var x = 10;',
+      @parser.parse('while(true) var x = 10;'))
+  end
+  
+  def test_break
+    assert_sexp([[:while, [:true], [:break]]],
+                @parser.parse('while(true) break;'))
+    assert_ecma('while(true) break;',
+      @parser.parse('while(true) break;'))
+  end
+
+  def test_continue
+    assert_sexp([[:while, [:true], [:continue]]],
+                @parser.parse('while(true) continue;'))
+    assert_ecma('while(true) continue;',
+      @parser.parse('while(true) continue;'))
+    assert_ecma("while(true) {\n  continue;\n}",
+      @parser.parse('while(true) { continue; }'))
+  end
+end

data/test/johnson/nodes/with_test.rb

@@ -0,0 +1,10 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class WithTest < Johnson::NodeTestCase
+  def test_with
+    assert_sexp([[:with, [:name, "o"], [:name, "x"]]],
+                @parser.parse('with (o) x;')
+               )
+    assert_ecma("with(o) x;", @parser.parse('with (o) x;'))
+  end
+end

data/test/johnson/prelude_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../helper"))
+
+module Johnson
+  class PreludeTest < Johnson::TestCase
+    def test_symbols_are_interned
+      assert(@runtime.evaluate("Johnson.symbolize('foo') === Johnson.symbolize('foo')"))
+    end
+    
+    def test_strings_had_a_to_symbol_method
+      assert_js_equal(:monkeys, "'monkeys'.toSymbol()")
+    end
+    
+    def test_string_to_symbol_is_not_enumerable
+      assert(!@runtime.evaluate(<<-END))
+        var flag = false;
+        for (x in "foo") { if (x == 'toSymbol') flag = true }
+        flag
+      END
+    end
+    
+    def test_symbol_to_string
+      assert_equal("monkey", @runtime.evaluate("Johnson.symbolize('monkey').toString()"))
+    end
+
+    def test_symbol_inspect
+      assert_equal(":monkey", @runtime.evaluate("Johnson.symbolize('monkey').inspect()"))
+    end
+    
+    def test_all_of_ruby_is_available
+      assert_raise(Johnson::Error) { @runtime.evaluate("Ruby.Set.new()") }
+      
+      @runtime.evaluate("Ruby.require('set')")
+      assert_kind_of(Set, @runtime.evaluate("Ruby.Set.new()"))
+    end
+    
+    # def test_require_an_existing_js_file_without_extension
+    #   assert_js("Johnson.require('johnson/template')")
+    # end
+    
+    # def test_require_returns_false_the_second_time_around
+    #   assert_js("Johnson.require('johnson/template')")
+    #   assert(!@runtime.evaluate("Johnson.require('johnson/template')"))
+    # end
+    
+    def test_missing_requires_throw_LoadError
+      assert_js(<<-END)
+        var flag = false;
+        
+        try { Johnson.require("johnson/__nonexistent"); }
+        catch(ex) { flag = true; }
+        
+        flag;
+      END
+    end
+  end
+end

data/test/johnson/runtime_test.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../helper"))
+require 'tempfile'
+
+module Johnson
+  class RuntimeTest < Johnson::TestCase
+    def test_default_delegate_is_spidermonkey
+      assert_equal(Johnson::SpiderMonkey::Runtime, @runtime.delegate.class)
+    end
+
+    def test_evaluate_returns_nil_for_nil_expression
+      assert_nil(@runtime.evaluate(nil))
+    end
+
+    def test_js_eval
+      assert_equal(1, @runtime.evaluate('eval("1");'))
+    end
+
+    def test_shebang_removal
+      t = Tempfile.new("johnson_shebang")
+      t.open { |tf| tf.write "#!/usr/bin/johnson\ntrue;" }
+      assert Johnson.load(t.path)
+    end
+
+    def test_js_throws_compile_errors
+      assert_raises(Johnson::Error) {
+        @runtime.evaluate("var js_lambda = function(x) { return x ** 2; }")
+      }
+      assert_raises(Johnson::Error) {
+        @runtime.compile("var js_lambda = function(x) { return x ** 2; }")
+      }
+    end
+
+    def test_breakpoint_gets_called
+      break_times = 0
+      @runtime['some_number'] = 0
+      script = @runtime.compile("some_number++;
+                            var x = 0;
+                            for(var i = 0; i < 10; i++) {
+                              x++;
+                            }
+                            some_number++;
+                        ", 'awesome_script')
+      @runtime.break('awesome_script', 4) do
+        break_times += 1
+        assert_equal(@runtime['i'], @runtime['x'])
+        assert_equal(1, @runtime['some_number'])
+      end
+      @runtime.evaluate_compiled_script(script)
+      assert_equal(10, break_times)
+      assert_equal(2, @runtime['some_number'])
+    end
+
+    def test_try_to_gc
+      10.times {
+        thread = Thread.new do
+            rt = Johnson::Runtime.new
+            rt.evaluate('new Date()').to_s
+        end
+        thread.join
+        GC.start
+      }
+    end
+  end
+end

data/test/johnson/spidermonkey/context_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module SpiderMonkey
+    class ContextTest < Johnson::TestCase
+      def setup
+        @runtime = Johnson::Runtime.new(Johnson::SpiderMonkey::Runtime)
+      end
+      
+      def test_wraps_global_unfuckedly
+        assert_same(@runtime.global, @runtime.evaluate("this"))
+      end
+      
+      def test_provides_basic_runtime_interface
+        assert(@runtime.respond_to?(:evaluate))
+        assert(@runtime.respond_to?(:[]))
+        assert(@runtime.respond_to?(:[]=))
+      end
+    end
+  end
+end

data/test/johnson/spidermonkey/immutable_node_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+require 'stringio'
+
+module Johnson
+  module SpiderMonkey
+    class ImmutableNodeTest < Johnson::TestCase
+      include Johnson::SpiderMonkey
+
+      def test_initialize
+        node = nil
+        assert_nothing_raised {
+          node = ImmutableNode.new
+        }
+      end
+
+      def test_parse_some_shit
+        assert_nothing_raised {
+          node = ImmutableNode.parse_io(StringIO.new('var x = 10;'))
+        }
+      end
+
+      def test_index
+        node = ImmutableNode.parse_io(StringIO.new('var x = 10;'))
+        assert_equal(0, node.index)
+      end
+
+      def test_line
+        node = ImmutableNode.parse_io(StringIO.new('var x = 10;'))
+        assert_equal(0, node.line)
+      end
+    end
+  end
+end