johnson 1.1.0

data/test/johnson/browser_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../helper"))
+
+begin
+  require "xml/dom/builder"
+  require "net/http"
+
+  module Johnson
+    class BrowserTest < Johnson::TestCase
+      def setup
+        super
+        @runtime.evaluate('Johnson.require("johnson/browser");')
+      end
+
+      def test_set_location_returns_location
+        filename = "file://#{File.expand_path(__FILE__)}"
+
+        may_thread {
+          @runtime.evaluate("window.location = '#{filename}'")
+        }
+
+        uri = URI.parse(filename)
+        assert_equal(uri.to_s, @runtime.evaluate('window.location').to_s)
+      end
+
+      def test_set_location_with_url
+        file = File.expand_path(__FILE__) + "/../../assets/index.html"
+        filename = "file://#{File.expand_path(file)}"
+        may_thread {
+          @runtime.evaluate("window.location = '#{filename}'")
+        }
+        doc = @runtime.evaluate('window.document')
+        assert_not_nil(doc)
+      end
+
+      def may_thread(&block)
+        block.call
+        (Thread.list - [Thread.main]).each { |t| t.join }
+      end
+    end
+  end
+rescue LoadError
+  # Yehuda is teh lame.
+end

data/test/johnson/conversions/array_test.rb

