therubyracer 0.5.0-x86-linux → 0.11.0beta5-x86-linux

data/lib/v8/conversion/class.rb

@@ -0,0 +1,120 @@
+class V8::Conversion
+  module Class
+    include V8::Conversion::Code
+
+    def to_template
+      weakcell(:constructor) do
+        template = V8::C::FunctionTemplate::New(Constructor.new(self))
+        prototype = template.InstanceTemplate()
+        prototype.SetNamedPropertyHandler(Get, Set)
+        prototype.SetIndexedPropertyHandler(IGet, ISet)
+        if self != ::Object && superclass != ::Object && superclass != ::Class
+          template.Inherit(superclass.to_template)
+        end
+        template
+      end
+    end
+
+    class Constructor
+      include V8::Error::Protect
+
+      def initialize(cls)
+        @class = cls
+      end
+
+      def call(arguments)
+        arguments.extend Args
+        protect do
+          if arguments.linkage_call?
+            arguments.link
+          else
+            arguments.construct @class
+          end
+        end
+        return arguments.This()
+      end
+
+      module Args
+        def linkage_call?
+          self.Length() == 1 && self[0].IsExternal()
+        end
+
+        def link
+          external = self[0]
+          This().SetHiddenValue("rr::implementation", external)
+          context.link external.Value(), This()
+        end
+
+        def construct(cls)
+          context.link cls.new(*to_args), This()
+        end
+
+        def context
+          V8::Context.current
+        end
+
+        def to_args
+          args = ::Array.new(Length())
+          0.upto(args.length - 1) do |i|
+            args[i] = self[i]
+          end
+          return args
+        end
+      end
+    end
+
+    module Accessor
+      include V8::Error::Protect
+      def intercept(info, key, &block)
+        context = V8::Context.current
+        access = context.access
+        object = context.to_ruby(info.This())
+        handles_property = true
+        dontintercept = proc do
+          handles_property = false
+        end
+        protect do
+          result = block.call(context, access, object, context.to_ruby(key), dontintercept)
+          handles_property ? context.to_v8(result) : V8::C::Value::Empty
+        end
+      end
+    end
+
+    class Get
+      extend Accessor
+      def self.call(property, info)
+        intercept(info, property) do |context, access, object, key, dontintercept|
+          access.get(object, key, &dontintercept)
+        end
+      end
+    end
+
+    class Set
+      extend Accessor
+      def self.call(property, value, info)
+        intercept(info, property) do |context, access, object, key, dontintercept|
+          access.set(object, key, context.to_ruby(value), &dontintercept)
+        end
+      end
+    end
+
+    class IGet
+      extend Accessor
+      def self.call(property, info)
+        intercept(info, property) do |context, access, object, key, dontintercept|
+          access.iget(object, key, &dontintercept)
+        end
+      end
+    end
+
+    class ISet
+      extend Accessor
+      def self.call(property, value, info)
+        intercept(info, property) do |context, access, object, key, dontintercept|
+          access.iset(object, key, context.to_ruby(value), &dontintercept)
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,25 @@
+module V8
+  class Error < StandardError
+    attr_reader :value
+    def initialize(message, value)
+      super(message)
+      @value = value
+    end
+  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
+        raise V8::Error.new(exception.Get("message").to_ruby, value)
+      end
+    else
+      raise V8::Error.new(exception.ToString().to_ruby, value)
+    end
+  end
+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

@@ -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