therubyracer 0.7.1 → 0.7.2.pre

data/lib/v8/error.rb

@@ -0,0 +1,111 @@
+
+module V8
+  class JSError < StandardError
+    attr_reader :value, :boundaries
+
+    def initialize(try)
+      begin
+        super(initialize_unsafe(try))
+      rescue Exception => e
+        @boundaries = Boundary.new(:rbframes => e.backtrace)
+        @value = e
+        super("BUG! please report. JSError#initialize failed!: #{e.message}")
+      end
+    end
+
+    def initialize_unsafe(try)
+      message = nil
+      ex = To.rb(try.Exception())
+      @boundaries = [Boundary.new :rbframes => caller(3), :jsframes => parse_js_frames(try)]
+      if V8::Object === ex
+        if msg = ex['message']
+          message = msg
+        else
+          message = ex.to_s
+        end
+        if cause = ex.instance_variable_get(:@native).GetHiddenValue("TheRubyRacer::Cause")
+          if !cause.IsEmpty()
+            prev = cause.Value()
+            if prev.kind_of?(JSError)
+              @boundaries.concat prev.boundaries
+              @value = prev.value
+            else
+              @value = prev
+              @boundaries.concat [Boundary.new(:rbframes => prev.backtrace)]
+            end
+          else
+            @value = ex
+          end
+        end
+      else
+        @value = ex
+        message = ex.to_s
+        @boundaries.first.jsframes << 'at [???].js'
+      end
+      return message
+    end
+
+    def in_ruby?
+      @value.kind_of?(Exception)
+    end
+
+    def in_javascript?
+      !in_ruby?
+    end
+
+    def backtrace(*modifiers)
+      trace_framework = modifiers.include?(:framework)
+      trace_ruby = modifiers.length == 0 || modifiers.include?(:ruby)
+      trace_javascript = modifiers.length == 0 || modifiers.include?(:javascript)
+      mixed = []
+      rbcontext = []
+      jscontext = []
+      @boundaries.each do |b|
+        rbframes = b.rbframes.dup
+        rbcontext.reverse_each do |frame|
+          if frame == rbframes.last
+            rbframes.pop
+          else
+            break
+          end
+        end if trace_ruby
+        jsframes = b.jsframes.dup
+        jscontext.reverse_each do |frame|
+          if frame == jsframes.last
+            jsframes.pop
+          else
+            break
+          end
+        end if trace_javascript
+        rbcontext = b.rbframes
+        jscontext = b.jsframes
+        rbframes.reject! {|f| f =~ /lib\/v8\/\w+\.rb/} unless trace_framework
+        mixed.unshift(*rbframes) if trace_ruby
+        mixed.unshift(*jsframes) if trace_javascript
+      end
+      return mixed
+    end
+
+    def parse_js_frames(try)
+      raw = To.rb(try.StackTrace())
+      if raw && !raw.empty?
+        raw.split("\n")[1..-1].tap do |frames|
+          frames.each {|frame| frame.strip!.chomp!(",")}
+        end
+      else
+        []
+      end
+    end
+
+    class Boundary
+      attr_reader :rbframes, :jsframes
+
+      def initialize(frames = {})
+        @rbframes = frames[:rbframes] || []
+        @jsframes = frames[:jsframes] || []
+      end
+    end
+  end
+  #deprecated -- use JSError
+  JavasriptError = JSError
+end

data/lib/v8/function.rb

@@ -7,8 +7,8 @@ module V8
       C::TryCatch.try do |try|
         @context.enter do
           this = To.v8(thisObject)
-          return_value = To.ruby(@native.Call(this, To.v8(args)))
-          err = JavascriptError.new(try) if try.HasCaught()
+          return_value = To.rb(@native.Call(this, To.v8(args)))
+          err = JSError.new(try) if try.HasCaught()
         end
       end
       raise err if err
@@ -28,10 +28,11 @@ module V8
     def self.rubycall(rubycode, *args)
       begin
         To.v8(rubycode.call(*args))
-      rescue StandardError => e
-        V8::C::ThrowException(V8::C::Exception::Error(V8::C::String::New(e.message)))
+      rescue Exception => e
+        error = V8::C::Exception::Error(V8::C::String::New(e.message))
+        error.SetHiddenValue("TheRubyRacer::Cause", C::External::New(e))
+        V8::C::ThrowException(error)
       end
     end
-
   end
 end

data/lib/v8/object.rb

