therubyracer 0.6.3 → 0.7.0.pre

data/lib/v8/ruby_error.rb

@@ -0,0 +1,3 @@
+module V8
+  @error = 
+end

data/lib/v8/to.rb

@@ -5,23 +5,75 @@ module V8
       def ruby(value)
         case value
         when V8::C::Function  then V8::Function.new(value)
+        when V8::C::Array     then V8::Array.new(value)          
         when V8::C::Object    then V8::Object.new(value)
-        when V8::C::String    then "Wonkers!"
+        when V8::C::String    then value.Utf8Value()
+        when V8::C::Date      then Time.at(value.NumberValue())
         else
           value
         end
       end
-      
+
+      alias_method :rb, :ruby
+
       def v8(value)
         case value
-        when String then  C::String.new(value)
-        when Proc   then  C::FunctionTemplate.new(&value).GetFunction()
-        when Method then  C::FunctionTemplate.new(&value.to_proc).GetFunction()
-        else
+        when V8::Object
+          value.instance_eval {@native}
+        when String, Symbol
+          C::String::New(value.to_s)
+        when Proc,Method
+          template = C::FunctionTemplate::New() do |arguments|
+            rbargs = []
+            for i in 0..arguments.Length() - 1
+              rbargs << To.ruby(arguments[i])
+            end
+            V8::Function.rubycall(value, *rbargs)
+          end
+          return template.GetFunction()
+        when ::Array
+          C::Array::New(value.length).tap do |a|
+            value.each_with_index do |item, i|
+              a.Set(i, To.v8(item))
+            end
+          end
+        when ::Hash
+          C::Object::New().tap do |o|
+            value.each do |key, value|
+              o.Set(To.v8(key), To.v8(value))
+            end
+          end
+        when ::Time
+          C::Date::New(value)
+        when nil,Numeric,TrueClass,FalseClass
           value
+        else
+          rubyobject = C::ObjectTemplate::New()
+          rubyobject.SetNamedPropertyHandler(
+            NamedPropertyGetter,
+            NamedPropertySetter,
+            nil,
+            nil,
+            NamedPropertyEnumerator
+          )
+          obj = nil
+          unless C::Context::InContext()
+            cxt = C::Context::New()
+            cxt.Enter()
+            begin
+              obj = rubyobject.NewInstance()
+              obj.SetHiddenValue(C::String::New("TheRubyRacer::RubyObject"), C::External::Wrap(value))
+            ensure
+              cxt.Exit()
+            end
+          else
+            obj = rubyobject.NewInstance()
+            obj.SetHiddenValue(C::String::New("TheRubyRacer::RubyObject"), C::External::Wrap(value))
+          end
+          return obj
         end
       end
-      
+
       def camel_case(str)
         str.to_s.gsub(/_(\w)/) {$1.upcase}
       end

data/spec/ext/cxt_spec.rb

@@ -6,20 +6,7 @@ include V8
 describe C::Context do  
   
   it "should not have a current context if no context is open" do
-    C::Context::GetCurrent().should be_nil
-  end
-  
-  it "can determine if there is a current context" do
-    C::Context::InContext().should be(false)
-    C::Context.new.open do |cxt|
-      C::Context::InContext().should be(true)
-    end
-  end
-  
-  it "returns the currently open context" do
-    C::Context.new.open do |cxt|
-      cxt.should be_eql(C::Context::GetCurrent())
-      cxt.should == C::Context::GetCurrent()
-    end
+    C::Context::GetEntered().should be_nil
   end
+
 end

data/spec/ext/func_spec.rb

@@ -4,39 +4,46 @@ include V8
 
 describe C::Function do
   it "is callable" do
-    C::Context.new.open do |cxt|
+    Context.new do |cxt|
       f = cxt.eval('(function() {return "Hello World"})', '<eval>');      
-      f.Call(cxt.Global).should == "Hello World"      
+      f.call(nil).should == "Hello World"      
     end
   end
   
   it "receives proper argument length from ruby" do
-    C::Context.new.open do |cxt|
+    Context.new do |cxt|
       f = cxt.eval('(function() {return arguments.length})', 'eval')
-      f.Call(nil,1, 2, 3).should == 3
+      f.call(nil,1, 2, 3).should == 3
     end
   end
   
   it "maps all arguments from ruby" do
-    C::Context.new.open do |cxt|
+    Context.new do |cxt|
       f = cxt.eval('(function(one, two, three) {return one + two + three})', 'eval')
-      f.Call(nil, 1,2,3).should == 6
+      f.call(nil, 1,2,3).should == 6
     end
   end
   
   it "properly maps ruby objects back and forth from arguments to return value" do
