therubyracer 0.10.2 → 0.11.0beta1

data/lib/v8/conversion/code.rb

@@ -0,0 +1,38 @@
+class V8::Conversion
+  module Code
+    include V8::Util::Weakcell
+
+    def to_v8
+      fn = to_template.GetFunction()
+      V8::Context.link self, fn
+      return fn
+    end
+
+    def to_template
+      weakcell(:template) {V8::C::FunctionTemplate::New(InvocationHandler.new(self))}
+    end
+
+    class InvocationHandler
+      include V8::Error::Protect
+
+      def initialize(code)
+        @code = code
+      end
+
+      def call(arguments)
+        protect do
+          context = V8::Context.current
+          access = context.access
+          args = ::Array.new(arguments.Length())
+          0.upto(args.length - 1) do |i|
+            if i < args.length
+              args[i] = context.to_ruby arguments[i]
+            end
+          end
+          this = context.to_ruby arguments.This()
+          context.to_v8 access.methodcall(@code, this, args)
+        end
+      end
+    end
+  end
+end

data/lib/v8/conversion/fundamental.rb

@@ -0,0 +1,11 @@
+class V8::Conversion
+  module Fundamental
+    def to_ruby(v8_object)
+      v8_object.to_ruby
+    end
+
+    def to_v8(ruby_object)
+      ruby_object.to_v8
+    end
+  end
+end

data/lib/v8/conversion/hash.rb

@@ -0,0 +1,11 @@
+class V8::Conversion
+  module Hash
+    def to_v8
+      object = V8::Object.new
+      each do |key, value|
+        object[key] = value
+      end
+      return object.to_v8
+    end
+  end
+end

data/lib/v8/conversion/indentity.rb

@@ -0,0 +1,31 @@
+require 'ref'
+
+class V8::Conversion
+  module Identity
+    def to_ruby(v8_object)
+      if v8_object.class <= V8::C::Object
+        v8_idmap[v8_object.GetIdentityHash()] || super(v8_object)
+      else
+        super(v8_object)
+      end
+    end
+
+    def to_v8(ruby_object)
+      return super(ruby_object) if ruby_object.is_a?(String) || ruby_object.is_a?(Primitive)
+      rb_idmap[ruby_object.object_id] || super(ruby_object)
+    end
+
+    def equate(ruby_object, v8_object)
+      v8_idmap[v8_object.GetIdentityHash()] = ruby_object
+      rb_idmap[ruby_object.object_id] = v8_object
+    end
+
+    def v8_idmap
+      @v8_idmap ||= Ref::WeakValueMap.new
+    end
+
+    def rb_idmap
+      @ruby_idmap ||= Ref::WeakValueMap.new
+    end
+  end
+end

data/lib/v8/conversion/method.rb

@@ -0,0 +1,26 @@
+class V8::Conversion
+  module Method
+    include V8::Conversion::Code
+
+    def to_v8
+      template = @@method_cache[self] ||= to_template
+      template.GetFunction()
+    end
+
+    class MethodCache
+      def initialize
+        @map = Ref::WeakValueMap.new
+      end
+
+      def [](method)
+        @map[method.to_s]
+      end
+
+      def []=(method, template)
+        @map[method.to_s] = template
+      end
+    end
+
+    @@method_cache = MethodCache.new
+  end
+end

data/lib/v8/conversion/object.rb

@@ -0,0 +1,28 @@
+class V8::Conversion
+  module Object
+    def to_v8
+      Reference.construct! self
+    end
+
+    def to_ruby
+      self
+    end
+  end
+
+  module NativeObject
+    def to_ruby
+      wrap = if IsArray()
+        ::V8::Array
+      elsif IsFunction()
+        ::V8::Function
+      else
+        ::V8::Object
+      end
+      wrap.new(self)
+    end
+
+    def to_v8
+      self
+    end
+  end
+end

data/lib/v8/conversion/primitive.rb

@@ -0,0 +1,7 @@
+class V8::Conversion
+  module Primitive
+    def to_v8
+      return self
+    end
+  end
+end

data/lib/v8/conversion/proc.rb

@@ -0,0 +1,5 @@
+class V8::Conversion
+  module Proc
+    include V8::Conversion::Code
+  end
+end

data/lib/v8/conversion/reference.rb

@@ -0,0 +1,16 @@
+class V8::Conversion
+  module Reference
+
+    def self.construct!(object)
+      context = V8::Context.current
+      constructor = context.to_v8(object.class)
+      reference = constructor.NewInstance([V8::C::External::New(object)])
+      return reference
+    end
+
+    def to_v8
+      Reference.construct! self
+    end
+
+  end
+end

data/lib/v8/conversion/string.rb

@@ -0,0 +1,12 @@
+class V8::Conversion
+  module String
+    def to_v8
+      V8::C::String::New(self)
+    end
+  end
+  module NativeString
+    def to_ruby
+      self.Utf8Value()
+    end
+  end
+end

data/lib/v8/conversion/symbol.rb

@@ -0,0 +1,7 @@
+class V8::Conversion
+  module Symbol
+    def to_v8
+      V8::C::String::NewSymbol(to_s)
+    end
+  end
+end

data/lib/v8/conversion/time.rb