@@ -11,7 +11,7 @@ module V8
 
     def [](key)
       @context.enter do
-        To.ruby(@native.Get(To.v8(key)))        
+        To.rb(@native.Get(To.v8(key)))
       end
     end
 

data/lib/v8/to.rb

@@ -1,32 +1,34 @@
+require 'weakref'
 
 module V8
   module To
     class << self
-      def ruby(value)
+      def rb(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::Function  then peer(value) {V8::Function}
+        when V8::C::Array     then peer(value) {V8::Array}
+        when V8::C::Object    then peer(value) {V8::Object}
         when V8::C::String    then value.Utf8Value()
         when V8::C::Date      then Time.at(value.NumberValue())
+        when V8::C::Value     then nil if value.IsEmpty()
         else
           value
         end
       end
 
-      alias_method :rb, :ruby
-
       def v8(value)
         case value
         when V8::Object
           value.instance_eval {@native}
-        when String, Symbol
+        when String
           C::String::New(value.to_s)
+        when Symbol
+          C::String::NewSymbol(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])
+              rbargs << To.rb(arguments[i])
             end
             V8::Function.rubycall(value, *rbargs)
           end
@@ -45,35 +47,29 @@ module V8
           end
         when ::Time
           C::Date::New(value)
+        when ::Class
+          Constructors[value].GetFunction().tap do |f|
+            f.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), C::External::New(value))
+          end
         when nil,Numeric,TrueClass,FalseClass, C::Value
           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
+          args = C::Array::New(1)
+          args.Set(0, C::External::New(value))
+          obj = Access[value.class].GetFunction().NewInstance(args)
           return obj
         end
       end
 
+      def peer(value)
+        external = value.GetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"))
+        if external && !external.IsEmpty()
+          external.Value()
+        else
+          yield.new(value)
+        end
+      end
+
       def camel_case(str)
         str.to_s.gsub(/_(\w)/) {$1.upcase}
       end

data/spec/redjs/jsapi_spec.rb

@@ -354,7 +354,7 @@ describe "Ruby Javascript API" do
         cxt.eval("this").should be(scope)
       end    
     end
-  
+
     it "can directly embed ruby values into javascript" do
       @cxt["bar"] = 9
       @cxt['foo'] = "bar"
@@ -367,12 +367,62 @@ describe "Ruby Javascript API" do
       @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 "will treat class objects as constructors by default" do
+      @cxt[:MyClass] = Class.new.tap do |cls|
+        cls.class_eval do
+          attr_reader :one, :two
+          def initialize(one, two)
+            @one, @two = one, two
+            # rputs "one: #{@one}, two: #{@two}"
+          end
+        end
+      end
+      @cxt.eval('new MyClass(1,2).one').should == 1
+      @cxt.eval('new MyClass(1,2).two').should == 2
+    end
+
+    it "unwraps reflected ruby constructor objects into their underlying ruby classes" do
+      @cxt['RubyObject'] = Object
+      @cxt['RubyObject'].should be(Object)
+    end
+
+    it "honors the instanceof operator for ruby instances when compared to their reflected constructors" do
+      @cxt['RubyObject'] = Object
+      @cxt['one'] = Object.new
+      @cxt['two'] = Object.new
+      @cxt.eval('one instanceof RubyObject')
+      @cxt.eval('two instanceof RubyObject')
+      @cxt.eval('RubyObject instanceof Function').should be(true)
+      @cxt.eval('new RubyObject() instanceof RubyObject').should be(true)
+      @cxt.eval('new RubyObject() instanceof Array').should be(false)
+      @cxt.eval('new RubyObject() instanceof Object').should be(true)
+    end
+
+    it "unwraps instances created by a native constructor when passing them back to ruby" do
+      cls = Class.new.tap do |c|
+        c.class_eval do
+          def definitely_a_product_of_this_one_off_class?
+            true
+          end
+        end
+      end
+      @cxt['RubyClass'] = cls
+      @cxt.eval('new RubyClass()').should be_definitely_a_product_of_this_one_off_class
+    end
+
+    it "does not allow you to call a native ruby constructor, unless that constructor has been directly embedded" do
+      @cxt['o'] = Class.new.new
+      lambda {
+        @cxt.eval('new (o.constructor)()')
+      }.should raise_error(JSError)
+    end
     
     it "extends object to allow for the arbitrary execution of javascript with any object as the scope" do
       Class.new.class_eval do