-    C::Context.new.open do |cxt|
+    Context.new do |cxt|
       Object.new.tap do |this|
          f = cxt.eval('(function() {return this})', 'eval')
-         f.Call(this).should be(this)
+         f.call(this).should be(this)
       end
     end
   end 
   
   it "can be called outside of a context" do
-    C::Context.new.open do |cxt|
+    Context.new do |cxt|
       @f = cxt.eval('(function() {return "Call Me"})', 'eval')
     end
-    @f.Call(nil).should == "Call Me"
+    @f.call(nil).should == "Call Me"
+  end
+  
+  it "is reflected properly" do
+    Context.new do |cxt|
+      cxt['say'] = lambda {|word, times| word * times}
+      cxt.eval('say("Hello", 3)').should == "HelloHelloHello"
+    end
   end
 end

data/spec/ext/try_catch_spec.rb

@@ -0,0 +1,32 @@
+require "#{File.dirname(__FILE__)}/../spec_helper.rb"
+
+include V8
+
+describe C::TryCatch do
+
+  it "does not allow instance creation by default" do
+    lambda {
+     C::TryCatch.new 
+    }.should raise_error
+  end
+  
+  it "will do nothing if not passed a block" do
+    C::TryCatch.try.should == nil
+  end
+  
+  it "executes a block in the context of a C++ stack frame" do
+    C::TryCatch.try do |catch|
+      catch.HasCaught().should be(false)      
+    end
+  end
+  
+  it "raises an erro if you try to access it outside of its scope" do
+    tc = C::TryCatch.try do |catch|
+      catch.tap {}
+    end
+    lambda {
+      tc.HasCaught()
+    }.should raise_error(ScriptError)
+  end
+  
+end

data/spec/foo.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+1000.times do
+  V8::Context.new do |cxt|
+    cxt['foo'] = Object.new
+  end
+end
+GC.start
+sleep(2)
+
+1000.times do
+  V8::Context.new do |cxt|
+    cxt['foo'] = Object.new
+  end
+end
+GC.start
+sleep(2)

data/spec/redjs/jsapi_spec.rb

@@ -4,76 +4,89 @@ require "#{File.dirname(__FILE__)}/../redjs_helper.rb"
 describe "Ruby Javascript API" do
 
   describe "Basic Evaluation" do
+
+    before do
+      @cxt = Context.new
+    end
+
     it "can evaluate some javascript" do
-      Context.eval("5 + 3")
+      @cxt.eval("5 + 3").should == 8
     end
   
     it "can pass back null to ruby" do
-      Context.eval("null").should be_nil      
+      @cxt.eval("null").should be_nil
     end
   
     it "can pass back undefined to ruby" do
-      Context.eval("this.undefined").should be_nil
+      @cxt.eval("this.undefined").should be_nil
     end
   
     it "can pass the empty string back to ruby" do
-      Context.eval("''").should == ""
+      @cxt.eval("''").should == ""
     end
   
     it "can pass doubles back to ruby" do
-      Context.eval("2.5").should == 2.5
+      @cxt.eval("2.5").should == 2.5
     end
   
     it "can pass fixed numbers back to ruby" do
-      Context.eval("1").should == 1
+      @cxt.eval("1").should == 1
     end
   
     it "can pass boolean values back to ruby" do
-      Context.eval("true").should be(true)
-      Context.eval("false").should be(false)
+      @cxt.eval("true").should be(true)
+      @cxt.eval("false").should be(false)
     end  
   
     it "treats nil and the empty string as the same thing when it comes to eval" do
-      Context.eval(nil).should == Context.eval('')
+      @cxt.eval(nil).should == Context.eval('')
     end
   
     it "can pass back strings to ruby" do
-      Context.open do |cxt|
-        cxt['foo'] = "Hello World"
-        cxt.eval("foo").should == "Hello World"
-      end
+      @cxt['foo'] = "Hello World"
+      @cxt.eval("foo").should == "Hello World"
     end
 
     it "can pass back very long strings to ruby" do
       lorem = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Duis faucibus, diam vel pellentesque aliquet, nisl sapien molestie eros, vitae vehicula libero massa vel neque. Phasellus tempor pharetra ipsum vel venenatis. Quisque vitae nisl vitae quam mattis pellentesque et in sapien. Sed at lectus quis eros pharetra feugiat non ac neque. Vivamus lacus eros, feugiat at volutpat at, viverra id nisl. Vivamus ac dolor eleifend libero venenatis pharetra ut iaculis arcu. Donec neque nibh, vehicula non porta a, consectetur eu erat. Sed eleifend, metus vel euismod placerat, lectus lectus sollicitudin nisl, ac elementum sem quam nec dolor. In hac habitasse platea dictumst. Proin vitae suscipit orci. Suspendisse a ipsum vel lorem tempus scelerisque et vitae neque. Proin sodales, tellus sit amet consequat cursus, odio massa ultricies enim, eu fermentum velit lectus in lacus. Quisque eu porttitor diam. Nunc felis purus, facilisis non tristique ac, pulvinar nec nulla. Duis dolor risus, egestas nec tristique ac, ullamcorper cras amet."