@@ -0,0 +1,13 @@
+class V8::Conversion
+  module Time
+    def to_v8
+      V8::C::Date::New(to_f * 1000)
+    end
+  end
+
+  module NativeDate
+    def to_ruby
+      ::Time.at(self.NumberValue() / 1000)
+    end
+  end
+end

data/lib/v8/error.rb

@@ -1,130 +1,25 @@
-
 module V8
-  class JSError < StandardError
-    attr_reader :value, :boundaries
-
-    def initialize(try, to)
-      @to = to
-      super(initialize_unsafe(try))
-    rescue Exception => e
-      @boundaries = [Boundary.new(:rbframes => e.backtrace)]
-      @value = e
-      super(<<-EOMSG)
-You have uncovered what is probably a BUG in therubyracer exception code. An error report would be very helpful.
-JSError#initialize failed!: #{e.message}"
-EOMSG
-    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
-      end
-      return message
+  class Error < StandardError
+    attr_reader :value
+    def initialize(message, value)
+      super(message)
+      @value = value
     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\/.*\.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)
-      #I can't figure out why V8 is not capturing the stacktrace here
-      #in terms of StackTrace and StackFrame objects, so we have to
-      #parse the string.
-      raw = @to.rb(try.StackTrace())
-      if raw && !raw.empty? && !syntax_error?(try)
-        raw.split("\n")[1..-1].tap do |frames|
-          frames.each {|frame| frame.strip!; frame.chomp!(",")}
-        end.reject(&:empty?)
-      else
-        msg = try.Message()
-        ["at #{@to.rb(msg.GetScriptResourceName())}:#{msg.GetLineNumber()}:#{msg.GetStartColumn() + 1}"]
-      end
-    end
-
-    #Syntax errors are weird in that they have a non-empty stack trace
-    #but it does not contain any source location information, so
-    #in these instances, we have to pull it out of the Message object
-    #in the TryCatch. Is there a better way to detect a syntax error
-    def syntax_error?(try)
-      ex = @to.rb(try.Exception())
-      if ex && ex.kind_of?(V8::Object)
-        type = ex["constructor"]
-        type && type.kind_of?(V8::Function) && type.name == "SyntaxError"
+  end
+  const_set :JSError, Error
+
+  def self.Error(exception)
+    value = exception.to_ruby
+    if !exception.kind_of?(V8::C::Value)
+      raise V8::Error.new(exception.to_s, value)
+    elsif exception.IsNativeError()
+      if football = exception.GetHiddenValue("rr::Football")
+        raise football.Value()
       else
-        false
-      end
-    end
-
-    class Boundary
-      attr_reader :rbframes, :jsframes
-
-      def initialize(frames = {})
-        @rbframes = frames[:rbframes] || []
-        @jsframes = frames[:jsframes] || []
+        raise V8::Error.new(exception.Get("message").to_ruby, value)
       end
+    else
+      raise V8::Error.new(exception.ToString().to_ruby, value)
     end
   end
-  #deprecated -- use JSError
-  JavasriptError = JSError
 end

data/lib/v8/error/protect.rb

@@ -0,0 +1,20 @@
+class V8::Error
+  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))
+      V8::C::ThrowException(error)
+    end
+  end
+end

data/lib/v8/error/try.rb

@@ -0,0 +1,15 @@
+class V8::Error
+  module Try
+    def try
+      context = V8::Context.current
+      V8::C::TryCatch() do |trycatch|
+        result = yield
+        if trycatch.HasCaught()
+          V8::Error(trycatch.Exception())
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/v8/function.rb

@@ -1,44 +1,28 @@
-module V8
-  class Function < V8::Object
+class V8::Function < V8::Object
+  include V8::Error::Try
 
-    def methodcall(thisObject, *args)
-      err = nil
-      return_value = nil
-      @portal.open do |to|
-        C::TryCatch.try do |try|
-          this = to.v8(thisObject)
-          return_value = to.rb(@native.Call(this, to.v8(args)))
-          err = JSError.new(try, to) if try.HasCaught()
-        end
-      end
-      raise err if err
-      return return_value
-    end
-
-    def call(*args)
-      @portal.open do
-        self.methodcall(@portal.context.native.Global(), *args)
-      end
+  def initialize(native = nil)
+    super do
+      native || V8::C::FunctionTemplate::New().GetFunction()
     end
+  end
 
-    def new(*args)
-      @portal.open do |to|
-        to.rb(@native.NewInstance(to.v8(args)))
-      end
+  def methodcall(this, *args)
+    @context.enter do
+      this ||= @context.native.Global()
+      @context.to_ruby try {native.Call(@context.to_v8(this), args.map {|a| @context.to_v8 a})}
     end
+  end
 
-    def name
-      @portal.open do |to|
-        to.rb(@native.GetName())
-      end
+  def call(*args)
+    @context.enter do
+      methodcall @context.native.Global(), *args
     end
+  end
 
-    def name=(name)
-      name.tap do
-        @portal.open do |to|
-          @native.SetName(to.v8(name))
-        end
-      end
+  def new(*args)
+    @context.enter do
+      @context.to_ruby try {native.NewInstance(args.map {|a| @context.to_v8 a})}
     end
   end
 end