therubyracer 0.11.0beta8-x86-freebsd-9

data/lib/v8/conversion/code.rb

@@ -0,0 +1,38 @@
+class V8::Conversion
+  module Code
+    include V8::Weak::Cell
+
+    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/fixnum.rb

@@ -0,0 +1,11 @@
+class V8::Conversion
+  module Fixnum
+    def to_ruby
+      self
+    end
+
+    def to_v8
+      self.to_f.to_v8
+    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 ||= V8::Weak::WeakValueMap.new
+    end
+
+    def rb_idmap
+      @ruby_idmap ||= V8::Weak::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 = V8::Weak::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

@@ -0,0 +1,166 @@
+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
+
+    # @!attribute [r] cause
+    # @return [Exception] the underlying error (if any) that triggered this error to be raised
+    attr_reader :cause
+
+    # @!attribute [r] javascript_backtrace
+    # @return [V8::StackTrace] 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
+        V8::C::TryCatch() do |trycatch|
+          result = yield
+          if trycatch.HasCaught()
+            raise V8::Error(trycatch)
+          else
+            result
+          end
+        end
+      end
+    end
+
+    module Protect
+      def protect
+        yield
+      rescue Exception => e
+        error = V8::C::Exception::Error(e.message)
+        error.SetHiddenValue("rr::Cause", V8::C::External::New(e))
+        V8::C::ThrowException(error)
+      end
+    end
+
+  end
+
+  # Convert the result of a triggered JavaScript try/catch block into
+  # a V8::Error
+  #
+  # This is a bit of a yak-shave because JavaScript let's you throw all
+  # kinds of things. We do our best to make sure that the message property
+  # of the resulting V8::Error is as helpful as possible, and that it
+  # contains as much source location information as we can put onto it.
+  #
+  # For example:
+  #
+  #    throw 4
+  #    throw 'four'
+  #    throw {number: 4}
+  #
+  # are all valid cases, none of which actually reference an exception object
+  # with a stack trace and a message. only with something like:
+  #
+  #    throw new Error('fail!')
+  #
+  # do you get the a proper stacktrace and a message property. However a lot of
+  # times JavaScript library authors are lazy and do this:
+  #
+  #     throw {message: 'foo', otherMetadata: 'bar'}
+  #
+  # It's common enough so we do the courtesy of having the resulting V8::Error
+  # have as its message in ruby land the 'message' property of the value object
+  #
+  # To further complicate things, SyntaxErrors do not have a JavaScript stack
+  # (even if they occur during js execution). This can make debugging a nightmare
+  # so we copy in the source location of the syntax error into the message of
+  # the resulting V8::Error
+  #
+  # @param [V8::C::TryCatch] native trycatch object that has been triggered
+  # @return [V8::Error] the error generated by this try/catch
+  def self.Error(trycatch)
+    exception = trycatch.Exception()
+    value = exception.to_ruby
+    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 cause = exception.GetHiddenValue("rr::Cause")
+        cause = cause.Value()
+      end
+      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
+        exception.Get("message").to_ruby
+      end
+    elsif exception.IsObject()
+      value['message'] || value.to_s
+    else
+      value.to_s
+    end
+    V8::Error.new(message, value, javascript_backtrace, cause)
+  end
+  const_set :JSError, Error
+end

data/lib/v8/function.rb

@@ -0,0 +1,28 @@
+class V8::Function < V8::Object
+  include V8::Error::Try
+
+  def initialize(native = nil)
+    super do
+      native || V8::C::FunctionTemplate::New().GetFunction()
+    end
+  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 call(*args)
+    @context.enter do
+      methodcall @context.native.Global(), *args
+    end
+  end
+
+  def new(*args)
+    @context.enter do
+      @context.to_ruby try {native.NewInstance(args.map {|a| @context.to_v8 a})}
+    end
+  end
+end

data/lib/v8/object.rb

@@ -0,0 +1,79 @@
+class V8::Object
+  include Enumerable
+  attr_reader :native
+  alias_method :to_v8, :native
+
+  def initialize(native = nil)
+    @context = V8::Context.current or fail "tried to initialize a #{self.class} without being in an entered V8::Context"
+    @native = block_given? ? yield : native || V8::C::Object::New()
+    @context.link self, @native
+  end
+
+  def [](key)
+    @context.enter do
+      @context.to_ruby @native.Get(@context.to_v8(key))
+    end
+  end
+
+  def []=(key, value)
+    @context.enter do
+      @native.Set(@context.to_v8(key), @context.to_v8(value))
+    end
+    return value
+  end
+
+  def keys
+    @context.enter do
+      names = @native.GetPropertyNames()
+      0.upto( names.Length() - 1).to_enum.map {|i| @context.to_ruby names.Get(i)}
+    end
+  end
+
+  def values
+    @context.enter do
+      names = @native.GetPropertyNames()
+      0.upto( names.Length() - 1).to_enum.map {|i| @context.to_ruby @native.Get(names.Get(i))}
+    end
+  end
+
+  def each
+    @context.enter do
+      names = @native.GetPropertyNames()
+      0.upto(names.Length() - 1) do |i|
+        name = names.Get(i)
+        yield @context.to_ruby(name), @context.to_ruby(@native.Get(name))
+      end
+    end
+  end
+
+  def to_s
+    @context.enter do
+      @context.to_ruby @native.ToString()
+    end
+  end
+
+  def respond_to?(method)
+    super or self[method] != nil
+  end
+
+  def method_missing(name, *args, &block)
+    if name.to_s =~ /(.*)=$/
+      if args.length > 1
+        self[$1] = args
+        return args
+      else
+        self[$1] = args.first
+        return args
+      end
+    end
+    return super(name, *args, &block) unless self.respond_to?(name)
+    property = self[name]
+    if property.kind_of?(V8::Function)
+      property.methodcall(self, *args)
+    elsif args.empty?
+      property
+    else
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 0)" unless args.empty?
+    end
+  end
+end