-      Context.open do |cxt|
-        cxt.eval("'#{lorem}'").should == lorem
-      end
+      @cxt.eval("'#{lorem}'").should == lorem
     end
   
     it "can pass objects back to ruby" do
-      Context.open do |cxt|      
-        cxt.eval("({foo: 'bar', baz: 'bang', '5': 5, embedded: {badda: 'bing'}})").tap do |object|
-          object.should_not be_nil        
-          object['foo'].should == 'bar'
-          object['baz'].should == 'bang'
-          object['5'].should == 5
-          object['embedded'].tap do |embedded|  
-            embedded.should_not be_nil
-            embedded['badda'].should == 'bing'
-          end
+      @cxt.eval("({foo: 'bar', baz: 'bang', '5': 5, embedded: {badda: 'bing'}})").tap do |object|
+        object.should_not be_nil
+        object['foo'].should == 'bar'
+        object['baz'].should == 'bang'
+        object['5'].should == 5
+        object['embedded'].tap do |embedded|
+          embedded.should_not be_nil
+          embedded['badda'].should == 'bing'
         end
       end
     end
   
     it "unwraps ruby objects returned by embedded ruby code to maintain referential integrity" do
       Object.new.tap do |o|
-        Context.open do |cxt|
-          cxt['get'] = lambda {o}
-          cxt.eval('get()').should be(o)
-        end
+        @cxt['get'] = lambda {o}
+        @cxt.eval('get()').should be(o)
+      end
+    end
+
+    it "converts arrays to javascript" do
+      @cxt['a'] = [1,2,4]
+      @cxt.eval('var sum = 0;for (var i = 0; i < a.length; i++) {sum += a[i]}; sum').should == 7
+      @cxt.eval('[1,2,3]').tap do |a|
+        a.length.should == 3
+        a.to_a.should == [1,2,3]
       end
-    end   
+    end
+
+    it "converts ruby hashes to javascript objects" do
+      @cxt['h'] = {:foo => 'bar', :baz => 'bang', :bar => {'hello' => 'world'}}
+      @cxt['h']['foo'].should == 'bar'
+      @cxt['h']['baz'].should == 'bang'
+      @cxt['h']['bar']['hello'].should == 'world'
+    end
   end
 
   describe "Calling Ruby Code From Within Javascript" do
@@ -81,15 +94,54 @@ describe "Ruby Javascript API" do
     before(:each) do
       @class = Class.new
       @instance = @class.new
+      @cxt = Context.new
+      @cxt['puts'] = lambda {|o| puts o.inspect}
+      @cxt['o'] = @instance
     end
 
     it "can embed a closure into a context and call it" do
-      Context.open do |cxt|
-        cxt["say"] = lambda {|word, times| word * times}
-        cxt.eval("say('Hello',2)").should == "HelloHello"
+      @cxt["say"] = lambda {|word, times| word * times}
+      @cxt.eval("say('Hello',2)").should == "HelloHello"
+    end
+  
+    it "translates ruby Array to Javascript Array" do
+      class_eval do
+        def ruby_array
+          []
+        end
       end
+      evaljs('o.ruby_array instanceof Array').should == true
     end
   
+    it "translates ruby Time to Javascript Date" do
+      class_eval do
+        def ruby_time
+          Time.new
+        end
+      end
+      evaljs('o.ruby_time instanceof Date').should == true
+      evaljs('o.ruby_time.valueOf()').should == Time.new.to_i
+      evaljs('new Date()').should be_kind_of(Time)
+    end
+
+    it "translates ruby true to Javascript true" do
+      class_eval do
+        def bool
+          true
+        end
+      end
+      evaljs('o.bool === true').should == true
+    end
+
+    it "translates ruby false to Javascript false" do
+      class_eval do
+        def bool
+          false
+        end
+      end
+      evaljs('o.bool === false').should == true
+    end
+
     it "can embed a ruby object into a context and call its methods" do
       class_eval do
         def say_hello(to)
@@ -109,14 +161,13 @@ describe "Ruby Javascript API" do
         end
         new(5)
       end