@@ -0,0 +1,32 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class ArrayTest < Johnson::TestCase
+      def test_array_index_get
+        @runtime[:list] = [1, 2, 3, 4]
+        assert_equal(1, @runtime.evaluate("list[0]"))
+      end
+
+      def test_array_index_set
+        @runtime[:list] = []
+        @runtime.evaluate("list[0] = 42")
+        assert_equal(42, @runtime[:list][0])
+      end
+
+      def test_array_works_with_for_in
+        list = [1, 2, 3, 4]
+
+        @runtime['alert'] = lambda { |x| p x }
+        @runtime['list'] = list
+        @runtime.evaluate("
+          var new_list = [];
+          for(x in list) {
+            new_list.push(x + 1);
+          }
+        ")
+        assert_equal(list.map { |x| x + 1}, @runtime['new_list'].to_a)
+      end
+    end
+  end
+end

data/test/johnson/conversions/boolean_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class BooleanTest < Johnson::TestCase
+      def test_truthiness
+        @runtime[:v] = true
+        assert_same(true, @runtime.evaluate("v === true"))
+      end
+
+      def test_dirty_lies
+        @runtime[:v] = false
+        assert_same(false, @runtime.evaluate("v === true"))
+      end
+    end
+  end
+end

data/test/johnson/conversions/callable_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class CallableTest < Johnson::TestCase
+      def test_proc_works_in_jsland
+        @runtime[:squared] = Proc.new { |x| x * x }
+        assert_js_equal(4, "squared(2)")
+      end
+      
+      def test_procs_roundtrip
+        @runtime[:k] = k = lambda { |x| x }
+        assert_same(k, @runtime.evaluate("k"))
+      end
+      
+      def test_proc_js_function_proxy_gets_reused
+        @runtime[:k] = k = lambda { |x| x }
+        @runtime[:kk] = k
+        assert_js("k === kk")
+      end
+      
+      class CallableThing
+        def call
+          "foo"
+        end
+      end
+      
+      def test_anything_with_a_call_method_can_be_called_as_a_method
+        @runtime[:c] = CallableThing.new
+        assert_js_equal("foo", "c()")
+      end
+    end
+  end
+end

data/test/johnson/conversions/file_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class FileTest < Johnson::TestCase
+      def test_read_file
+        File.open(__FILE__, 'rb') { |f|
+          @runtime[:foo] = f
+          assert_equal(f, @runtime.evaluate("foo"))
+          assert_equal(File.read(__FILE__), @runtime.evaluate("foo.read()"))
+        }
+      end
+    end
+  end
+end

data/test/johnson/conversions/nil_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class NilTest < Johnson::TestCase
+      def test_ruby_nil_is_js_null
+        @runtime[:v] = nil
+        assert_equal(true, @runtime.evaluate("v == null"))
+      end
+
+      def test_js_null_is_ruby_nil
+        assert_nil(@runtime.evaluate("null"))
+      end
+
+      def test_js_undefined_is_ruby_nil
+        assert_nil(@runtime.evaluate("undefined"))
+      end
+    end
+  end
+end

data/test/johnson/conversions/number_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class NumberTest < Johnson::TestCase
+      def test_ruby_fixnum_in_js
+        @runtime[:v] = 42
+        
+        assert_js("v == 42")
+        assert_js_equal(42, "v")
+        assert_equal(42, @runtime[:v])
+      end
+      
+      def test_js_fixnum_in_ruby
+        fix = @runtime.evaluate("42")
+        assert_equal(42, fix)
+        assert_kind_of(Fixnum, fix)
+      end
+
+      def test_ruby_float_in_js
+        @runtime[:pi] = pi = 3.141592654
+        assert_js_equal(pi, "pi")
+        assert_in_delta(pi, @runtime.evaluate("pi"), 2 ** -20)
+      end
+      
+      def test_ruby_bignum_in_js
+        @runtime[:big] = big = 2 ** 200        
+        
+        assert_js_equal(big, "big")
+        assert_kind_of(Float, @runtime.evaluate("big"))
+      end
+    end
+  end
+end

data/test/johnson/conversions/regexp_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class RegexpTest < Johnson::TestCase
+      def test_regex_converts
+        @runtime[:x] = /aaron/
+        @runtime[:y] = /john/i
+        assert @runtime.evaluate('"aaron".match(x)')
+        assert !@runtime.evaluate('"Aaron".match(x)')
+        assert @runtime.evaluate('"john".match(y)')
+        assert @runtime.evaluate('"John".match(y)')
+      end
+
+      def test_regex_roundtrips
+        @runtime[:x] = /aaron/
+        assert_equal(/aaron/, @runtime.evaluate('x'))
+
+        @runtime[:x] = /aaron/m
+        assert_equal(/aaron/m, @runtime.evaluate('x'))
+      end
+    end
+  end
+end

data/test/johnson/conversions/string_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class StringTest < Johnson::TestCase
+      def test_ruby_string_in_js
+        @runtime[:v] = "foo"
+        assert_js("'foo' == v")
+      end
+
+      def test_js_string_in_ruby
+        assert_equal("foo", @runtime.evaluate("'foo'"))
+      end
+
+      def test_roundtrip
+        @runtime[:v] = v = "hola"
+        assert_equal(v, @runtime.evaluate("v"))
+      end
+      
+      def test_strings_are_copies
+        @runtime[:v] = v = "hola"
+        assert_not_same(v, @runtime.evaluate("v"))
+      end
+    end
+  end
+end

data/test/johnson/conversions/struct_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class StructTest < Johnson::TestCase
+      def test_use_struct
+        f = Struct.new(:phil_collins).new
+        f.phil_collins = 'awesome'
+        @runtime[:foo] = f
+        assert_equal(f, @runtime.evaluate('foo'))
+        assert_equal('awesome', @runtime.evaluate('foo.phil_collins'))
+      end
+    end
+  end
+end

data/test/johnson/conversions/symbol_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class SymbolTest < Johnson::TestCase
+      def test_symbols_are_interned
+        @runtime[:v] = :symbol
+        @runtime[:x] = :symbol
+
+        assert(@runtime.evaluate("v !== null && v === x"))
+      end
+
+      def test_ruby_symbol_roundtrips
+        @runtime[:v] = :foo
+        assert_equal(:foo, @runtime.evaluate("v"))
+      end
+    end
+  end
+end

data/test/johnson/conversions/thread_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module Conversions
+    class ThreadTest < Johnson::TestCase
+      def test_manipulate_thread
+        thread = Thread.new { }
+        @runtime['thread'] = thread
+        assert_js_equal(false, "thread.send('alive?')")
+      end
+
+      def test_new_js_thread
+        @runtime.evaluate('function testing() { Ruby.sleep(10); }')
+        @runtime.evaluate('new Ruby.Thread(function() { testing(); })')
+      end
+
+      def test_js_thread_read_file
+        @runtime['filename'] = File.expand_path(__FILE__)
+        @runtime.evaluate('function testing() { Ruby.File.read(filename); }')
+        @runtime.evaluate('new Ruby.Thread(function() { testing(); })')
+      end
+    end
+  end
+end

data/test/johnson/error_test.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../helper"))
+
+module Johnson
+  class ErrorTest < Johnson::TestCase
+    def test_inherits_from_standard_error
+      assert(Johnson::Error < StandardError)
+    end
+  end
+end

data/test/johnson/extensions_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../helper"))
+
+module Johnson
+  module Extensions
+    class DefinePropertyTest < Johnson::TestCase
+      def setup
+        super
+        @runtime.evaluate("x = {}")
+      end      
+      
+      def test_object_can_define_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42)")
+        assert_js_equal(42, "x.answer")
+      end
+      
+      def test_object_can_define_unenumerable_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42)")
+        @runtime.evaluate <<-JS
+          y = [];
+          for(prop in x) if(prop == "answer") y.push(prop)
+        JS
+        assert_js("y.length == 0")
+      end
+      
+      def test_object_can_define_enumerable_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42, Object.ITERABLE)")
+        @runtime.evaluate <<-JS
+          y = [];
+          for(prop in x) if(prop == "answer") y.push(prop)
+        JS
+        assert_js("y.length == 1")
+      end
+      
+      def test_object_can_define_read_only_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42, Object.READ_ONLY)")
+        @runtime.evaluate("x.answer = 47")
+        assert_js_equal(42, "x.answer")
+      end
+      
+      def test_object_can_define_non_deletable_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42, Object.NON_DELETABLE)")
+        @runtime.evaluate("r = (delete x.answer)")
+        assert_js_equal(false, "r")
+        assert_js_equal(42, "x.answer")
+      end
+      
+      def test_object_can_define_mixed_property
+        @runtime.evaluate("Object.defineProperty(x, 'answer', 42, Object.NON_DELETABLE | Object.READ_ONLY)")
+        @runtime.evaluate("r = (delete x.answer)")
+        @runtime.evaluate("x.answer = 47")
+        assert_js_equal(false, "r")
+        assert_js_equal(42, "x.answer")
+      end      
+    end
+  end
+end

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