johnson 1.1.2 → 1.2.0

data/lib/johnson/spidermonkey.rb

@@ -0,0 +1,12 @@
+
+# the native SpiderMonkey extension
+require "johnson/spidermonkey/spidermonkey"
+
+# the SpiderMonkey bits written in Ruby
+require "johnson/spidermonkey/runtime"
+require "johnson/spidermonkey/context"
+require "johnson/spidermonkey/js_land_proxy"
+require "johnson/spidermonkey/ruby_land_proxy"
+require "johnson/spidermonkey/mutable_tree_visitor"
+require "johnson/spidermonkey/debugger"
+require "johnson/spidermonkey/immutable_node"

data/lib/johnson/spidermonkey/js_land_proxy.rb

@@ -1,3 +1,13 @@
+# FIXME: This definition should probably be somewhere else
+class Array
+  def js_property?(name)
+    name == :length
+  end
+  def js_properties
+    (0...size).to_a
+  end
+end
+
 module Johnson
   module SpiderMonkey
     module JSLandProxy #:nodoc:
@@ -16,14 +26,6 @@ module Johnson
           (target.respond_to?(:js_property?) && target.__send__(:js_property?, name))
       end
       
-      def self.call_proc_by_oid(oid, *args)
-        id2ref(oid).call(*args)
-      end
-      
-      def self.id2ref(oid)
-        ObjectSpace._id2ref(oid)
-      end
-      
       def self.autovivified(target, attribute)
         target.send(:__johnson_js_properties)[attribute]
       end

data/lib/johnson/spidermonkey/ruby_land_proxy.rb

@@ -1,53 +1,16 @@
 module Johnson #:nodoc:
   module SpiderMonkey #:nodoc:
-    class RubyLandProxy # native
-      include Enumerable
-      
-      def initialize
-        raise Johnson::Error, "#{self.class.name} is an internal support class."
+    class RubyLandProxy < Johnson::RubyLandProxy # native
+      module Callable
+        def call_using(this, *args)
+          native_call(this, *args)
+        end
       end
-      
-      private :initialize
-      
-      # FIXME: need to revisit array vs non-array proxy, to_a/to_ary semantics, etc.
-      alias_method :size, :length
-      alias_method :to_ary, :to_a
-      
-      def to_proc
-        @proc ||= Proc.new { |*args| call(*args) }
-      end
-
-      def call(*args)
-        call_using(runtime.global, *args)
-      end
-
-      def call_using(this, *args)
-        native_call(this, *args)
-      end
-      
-      def inspect
-        toString
-      end
-      
-      def method_missing(sym, *args, &block)
-        args << block if block_given?
-        
-        name = sym.to_s
-        assignment = "=" == name[-1, 1]
-        
-        # default behavior if the slot's not there
-        return super unless assignment || respond_to?(sym)
-        
-        unless function_property?(name)
-          # for arity 0, treat it as a get
-          return self[name] if args.empty?
-
-          # arity 1 and quacking like an assignment, treat it as a set
-          return self[name[0..-2]] = args[0] if assignment && 1 == args.size
-        end        
-        
-        # okay, must really be a function
-        call_function_property(name, *args)
+    end
+    class RubyLandScript < Johnson::SpiderMonkey::RubyLandProxy # native
+      def break(linenum, &block)
+        runtime.set_trap(self, linenum, block)
+        runtime.traps << [self, linenum]
       end
     end
   end

data/lib/johnson/spidermonkey/runtime.rb

@@ -1,15 +1,15 @@
 module Johnson #:nodoc:
   module SpiderMonkey #:nodoc:
-    class Runtime # native
+    class Runtime < Johnson::Runtime # native
       CONTEXT_MAP_KEY = :johnson_context_map
 
+      attr_reader :traps
       def initialize(options={})
         @debugger = nil
-        @compiled_scripts = {}
         @gcthings = {}
         @traps = []
         initialize_native(options)
-        self["Ruby"] = Object
+        super()
       end
       
       # called from js_land_proxy.c:make_js_land_proxy
@@ -22,29 +22,19 @@ module Johnson #:nodoc:
         @gcthings.delete(object_id) if defined? @gcthings
       end
 
+      def debugger?
+        not @debugger.nil?
+      end
 
       def current_context
         contexts = (Thread.current[CONTEXT_MAP_KEY] ||= {})
         contexts[self.object_id] ||= Context.new(self)
       end
 
-      def [](key)
-        global[key]
-      end
-      
-      def []=(key, value)
-        global[key] = value
-      end
-
-      ###
-      # Evaluate +script+ with +filename+ and +linenum+
-      def evaluate(script, filename = nil, linenum = nil)
-        compiled_script = compile(script, filename, linenum)
-        evaluate_compiled_script(compiled_script)
-      end
-
-      def evaluate_compiled script
-        evaluate_compiled_script(script)
+      alias :evaluate_compiled_script_without_clearing_traps :evaluate_compiled_script
+      def evaluate_compiled_script script
+        evaluate_compiled_script_without_clearing_traps(script)
+      ensure
         @traps.each do |trap_tuple|
           clear_trap(*trap_tuple)
         end