-      Context.open do |cxt|
-        cxt['timesfive'] = five.method(:times)
-        cxt.eval('timesfive(3)').should == 15
-      end          
+
+      @cxt['timesfive'] = five.method(:times)
+      @cxt.eval('timesfive(3)').should == 15
     end
     
     it "reports ruby methods that do not exist as undefined" do
-      Context.open(:with => Object.new) do |cxt|
+      Context.new(:with => Object.new) do |cxt|
         cxt.eval('this.foobar').should be_nil 
       end
     end
@@ -167,15 +218,13 @@ describe "Ruby Javascript API" do
     end
   
     it "will see a method that appears after the wrapper was first created" do
-      Context.open do |cxt|
-        cxt['o'] = @instance
-        class_eval do
-          def whiz(str)
-            "whiz#{str}!"
-          end
+      @cxt['o'] = @instance
+      class_eval do
+        def whiz(str)
+          "whiz#{str}!"
         end
-        cxt.eval("o.whiz('bang')").should == "whizbang!"
       end
+      @cxt.eval("o.whiz('bang')").should == "whizbang!"
     end 
   
     it "treats ruby methods that have an arity of 0 as javascript properties by default" do
@@ -215,11 +264,7 @@ describe "Ruby Javascript API" do
     end
   
     def evaljs(str)
-      Context.open do |cxt|
-        cxt['puts'] = lambda {|o| puts o.inspect}
-        cxt['o'] = @instance
-        cxt.eval(str)
-      end
+      @cxt.eval(str)
     end
   
     def class_eval(&body)
@@ -229,22 +274,28 @@ describe "Ruby Javascript API" do
   end
 
   describe "Calling JavaScript Code From Within Ruby" do
-    it "allows you to capture a reference to a javascript function and call it" do
-      Context.open do |cxt|
-        f = cxt.eval('(function add(lhs, rhs) {return lhs + rhs})')
-        f.call(nil, 1,2).should == 3
-      end
+
+    before(:each) do
+      @cxt = Context.new
     end
     
-    it "can be done outside an open context" do
-      Context.open do |cxt|
-        @f = cxt.eval('(function add(lhs, rhs) {return lhs + rhs})')
-      end
-      @f.call(nil, 1,1).should == 2
+    it "allows you to capture a reference to a javascript function and call it" do
+      f = @cxt.eval('(function add(lhs, rhs) {return lhs + rhs})')
+      f.call(nil, 1,2).should == 3
+    end
+
+    it "unwraps objects that are backed by javascript objects to pass their native equivalents" do |cxt|
+      @cxt.eval('obj = {foo: "bar"}')
+      f = @cxt.eval('(function() {return this == obj})')
+      f.call(@cxt['obj']).should be(true)
     end
   end
 
   describe "Setting up the Host Environment" do
+    before(:each) do
+      @cxt = Context.new
+    end
+
     it "can eval javascript with a given ruby object as the scope." do
       scope = Class.new.class_eval do
         def plus(lhs, rhs)
@@ -258,7 +309,7 @@ describe "Ruby Javascript API" do
         new
       end
 
-      Context.open(:with => scope) do |cxt|
+      Context.new(:with => scope) do |cxt|
         cxt.eval("plus(1,2)").should == 3
         cxt.eval("minus(10, 20)").should == -10
         cxt.eval("this").should be(scope)
@@ -266,18 +317,22 @@ describe "Ruby Javascript API" do
     end
   
     it "can directly embed ruby values into javascript" do
-      Context.open do |cxt|
-        cxt["bar"] = 9
-        cxt['foo'] = "bar"
-        cxt['num'] = 3.14
-        cxt['trU'] = true
-        cxt['falls'] = false
-        cxt.eval("bar + 10").should be(19)
-        cxt.eval('foo').should == "bar"
-        cxt.eval('num').should == 3.14
-        cxt.eval('trU').should be(true)
-        cxt.eval('falls').should be(false)      
-      end
+      @cxt["bar"] = 9
+      @cxt['foo'] = "bar"
+      @cxt['num'] = 3.14
+      @cxt['trU'] = true
+      @cxt['falls'] = false
+      @cxt.eval("bar + 10").should be(19)
+      @cxt.eval('foo').should == "bar"
+      @cxt.eval('num').should == 3.14
+      @cxt.eval('trU').should be(true)
+      @cxt.eval('falls').should be(false)
+    end
+    
+    it "has the global object available as a javascript value" do
+      @cxt['foo'] = 'bar'
+      @cxt.scope.should be_kind_of(V8::Object)
+      @cxt.scope['foo'].should == 'bar'
     end
     
     it "extends object to allow for the arbitrary execution of javascript with any object as the scope" do
