therubyracer 0.11.0beta7-x86-linux → 0.11.0beta8-x86-linux

data/ext/v8/backref.cc

@@ -7,7 +7,7 @@ namespace rr {
   ID Backref::object;
 
   void Backref::Init() {
-    Storage = rb_eval_string("Ref::WeakReference");
+    Storage = rb_eval_string("V8::Weak::Ref");
     rb_gc_register_address(&Storage);
     _new = rb_intern("new");
     object = rb_intern("object");

data/ext/v8/stack.cc

@@ -22,6 +22,7 @@ namespace rr {
       defineMethod("GetColumn", &Frame::GetColumn).
       defineMethod("GetScriptName", &Frame::GetScriptName).
       defineMethod("GetScriptNameOrSourceURL", &Frame::GetScriptNameOrSourceURL).
+      defineMethod("GetFunctionName", &Frame::GetFunctionName).
       defineMethod("IsEval", &Frame::IsEval).
       defineMethod("IsConstructor", &Frame::IsConstructor).
       store(&Frame::Class);

data/lib/v8.rb

@@ -1,9 +1,9 @@
 require "v8/version"
 
-require 'ref'
+require 'v8/weak'
 require 'v8/init'
-require 'v8/util/weakcell'
 require 'v8/error'
+require 'v8/stack'
 require 'v8/conversion/fundamental'
 require 'v8/conversion/indentity'
 require 'v8/conversion/reference'

data/lib/v8/conversion/code.rb

@@ -1,6 +1,6 @@
 class V8::Conversion
   module Code
-    include V8::Util::Weakcell
+    include V8::Weak::Cell
 
     def to_v8
       fn = to_template.GetFunction()

data/lib/v8/conversion/indentity.rb

@@ -21,11 +21,11 @@ class V8::Conversion
     end
 
     def v8_idmap
-      @v8_idmap ||= Ref::WeakValueMap.new
+      @v8_idmap ||= V8::Weak::WeakValueMap.new
     end
 
     def rb_idmap
-      @ruby_idmap ||= Ref::WeakValueMap.new
+      @ruby_idmap ||= V8::Weak::WeakValueMap.new
     end
   end
 end

data/lib/v8/conversion/method.rb

@@ -9,7 +9,7 @@ class V8::Conversion
 
     class MethodCache
       def initialize
-        @map = Ref::WeakValueMap.new
+        @map = V8::Weak::WeakValueMap.new
       end
 
       def [](method)

data/lib/v8/error.rb

@@ -1,18 +1,89 @@
 module V8
+  # capture 99 stack frames on exception with normal details.
+  # You can adjust these values for performance or turn of stack capture entirely
+  V8::C::V8::SetCaptureStackTraceForUncaughtExceptions(true, 99, V8::C::StackTrace::kOverview)
   class Error < StandardError
+    include Enumerable
+
+    # @!attribute [r] value
+    # @return [Object] the JavaScript value passed to the `throw` statement
     attr_reader :value
-    def initialize(message, value)
+
+    # @!attribute [r] cause
+    # @return [Exception] the underlying error (if any) that triggered this error to be raised
+    attr_reader :cause
+
+    # @!attribute [V8::StackTrace] javascript_backtrace
+    # @return the complete JavaScript stack at the point this error was thrown
+    attr_reader :javascript_backtrace
+
+    # keep an alias to the StandardError#backtrace method so that we can capture
+    # just ruby backtrace frames
+    alias_method :standard_error_backtrace, :backtrace
+
+    def initialize(message, value, javascript_backtrace, cause = nil)
       super(message)
       @value = value
+      @cause = cause
+      @javascript_backtrace = javascript_backtrace
+    end
+
+    def causes
+      [].tap do |causes|
+        current = self
+        until current.nil? do
+          causes.push current
+          current = current.respond_to?(:cause) ? current.cause : nil
+        end
+      end
+    end
+
+    def backtrace(*modifiers)
+      return unless super()
+      trace_framework = modifiers.include?(:framework)
+      trace_ruby = modifiers.length == 0 || modifiers.include?(:ruby)
+      trace_javascript = modifiers.length == 0 || modifiers.include?(:javascript)
+      bilingual_backtrace(trace_ruby, trace_javascript).tap do |trace|
+        trace.reject! {|frame| frame =~  %r{(lib/v8/.*\.rb|ext/v8/.*\.cc)}} unless modifiers.include?(:framework)
+      end
+    end
+
+    def root_cause
+      causes.last
+    end
+
+    def in_javascript?
+      causes.last.is_a? self.class
+    end
+
+    def in_ruby?
+      !in_javascript?
+    end
+
+    def bilingual_backtrace(trace_ruby = true, trace_javascript = true)
+      backtrace = causes.reduce(:backtrace => [], :ruby => -1, :javascript => -1) { |accumulator, cause|
+        accumulator.tap do
+          if trace_ruby
+            backtrace_selector = cause.respond_to?(:standard_error_backtrace) ? :standard_error_backtrace : :backtrace
+            ruby_frames = cause.send(backtrace_selector)[0..accumulator[:ruby]]
+            accumulator[:backtrace].unshift *ruby_frames
+            accumulator[:ruby] -= ruby_frames.length
+          end
+          if trace_javascript && cause.respond_to?(:javascript_backtrace)
+            javascript_frames = cause.javascript_backtrace.to_a[0..accumulator[:javascript]].map(&:to_s)
+            accumulator[:backtrace].unshift *javascript_frames
+            accumulator[:javascript] -= javascript_frames.length
+          end
+        end
+      }[:backtrace]
     end
 
     module Try
       def try
-        context = V8::Context.current
         V8::C::TryCatch() do |trycatch|
           result = yield
           if trycatch.HasCaught()
-            V8::Error(trycatch.Exception())
+            raise V8::Error(trycatch)
           else
             result
           end
@@ -23,37 +94,41 @@ module V8
     module Protect
       def protect
         yield
-      rescue Football => e
-        e.kickoff!
       rescue Exception => e
-        e.extend Football
-        e.kickoff!
-      end
-    end
-
-    module Football
-      def kickoff!
-        error = V8::C::Exception::Error(message)
-        error.SetHiddenValue("rr::Football", V8::C::External::New(self))
+        error = V8::C::Exception::Error(e.message)
+        error.SetHiddenValue("rr::Cause", V8::C::External::New(e))
         V8::C::ThrowException(error)
       end
     end
 
   end
 
-  def self.Error(exception)
+  def self.Error(trycatch)
+    exception = trycatch.Exception()
     value = exception.to_ruby
-    if !exception.kind_of?(V8::C::Value)
-      raise V8::Error.new(exception.to_s, value)
+    cause = nil
+    javascript_backtrace = V8::StackTrace.new(trycatch.Message().GetStackTrace())
+    message = if !exception.kind_of?(V8::C::Value)
+      exception.to_s
     elsif exception.IsNativeError()
-      if football = exception.GetHiddenValue("rr::Football")
-        raise football.Value()
+      if cause = exception.GetHiddenValue("rr::Cause")
+        cause = cause.Value()
+      end
+      # SyntaxErrors do not have a JavaScript stack (even if they occur during js execution).
+      # To caputre where the error occured, we need to put it in the message
+      if value['constructor'] == V8::Context.current['SyntaxError']
+        info = trycatch.Message()
+        resource_name = info.GetScriptResourceName().to_ruby
+        "#{value['message']} at #{resource_name}:#{info.GetLineNumber()}:#{info.GetStartColumn() + 1}"
       else
-        raise V8::Error.new(exception.Get("message").to_ruby, value)
+        exception.Get("message").to_ruby
       end
+    elsif exception.IsObject()
+      value['message'] || value.to_s
     else
-      raise V8::Error.new(exception.ToString().to_ruby, value)
+      value.to_s
     end
+    V8::Error.new(message, value, javascript_backtrace, cause)
   end
   const_set :JSError, Error
 end

data/lib/v8/stack.rb

@@ -0,0 +1,85 @@
+
+module V8
+
+  class StackTrace
+    include Enumerable
+
+    def initialize(native)
+      @context = V8::Context.current
+      @native = native
+    end
+
+    def length
+      @context.enter do
+        @native ? @native.GetFrameCount() : 0
+      end
+    end
+
+    def each
+      return unless @native
+      @context.enter do
+        for i in 0..length - 1
+          yield V8::StackFrame.new(@native.GetFrame(i), @context)
+        end
+      end
+    end
+
+    def to_s
+      @native ? map(&:to_s).join("\n") : ""
+    end
+  end
+
+  class StackFrame
+
+    def initialize(native, context)
+      @context = context
+      @native = native
+    end
+
+    def script_name
+      @context.enter do
+        @context.to_ruby(@native.GetScriptName())
+      end
+    end
+
+    def function_name
+      @context.enter do
+        @context.to_ruby(@native.GetFunctionName())
+      end
+    end
+
+    def line_number
+      @context.enter do
+        @native.GetLineNumber()
+      end
+    end
+
+    def column
+      @context.enter do
+        @native.GetColumn()
+      end
+    end
+
+    def eval?
+      @context.enter do
+        @native.IsEval()
+      end
+    end
+
+    def constructor?
+      @context.enter do
+        @native.IsConstructor()
+      end
+    end
+
+    def to_s
+      @context.enter do
+        "at " + if !function_name.empty?
+          "#{function_name} (#{script_name}:#{line_number}:#{column})"
+        else
+          "#{script_name}:#{line_number}:#{column}"
+        end
+      end
+    end
+  end
+end

data/lib/v8/version.rb

@@ -1,3 +1,3 @@
 module V8
-  VERSION = "0.11.0beta7"
+  VERSION = "0.11.0beta8"
 end

data/lib/v8/weak.rb

@@ -0,0 +1,70 @@
+module V8
+  module Weak
+    # weak refs are broken on MRI 1.9 and merely slow on 1.8
+    # so we mitigate this by using the 'ref' gem. However, this
+    # only mitigates the problem. Under heavy load, you will still
+    # get different or terminated objects being returned. bad stuff
+    #
+    # for other platforms we just use the stdlib 'weakref'
+    # implementation
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
+      require 'ref'
+      Ref = ::Ref::WeakReference
+      WeakValueMap = ::Ref::WeakValueMap
+    else
+      require 'weakref'
+      class Ref
+        def initialize(object)
+          @ref = ::WeakRef.new(object)
+        end
+        def object
+          @ref.__getobj__
+        rescue ::WeakRef::RefError
+          nil
+        end
+      end
+
+      class WeakValueMap
+        def initialize
+          @values = {}
+        end
+
+        def [](key)
+          if ref = @values[key]
+            ref.object
+          end
+        end
+
+        def []=(key, value)
+          @values[key] = V8::Weak::Ref.new(value)
+        end
+      end
+    end
+
+    module Cell
+      def weakcell(name, &block)
+        unless storage = instance_variable_get("@#{name}")
+          storage = instance_variable_set("@#{name}", Storage.new)
+        end
+        storage.access(&block)
+      end
+      class Storage
+        def access(&block)
+          if @ref
+            @ref.object || populate(block)
+          else
+            populate(block)
+          end
+        end
+
+        private
+
+        def populate(block)
+          occupant = block.call()
+          @ref = V8::Weak::Ref.new(occupant)
+          return occupant
+        end
+      end
+    end
+  end
+end

data/spec/v8/error_spec.rb

@@ -1,21 +1,165 @@
 require 'spec_helper'
 
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
 describe V8::Error do
-  it "uses the same ruby exception through multiple language boundaries" do
-    V8::Context.new do |cxt|
-      error = StandardError.new('potato')
-      cxt['one'] = lambda do
-        cxt.eval('two()', 'one.js')
+
+  before 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['message'].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
-      cxt['two'] = lambda do
-        cxt.eval('three()', 'two.js')
+      lambda {
+        @cxt.eval('boom()', 'boom.js')
+      }.should(raise_error do |raised|
+        raised.should be_in_ruby
+        raised.should_not be_in_javascript
+        raised.root_cause.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
-      cxt['three'] = lambda do
-        raise error
+    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 three.js:1:1'
+      end
+    end
+
+    it "has a source name and line number when there is a javascript SyntaxError" do
+      lambda do
+        @cxt.eval(<<-INVALID, 'source.js')
+"this line is okay";
+"this line has a syntax error because it ends with a colon":
+"this line is also okay";
+"how do I find out that line 2 has the syntax error?";
+INVALID
+      end.should raise_error(V8::JSError) {|error|
+        error.message.should eql 'Unexpected token : at source.js:2:61'
+      }
+    end
+
+    it "can start with ruby at the bottom" do
+      @cxt['boom'] = lambda do
+        raise StandardError, "Bif!"
       end
       lambda {
-        cxt.eval('one()')
-      }.should raise_error {|e| e.should be error}
+        @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
+
+
+# describe V8::Error do
+#   describe "A ruby exception thrown inside JavaScript" do
+#     before do
+#       @error = StandardError.new('potato')
+#       begin
+#         V8::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
+#             raise @error
+#           end
+#           cxt.eval('one()')
+#         end
+#       rescue StandardError => e
+#         @thrown = e
+#       end
+#     end
+#     it "is raised up through the call stack" do
+#       @thrown.should be(@error)
+#     end
+#
+#     it "shows both the javascript and the ruby callframes" do
+#       puts @error.backtrace.join('<br/>')
+#     end
+#
+#   end
+# end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: therubyracer
 version: !ruby/object:Gem::Version
-  version: 0.11.0beta7
+  version: 0.11.0beta8
   segments: 
   hash: 
 platform: x86-linux
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-09 00:00:00.000000000 Z
+date: 2012-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ref
@@ -104,8 +104,9 @@ files:
 - lib/v8/error.rb
 - lib/v8/function.rb
 - lib/v8/object.rb
-- lib/v8/util/weakcell.rb
+- lib/v8/stack.rb
 - lib/v8/version.rb
+- lib/v8/weak.rb
 - spec/c/array_spec.rb
 - spec/c/constants_spec.rb
 - spec/c/exception_spec.rb

data/lib/v8/util/weakcell.rb

@@ -1,29 +0,0 @@
-module V8
-  module Util
-    module Weakcell
-      def weakcell(name, &block)
-        unless storage = instance_variable_get("@#{name}")
-          storage = instance_variable_set("@#{name}", Storage.new)
-        end
-        storage.access(&block)
-      end
-      class Storage
-        def access(&block)
-          if @ref
-            @ref.object || populate(block)
-          else
-            populate(block)
-          end
-        end
-
-        private
-
-        def populate(block)
-          occupant = block.call()
-          @ref = Ref::WeakReference.new(occupant)
-          return occupant
-        end
-      end
-    end
-  end
-end