@@ -55,17 +45,7 @@ module Johnson #:nodoc:
       def compile(script, filename=nil, linenum=nil)
         filename ||= 'none'
         linenum  ||= 1
-        @compiled_scripts[filename] = native_compile(script, filename, linenum)
-      end
-
-      ###
-      # Yield to +block+ in +filename+ at +linenum+
-      def break(filename, linenum, &block)
-        raise "#{filename} has not been compiled" unless @compiled_scripts.key?(filename)
-
-        compiled_script = @compiled_scripts[filename]
-        set_trap(compiled_script, linenum, block)
-        @traps << [compiled_script, linenum]
+        native_compile(script, filename, linenum)
       end
 
       class << self

data/test/johnson/conversions/array_test.rb

@@ -14,18 +14,56 @@ module Johnson
         assert_equal(42, @runtime[:list][0])
       end
 
+      def test_array_length
+        @runtime[:list] = [1, 2, 3, 4]
+        assert_equal(4, @runtime.evaluate("list.length"))
+      end
+
       def test_array_works_with_for_in
+        list = [9, 3, 12, 8]
+
+        @runtime['alert'] = lambda { |x| p x }
+        @runtime['list'] = list
+        @runtime.evaluate("
+          var new_list = [];
+          for(var x in list) {
+            new_list.push(x);
+          }
+        ")
+        assert_equal([0, 1, 2, 3], @runtime['new_list'].to_a)
+      end
+
+      def test_array_works_with_iterator
+        list = [9, 3, 12, 8]
+
+        @runtime['alert'] = lambda { |x| p x }
+        @runtime['list'] = list
+        @runtime.evaluate("
+          var new_list = [];
+          var it = Iterator(list);
+          for(var x in it) {
+            new_list.push(x);
+          }
+        ")
+        assert_equal([[0, 9], [1, 3], [2, 12], [3, 8]], @runtime['new_list'].to_a.map {|a| a.to_a })
+      end
+
+      def test_array_works_with_function_apply
         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);
+          function process_list(a, b, c, d) {
+            new_list.push(a * 2);
+            new_list.push(b * 2);
+            // skip c
+            new_list.push(d * 2);
           }
+          process_list.apply(process_list, list);
         ")
-        assert_equal(list.map { |x| x + 1}, @runtime['new_list'].to_a)
+        assert_equal([2, 4, 8], @runtime['new_list'].to_a)
       end
     end
   end

data/test/johnson/conversions/string_test.rb

@@ -21,6 +21,18 @@ module Johnson
         @runtime[:v] = v = "hola"
         assert_not_same(v, @runtime.evaluate("v"))
       end
+
+      def test_multibyte_character_roundtrip_js
+        assert_equal(1, @runtime.evaluate("'\\u20AC'.length"))
+        assert_equal(0x20ac, @runtime.evaluate("'\\u20AC'.charCodeAt(0)"))
+        assert_equal(0x0000, @runtime.evaluate("'\\u0000'.charCodeAt(0)"))
+        @runtime[:s] = "\xe2\x82\xac"
+        assert_equal(0x20ac, @runtime.evaluate("s.charCodeAt(0)"))
+        assert_equal('', @runtime.evaluate("s.substr(1)"))
+        assert_equal(1, @runtime.evaluate("s.length"))
+        assert_equal("\xe2\x82\xac", @runtime.evaluate("s"))
+        assert_js("'\\u20ac' == s")
+      end
     end
   end
 end

data/test/johnson/custom_conversions_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../helper"))
+
+module Johnson
+  class CustomConversionsTest < Johnson::TestCase
+    def test_ruby_time_round_trips
+      @runtime['t'] = t = Time.now
+      assert_js_equal(t, 't')
+    end
+
+    def test_ruby_time_wrappers_are_equal
+      @runtime['t'] = t = Time.now
+      @runtime['t2'] = t
+      assert_js('t == t2')
+    end
+
+    def test_ruby_time_has_js_methods
+      @runtime['t'] = t = Time.now
+      assert_js_equal(t.year, 't.getFullYear()')
+    end
+
+    def test_ruby_date_round_trips
+      @runtime['t'] = t = Date.today
+      assert_js_equal(t, 't')
+    end
+
+    def test_ruby_date_has_js_methods
+      @runtime['t'] = t = Date.today
+      assert_js_equal(t.year, 't.getFullYear()')
+    end
+
+    def test_js_date_is_ruby_date
+      @runtime.evaluate %{this.t = new Date('Jul 22, 2009 12:34:56');}
+
+      assert_kind_of(Date, @runtime['t'])
+    end
+
+    def test_js_date_round_trips
+      @runtime.evaluate %{this.t = new Date('Jul 22, 2009 12:34:56');}
+      @runtime['t2'] = @runtime['t']
+
+      assert_js('t == t2')
+    end
+
+    def test_js_date_has_ruby_methods
+      @runtime.evaluate %{this.t = new Date('Jul 22, 2009 12:34:56');}
+
+      assert_equal('Wed, 22 July, 2009', @runtime['t'].strftime('%a, %d %B, %Y'))
+    end
+  end
+end

data/test/johnson/prelude_test.rb

@@ -52,5 +52,28 @@ module Johnson
         flag;
       END
     end
+
+    def test_apply_without_second_param_works
+      assert_js(<<-END)
+        var func = function() { return arguments.length; };
+        func.apply(null, null) == 0 && func.apply(null) == 0;
+      END
+    end
+
+    def test_apply_with_non_array_throws
+      assert_raise(Johnson::Error) {
+        @runtime.evaluate(<<-END)
+          var func = function() { return arguments.length; };
+          func.apply(null, "foo");
+        END
+      }
+
+      assert_raise(Johnson::Error) {
+        @runtime.evaluate(<<-END)
+          var func = function() { return arguments.length; };
+          func.apply(null, { foo: 'bar' });
+        END
+      }
+    end
   end
 end

data/test/johnson/runtime_test.rb

@@ -11,6 +11,23 @@ module Johnson
       assert_nil(@runtime.evaluate(nil))
     end
 
+    def test_global_treats_symbols_as_strings
+      @runtime[:foo] = 17
+      @runtime['bar'] = 4
+      assert_equal 17, @runtime['foo']
+      assert_equal 4, @runtime[:bar]
+      assert_js_equal 21, 'foo + bar'
+    end
+
+    def test_disallows_invalid_key_types
+      assert_raises(TypeError) {
+        @runtime[4.1] = 3
+      }
+      assert_raises(TypeError) {
+        @runtime[%w(hello world)]
+      }
+    end
+
     def test_js_eval
       assert_equal(1, @runtime.evaluate('eval("1");'))
     end
@@ -39,8 +56,8 @@ module Johnson
                               x++;
                             }
                             some_number++;