@@ -298,7 +353,7 @@ describe "Ruby Javascript API" do
     it "can limit the number of instructions that are executed in the context" do
       pending "haven't figured out how to constrain resources in V8"
       lambda {
-        Context.open do |cxt|
+        Context.new do |cxt|
           cxt.instruction_limit = 100 * 1000
           timeout(1) do
             cxt.eval('while (true);')
@@ -325,7 +380,7 @@ describe "Ruby Javascript API" do
   foo = 'bar'
   five();
       EOJS
-      Context.open do |cxt|
+      Context.new do |cxt|
         cxt.eval(source, "StringIO").should == 5
         cxt['foo'].should == "bar"
       end
@@ -334,7 +389,7 @@ describe "Ruby Javascript API" do
     it "can load a file into the runtime" do
       mock(:JavascriptSourceFile).tap do |file|
         File.should_receive(:open).with("path/to/mysource.js").and_yield(file)
-        Context.open do |cxt|
+        Context.new do |cxt|
           cxt.should_receive(:evaluate).with(file, "path/to/mysource.js", 1)
           cxt.load("path/to/mysource.js")
         end
@@ -346,16 +401,12 @@ describe "Ruby Javascript API" do
   describe "A Javascript Object Reflected Into Ruby" do
   
     before(:each) do
-      @o = Context.open do |cxt|
-        @cxt = cxt      
-        cxt.eval("o = new Object(); o")
-      end
+      @cxt = Context.new
+      @o = @cxt.eval("o = new Object(); o")
     end
   
     def evaljs(js)
-      @cxt.open do
-        @cxt.eval(js)
-      end
+      @cxt.eval(js)
     end
   
     it "can have its properties manipulated via ruby style [] hash access" do
@@ -377,7 +428,7 @@ describe "Ruby Javascript API" do
     end
 
     it "traverses the prototype chain when hash accessing properties from the ruby object" do
-      Context.open do |cxt|
+      Context.new do |cxt|
         cxt.eval(<<EOJS)['bar'].should == "baz"
 function Foo() {}
 Foo.prototype.bar = 'baz'
@@ -387,14 +438,12 @@ EOJS
     end
 
     it "is enumenable" do
-      @cxt.open do
-        evaljs("o.foo = 'bar'; o.bang = 'baz'; o[5] = 'flip'")
-        {}.tap do |h|
-          @o.each do |k,v|
-            h[k] = v
-          end
-          h.should == {"foo" => 'bar', "bang" => 'baz', 5 => 'flip'}
+      evaljs("o.foo = 'bar'; o.bang = 'baz'; o[5] = 'flip'")
+      {}.tap do |h|
+        @o.each do |k,v|
+          h[k] = v
         end
+        h.should == {"foo" => 'bar', "bang" => 'baz', 5 => 'flip'}
       end
     end  
 end
@@ -402,7 +451,7 @@ end
   describe "Exception Handling" do
     it "raises javascript exceptions as ruby exceptions" do
       lambda {
-        Context.new.eval('foo')
+        Context.eval('foo')
       }.should raise_error(JavascriptError)
     end
 
@@ -414,13 +463,41 @@ end
     
     it "should track message state" do
       begin        
-        Context.open do |cxt|
-          cxt.eval("var foo = 'bar';\nsyntax error!", "foo.js")
-        end
+        Context.new.eval("var foo = 'bar';\nsyntax error!", "foo.js")
       rescue JavascriptError => e
         e.line_number.should == 2
         e.source_name.should == "foo.js"
       end
     end
+
+    it "translates ruby exceptions into javascript exceptions if they are thrown from code called it javascript" do
+      Context.new do |cxt|
+        cxt['rputs'] = lambda {|msg| rputs msg}
+        cxt['boom'] = lambda do
+          raise "BOOM!"
+        end
+        cxt.eval('var msg;try {boom()} catch (e) {msg = e.message};msg').should == 'BOOM!'
+      end
+    end
+
+    it "will allow exceptions to pass through multiple languages boundaries (i.e. js -> rb -> js -> rb)" do
+      Context.new do |cxt|
+        cxt['one'] = lambda do
+          cxt.eval('two()', 'one.js')
+        end
+        cxt['two'] = lambda do
+          cxt.eval('three()', 'two.js')
+        end
+        cxt['three'] = lambda do
+          cxt.eval('throw "BOOM!"', "three.js")
+        end
+        lambda {
+          cxt['one'].call(cxt.scope)
+        }.should raise_error {|e|
+          #TODO: assert something about the contents of the stack?
+          #--cowboyd 05/25/2010
+        }
+      end
+    end
   end
 end