@@ -388,7 +438,7 @@ describe "Ruby Javascript API" do
         new.eval_js("timesfive(6)").should == 30
       end
     end
-  
+
     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 {
@@ -402,7 +452,7 @@ describe "Ruby Javascript API" do
     end    
   end
 
-  describe "loading javascript source into the interpreter" do
+  describe "Loading javascript source into the interpreter" do
 
     it "can take an IO object in the eval method instead of a string" do
       source = StringIO.new(<<-EOJS)
@@ -491,7 +541,7 @@ end
     it "raises javascript exceptions as ruby exceptions" do
       lambda {
         Context.eval('foo')
-      }.should raise_error(JavascriptError)
+      }.should raise_error(JSError)
     end
 
     it "can handle syntax errors" do
@@ -499,15 +549,6 @@ end
     		Context.eval('does not compiles')
     	}.should raise_error
     end
-    
-    it "should track message state" do
-      begin        
-        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|

data/spec/v8/error_spec.rb

@@ -0,0 +1,118 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe V8::JSError do
+  
+  before(:each) do
+    @cxt = V8::Context.new
+    @cxt['one'] = lambda do
+      @cxt.eval('two()', 'one.js')
+    end
+    @cxt['two'] = lambda do
+      @cxt.eval('three()', 'two.js')
+    end
+  end
+  
+  it "captures a message without over nesting when the error is an error" do
+    throw! do |e|
+      e.message.should == "BOOM!"
+    end
+  end
+  
+  it "captures the js message without over nesting when the error is a normal object" do
+    throw!('{foo: "bar"}') do |e|
+      e.message.should == "[object Object]"
+    end
+    throw!('{message: "bar"}') do |e|
+      e.message.should == "bar"
+    end
+  end
+  
+  it "captures a thrown value as the message" do
+    throw!('"BOOM!"') do |e|
+      e.message.should == "BOOM!"
+    end
+    throw!('6') do |e|
+      e.message.should == '6'
+    end
+  end
+  
+  it "has a reference to the root javascript cause" do
+    throw!('"I am a String"') do |e|
+      e.should_not be_in_ruby
+      e.should be_in_javascript 
+      e.value.should == "I am a String"
+    end
+  end
+  
+  it "has a reference to the root ruby cause if one exists" do
+    StandardError.new("BOOM!").tap do |bomb|
+      @cxt['boom'] = lambda do
+        raise bomb
+      end
+      lambda {
+        @cxt.eval('boom()', 'boom.js')
+      }.should(raise_error do |raised|
+        raised.should be_in_ruby 
+        raised.should_not be_in_javascript 
+        raised.value.should be(bomb)
+      end)
+    end
+  end
+  
+  describe "backtrace" do
+    
+    it "is mixed with ruby and javascript" do
+      throw! do |e|
+        e.backtrace.first.should == "at three.js:1:7"
+        e.backtrace[1].should =~ /error_spec.rb/
+        e.backtrace[2].should == "at two.js:1:1"
+        e.backtrace[3].should =~ /error_spec.rb/
+        e.backtrace[4].should == "at one.js:1:1"
+      end
+    end
+    
+    it "can be set to show only ruby frames" do
+      throw! do |e|
+        e.backtrace(:ruby).each do |frame|
+          frame.should =~ /(\.rb|):\d+/
+        end
+      end
+    end
+    
+    it "can be set to show only javascript frames" do
+      throw! do |e|
+        e.backtrace(:javascript).each do |frame|
+          frame.should =~ /\.js:\d:\d/
+        end
+      end
+    end
+    
+    it "includes a mystery marker when the original frame is unavailable because what got thrown wasn't an error" do
+      throw!("6") do |e|
+        e.backtrace.first.should == 'at [???].js'
+      end
+    end
+    
+    it "can start with ruby at the bottom" do
+      @cxt['boom'] = lambda do
+        raise StandardError, "Bif!"
+      end
+      lambda {
+        @cxt.eval('boom()', "boom.js")
+      }.should(raise_error {|e|
+        e.backtrace.first.should =~ /error_spec\.rb/
+        e.backtrace[1].should =~ /boom.js/
+      })
+    end
+  end
+  
+  
+  def throw!(js = "new Error('BOOM!')", &block)
+    @cxt['three'] = lambda do
+      @cxt.eval("throw #{js}", 'three.js')
+    end
+    lambda do
+      @cxt['one'].call()
+    end.should(raise_error(V8::JSError, &block))
+  end
+end