jbarnette-johnson 1.0.0.200806240111

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,46 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../helper"))
+
+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_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
+  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

data/test/johnson/spidermonkey/js_land_proxy_test.rb

@@ -0,0 +1,236 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module SpiderMonkey
+    class JSLandProxyTest < Johnson::TestCase
+      module AModule
+      end
+      
+      class AClass
+        attr_reader :args
+        
+        def initialize(*args)
+          @args = args
+        end
+      end
+      
+      class Foo
+        class Inner
+        end
+        
+        def self.bar; 10; end
+
+        attr_accessor :bar
+        
+        def initialize
+          @bar = 10
+        end
+        
+        def x2(x)
+          x * 2
+        end
+        
+        def add(*args)
+          args.inject { |m,n| m += n }
+        end
+        
+        def xform(arg)
+          yield(arg)          
+        end
+      end
+      
+      class Indexable
+        def initialize
+          @store = {}
+        end
+        
+        def [](key)
+          @store[key]
+        end
+        
+        def []=(key, value)
+          @store[key] = value
+        end
+        
+        def key?(key)
+          @store.key?(key)
+        end
+      end
+
+      def setup
+        @runtime = Johnson::Runtime.new(Johnson::SpiderMonkey::Runtime)
+      end
+
+      def test_find_constants
+        assert_js_equal($LOAD_PATH, "Ruby['$LOAD_PATH']")
+      end
+
+      def test_proxies_get_reused
+        @runtime["foo"] = @runtime["bar"] = Foo.new
+        assert_js_equal(true, "foo === bar")
+      end
+
+      def test_attributes_get_added_to_ruby
+        foo = @runtime["foo"] = Foo.new
+        assert !foo.respond_to?(:johnson)
+        @runtime.evaluate("foo.johnson = 'explode';")
+        assert foo.respond_to?(:johnson)
+        assert_equal('explode', foo.johnson)
+        assert_js_equal('explode', 'foo.johnson')
+        assert !Foo.new.respond_to?(:johnson)
+      end
+
+      def test_assign_function_as_attribute
+        foo = @runtime["foo"] = Foo.new
+        assert !foo.respond_to?(:johnson)
+        f = @runtime.evaluate("foo.johnson = function() { return 'explode'; }")
+        assert foo.respond_to?(:johnson)
+        assert_equal('explode', foo.johnson)
+        assert_js_equal('explode', 'foo.johnson()')
+        assert_js_equal(f, 'foo.johnson')
+        assert !Foo.new.respond_to?(:johnson)
+      end
+
+      def test_assign_function_as_attribute_with_this
+        foo = @runtime["foo"] = Foo.new
+        @runtime.evaluate("foo.ex_squared = function(x) { return this.x2(x); }")
+        assert_equal(4, foo.ex_squared(2))
+        @runtime.evaluate("foo.ex_squared = 20;")
+        assert_equal(20, foo.ex_squared)
+      end
+
+      def test_use_ruby_global_object
+        func = @runtime.evaluate("function(x) { return this.x2(x); }")
+        foo  = Foo.new
+        assert_equal(4, func.call_using(foo, 2))
+      end
+      
+      def test_proxies_roundtrip
+        @runtime["foo"] = foo = Foo.new
+        assert_same(foo, @runtime.evaluate("foo"))
+      end
+      
+      def test_proxies_classes
+        @runtime["Foo"] = Foo
+        assert_same(Foo, @runtime.evaluate("Foo"))
+      end
+      
+      def test_proxies_modules
+        @runtime["AModule"] = AModule
+        assert_same(AModule, @runtime.evaluate("AModule"))
+      end
+      
+      def test_proxies_hashes
+        @runtime["beatles"] = { "george" => "guitar" }
+        assert_equal("guitar", @runtime.evaluate("beatles['george']"))
+      end
+      
+      def test_getter_calls_0_arity_method
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.bar")
+      end
+      
+      def test_getter_calls_indexer
+        @runtime["foo"] = indexable = Indexable.new
+        indexable["bar"] = 10
+        
+        assert_js_equal(10, "foo.bar")
+      end
+      
+      def test_getter_returns_nil_for_unknown_properties
+        @runtime["foo"] = Foo.new
+        assert_js_equal(nil, "foo.quux")
+      end
+
+      def test_setter_calls_key=
+        @runtime["foo"] = foo = Foo.new
+        assert_js_equal(42, "foo.bar = 42")
+        assert_equal(42, foo.bar)
+      end
+      
+      def test_setter_calls_indexer
+        @runtime["foo"] = indexable = Indexable.new
+        assert_js_equal(42, "foo.monkey = 42")
+        assert_equal(42, indexable["monkey"])
+      end
+      
+      def test_calls_attr_reader
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.bar")
+      end
+      
+      def test_calls_1_arity_method
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.x2(5)")
+      end
+      
+      def test_calls_n_arity_method
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.add(4, 2, 2, 1, 1)")
+      end
+      
+      def test_calls_class_method
+        @runtime["Foo"] = Foo
+        assert_js_equal(Foo.bar, "Foo.bar()")
+      end
+      
+      def test_accesses_consts
+        @runtime["Foo"] = Foo
+        assert_same(Foo::Inner, @runtime.evaluate("Foo.Inner"))
+      end
+            
+      def test_can_create_new_instances_in_js
+        @runtime["AClass"] = AClass
+        foo = @runtime.evaluate("AClass.new()")
+        assert_kind_of(AClass, foo)
+      end
+      
+      def test_class_proxies_provide_a_ctor
+        @runtime["AClass"] = AClass
+        foo = @runtime.evaluate("new AClass()")
+        assert_kind_of(AClass, foo)
+        
+        bar = @runtime.evaluate("new AClass(1, 2, 3)")
+        assert_equal([1, 2, 3], bar.args)
+      end
+      
+      def test_dwims_blocks
+        @runtime["foo"] = Foo.new
+        assert_js_equal(4, "foo.xform(2, function(x) { return x * 2 })")
+      end
+      
+      def test_dwims_blocks_for_0_arity_methods
+        @runtime[:arr] = [1, 2, 3]
+        assert_js_equal([2, 4, 6], "arr.collect(function(x) { return x * 2 })")
+      end
+      
+      def test_scope_for_with
+        assert_js_equal(84, "with (rb) { b + b }", :b => 1, :rb => { "b" => 42 })
+      end
+      
+      def test_lambdas_for_with
+        assert_js_equal(84, "with (rb) { b(42) }", :rb => { "b" => lambda { |x| x * 2 } })
+      end
+      
+      class MethodForWith
+        def b(x); x * 2; end
+      end
+      
+      def test_method_for_with
+        assert_js_equal(84, "with (rb) { b(42) }", :rb => MethodForWith.new)
+      end
+
+      def test_raises_string_to_ruby
+        assert_raise(Johnson::Error) { @runtime.evaluate("throw 'my string';") }
+      end
+
+      def test_raises_object_to_ruby
+        assert_raise(Johnson::Error) { @runtime.evaluate("throw { bad: true };") }
+      end
+
+      def test_raises_exception_to_ruby
+        assert_raise(Johnson::Error) { @runtime.evaluate("undefinedValue();") }
+      end
+    end
+  end
+end