-                        ", 'awesome_script')
-      @runtime.break('awesome_script', 4) do
+                        ")
+      script.break(4) do
         break_times += 1
         assert_equal(@runtime['i'], @runtime['x'])
         assert_equal(1, @runtime['some_number'])
@@ -50,6 +67,57 @@ module Johnson
       assert_equal(2, @runtime['some_number'])
     end
 
+    def test_breakpoint_can_raise
+      break_times = 0
+      @runtime['some_number'] = 0
+      @runtime['alert'] = lambda {|x,y| p [x, y] }
+      script = @runtime.compile("some_number++;
+                            var x = 0;
+                            try {
+                              for(var i = 0; i < 10; i++) {
+                                x++;
+                              }
+                            } catch(ex) {
+                              note_error(ex);
+                            }
+                            some_number++;
+                        ")
+      script.break(5) do
+        break_times += 1
+        assert_equal(@runtime['i'], @runtime['x'])
+        assert_equal(1, @runtime['some_number'])
+        raise ArgumentError, "Test" if @runtime['i'] > 4
+      end
+      break_ex = nil
+      @runtime['note_error'] = lambda {|ex| break_ex = ex }
+      @runtime.evaluate_compiled_script(script)
+      assert_match(/ArgumentError: Test/, break_ex.message)
+      assert_equal(6, break_times)
+      assert_equal(2, @runtime['some_number'])
+    end
+
+    def test_breakpoints_are_cleared
+      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++;
+                        ")
+      script.break(4) do
+        break_times += 1
+        assert_equal(@runtime['i'], @runtime['x'])
+        assert_equal(1, @runtime['some_number'] % 2)
+      end
+      3.times do
+        @runtime.evaluate_compiled_script(script)
+      end
+      assert_equal(10, break_times)
+      assert_equal(6, @runtime['some_number'])
+    end
+
     def test_try_to_gc
       10.times {
         thread = Thread.new do
@@ -60,5 +128,17 @@ module Johnson
         GC.start
       }
     end
+
+    def test_evaluated_compiled_script_checks_argument_type
+      assert_raises(ArgumentError) {
+        @runtime.evaluate_compiled_script(nil)
+      }
+      assert_raises(ArgumentError) {
+        @runtime.evaluate_compiled_script(17)
+      }
+      assert_raises(ArgumentError) {
+        @runtime.evaluate_compiled_script("3+9")
+      }
+    end
   end
 end