therubyracer 0.10.2 → 0.11.0beta1

data/lib/v8/portal.rb

@@ -1,86 +0,0 @@
-
-module V8
-  class Portal
-    attr_reader :context, :access, :proxies, :templates, :interceptors, :caller
-
-    def initialize(context, access)
-      @context, @access = context, access
-      @proxies = Proxies.new
-      @templates = Templates.new(self)
-      @interceptors = Interceptors.new(self)
-      @caller = Caller.new(self)
-    end
-
-    def lock
-      lock = V8::C::Locker.new
-      yield
-    ensure
-      lock.delete
-    end
-
-    def open
-      lock do
-        @context.native.enter do
-          yield(self)
-        end if block_given?
-      end
-    end
-
-    def rb(value)
-      @proxies.js2rb(value) do
-        case value
-          when V8::C::Function    then V8::Function.new(value, self)
-          when V8::C::Array       then V8::Array.new(value, self)
-          when V8::C::Object      then V8::Object.new(value, self)
-          when V8::C::String      then value.Utf8Value.tap {|s| return s.respond_to?(:force_encoding) ? s.force_encoding("UTF-8") : s}
-          when V8::C::Date        then Time.at(value.NumberValue() / 1000)
-          when V8::C::StackTrace  then V8::StackTrace.new(self, value)
-          when V8::C::Value       then nil if value.IsEmpty()
-        else
-          value
-        end
-      end
-    end
-
-    def v8(value)
-      case value
-      when V8::Object
-        value.instance_eval {@native}
-      when String
-        C::String::New(value)
-      when Symbol
-        C::String::NewSymbol(value.to_s)
-      when Proc,Method,UnboundMethod
-        @proxies.rb2js(value) do
-          @templates.to_function(value).function
-        end
-      when ::Array
-        C::Array::New(value.length).tap do |a|
-          value.each_with_index do |item, i|
-            a.Set(i, v8(item))
-          end
-        end
-      when ::Hash
-        C::Object::New().tap do |o|
-          value.each do |key, val|
-            o.Set(v8(key), v8(val))
-          end
-        end
-      when ::Time
-        C::Date::New(value.to_f * 1000)
-      when ::Class
-        @proxies.rb2js(value) do
-          constructor = @templates.to_constructor(value)
-          constructor.exposed = true
-          constructor.function
-        end
-      when nil,Numeric,TrueClass,FalseClass, C::Value
-        value
-      else
-        @proxies.rb2js(value) do
-          @templates.to_constructor(value.class).allocate(value)
-        end
-      end
-    end
-  end
-end

data/lib/v8/portal/caller.rb

@@ -1,37 +0,0 @@
-
-module V8
-  class Portal
-    class Caller
-
-      def initialize(portal)
-        @portal = portal
-      end
-
-      def raw
-        yield
-      rescue Exception => e
-        case e
-        when SystemExit, NoMemoryError
-          raise e
-        else
-          error = V8::C::Exception::Error(V8::C::String::New(e.message))
-          #TODO: This is almost certainly a crash here.
-          #we need to hold onto `error` while it bubbles up the javascript stack.
-          error.SetHiddenValue("TheRubyRacer::Cause", C::External::New(e))
-          V8::C::ThrowException(error)
-        end
-      end
-
-      def protect(*args, &block)
-        @portal.v8 raw(*args, &block)
-      end
-
-      def invoke(code, *args, &block)
-        protect do
-          args = args.slice(0, code.arity) if code.arity >= 0
-          code.call(*args, &block)
-        end
-      end
-    end
-  end
-end

data/lib/v8/portal/constructor.rb

@@ -1,98 +0,0 @@
-
-module V8
-  class Portal
-    class ConstructorAdapter
-      attr_reader :template, :exposed
-      alias_method :exposed?, :exposed
-
-      def initialize(templates, class_id)
-        @exposed = false
-        @class_id = class_id
-        @templates = templates
-        @invoke = method(:invoke)
-        @template = C::FunctionTemplate::New(@invoke)
-        portal.interceptors.setup(@template.InstanceTemplate())
-        cls = self.ruby_class
-        superclass = cls.superclass
-        if cls != ::Object && superclass != ::Object && superclass != ::Class
-          @template.Inherit(templates.to_constructor(superclass).template)
-        end
-        if cls.name && cls.name =~ /(::)?(\w+?)$/
-          template.SetClassName(C::String::NewSymbol("rb::" + $2))
-        else
-          template.SetClassName("Ruby")
-        end
-      end
-
-      def function
-        @template.GetFunction()
-      end
-
-      def allocate(object)
-        arguments = C::Array::New(1)
-        arguments.Set(0, C::External::New(object))
-        function.NewInstance(arguments)
-      end
-
-      def disable
-        @disabled = true
-      end
-
-      def enable
-        @disabled = nil
-      end
-
-      def invoke(arguments)
-        return if @disabled
-        if !@exposed
-          unless arguments.Length() == 1 && arguments[0].kind_of?(C::External)
-            C::ThrowException(C::Exception::Error(C::String::New("cannot call native constructor from javascript")))
-          else
-            object = arguments[0].Value()
-            proxies.register_javascript_proxy arguments.This(), :for => object
-          end
-        else
-          instance = nil
-          if arguments.Length() > 0 && arguments[0].kind_of?(C::External)
-            instance = arguments[0].Value()
-          else
-            rbargs = []
-            for i in 0..arguments.Length() - 1
-              rbargs << @templates.portal.rb(arguments[i])
-            end
-            instance = portal.caller.raw do
-              self.ruby_class.new(*rbargs)
-            end
-          end
-          proxies.register_javascript_proxy arguments.This(), :for => instance
-        end
-      end
-
-      def exposed=(exposed)
-        if exposed && !@augmented
-          #create a prototype so that this constructor also acts like a ruby object
-          prototype_template = C::ObjectTemplate::New()
-          portal.interceptors.setup(prototype_template)
-          prototype = prototype_template.NewInstance()
-          #set *that* object's prototype to an empty function so that it will look and behave like a function.
-          prototype.SetPrototype(C::FunctionTemplate::New().GetFunction())
-          template.GetFunction().SetPrototype(prototype)
-          @augmented = true
-        end
-        @exposed = exposed
-      end
-
-      def ruby_class
-        ObjectSpace._id2ref(@class_id)
-      end
-
-      def proxies
-        @templates.proxies
-      end
-
-      def portal
-        @templates.portal
-      end
-    end
-  end
-end

data/lib/v8/portal/function.rb

@@ -1,63 +0,0 @@
-module V8
-  class Portal
-    class FunctionAdapter
-
-      attr_reader :template
-
-      def initialize(portal, code)
-        @portal = portal
-        @caller = case code
-        when Method then BoundCall.new(portal)
-        when UnboundMethod then BindAndCall.new(portal)
-        else Call.new(portal)
-        end
-        @code = code
-        @template = V8::C::FunctionTemplate::New(@caller, @code)
-      end
-
-      def function
-        @template.GetFunction()
-      end
-
-      class Call
-        def initialize(portal)
-          @portal = portal
-        end
-
-        def call(arguments)
-          proc = arguments.Data()
-          rbargs = [@portal.rb(arguments.This())]
-          for i in 0..arguments.Length() - 1
-            rbargs << @portal.rb(arguments[i])
-          end
-          @portal.caller.invoke(proc, *rbargs)
-        end
-      end
-
-      class BoundCall < Call
-        def call(arguments)
-          proc = arguments.Data()
-          rbargs = []
-          for i in 0..arguments.Length() - 1
-            rbargs << @portal.rb(arguments[i])
-          end
-          @portal.caller.invoke(proc, *rbargs)
-        end
-      end
-
-      class BindAndCall < Call
-        def call(arguments)
-          method = arguments.Data()
-          rbargs = []
-          for i in 0..arguments.Length() - 1
-            rbargs << @portal.rb(arguments[i])
-          end
-          this = @portal.rb(arguments.This())
-          @portal.caller.protect do
-            method.bind(this).call(*rbargs)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/v8/portal/interceptors.rb

@@ -1,152 +0,0 @@
-module V8
-  class Portal
-    class Interceptors
-      def initialize(portal)
-        @getter = NamedPropertyGetter.new(portal)
-        @setter = NamedPropertySetter.new(portal)
-        @query = nil
-        @deleter = nil
-        @enumerator = NamedPropertyEnumerator.new(portal)
-        @igetter = IndexedPropertyGetter.new(portal)
-        @isetter = IndexedPropertySetter.new(portal)
-        @iquery = nil
-        @ideleter = nil
-        @ienumerator = IndexedPropertyEnumerator.new(portal)
-      end
-
-      def setup(template)
-        template.SetNamedPropertyHandler(@getter,@setter,@query,@deleter,@enumerator, nil)
-        template.SetIndexedPropertyHandler(@igetter,@isetter,@iquery,@ideleter,@ienumerator, nil)
-      end
-
-      class PropertyAttributes
-        attr_reader :flags
-        def initialize
-          @flags = 0
-        end
-
-        def read_only
-          tap do
-            @flags |= V8::C::ReadOnly
-          end
-        end
-
-        def dont_enum
-          tap do
-            @flags |= V8::C::DontEnum
-          end
-        end
-
-        def dont_delete
-          tap do
-            @flags |= V8::C::DontDelete
-          end
-        end
-      end
-
-      class Interceptor
-
-        def initialize(portal)
-          @to, @access = portal, portal.access
-        end
-
-        def intercept(info, retval = nil, &code)
-          obj = @to.rb(info.This())
-          intercepts = true
-          result = @to.caller.protect do
-            dontintercept = proc do
-              intercepts = false
-            end
-            code.call(obj, dontintercept)
-          end
-          intercepts ? (retval || result) : C::Empty
-        end
-      end
-
-      class NamedPropertyGetter < Interceptor
-        def call(property, info)
-          intercept(info) do |obj, dontintercept|
-            @access.get(obj, @to.rb(property), &dontintercept)
-          end
-        end
-      end
-
-      class NamedPropertySetter < Interceptor
-        def call(property, value, info)
-          intercept(info, value) do |obj, dontintercept|
-            @access.set(obj, @to.rb(property), @to.rb(value), &dontintercept)
-          end
-        end
-      end
-
-      class NamedPropertyQuery
-        def call(property, info)
-          attributes = PropertyAttributes.new
-          result = intercept(info) do |obj, dontintercept|
-            @access.query(obj, @to.rb(property), attributes, &dontintercept)
-          end
-          return result == C::Empty ? result : C::Integer::New(attributes.flags)
-        end
-      end
-
-      class NamedPropertyEnumerator < Interceptor
-        def call(info)
-          intercept(info) do |obj, dontintercept|
-            @access.names(obj, &dontintercept).to_a
-          end
-        end
-      end
-
-      class NamedPropertyDeleter < Interceptor
-        def call(property, info)
-          intercept(info) do |obj, dontintercept|
-            @access.delete(obj, property, &dontintercept)
-          end
-        end
-      end
-
-      class IndexedPropertyGetter < Interceptor
-        def call(index, info)
-          intercept(info) do |obj, dontintercept|
-            @access.iget(obj, index, &dontintercept)
-          end
-        end
-      end
-
-      class IndexedPropertySetter < Interceptor
-        def call(index, value, info)
-          intercept(info, value) do |obj, dontintercept|
-            @access.iset(obj, index, @to.rb(value), &dontintercept)
-          end
-        end
-      end
-
-      class IndexedPropertyQuery < Interceptor
-        def call(property, info)
-          attributes = PropertyAttributes.new
-          result = intercept(info) do |obj, dontintercept|
-            @access.indices(obj, &dontintercept)
-          end
-          result == C::Empty ? C::Empty : C::Integer::New(attributes.flags)
-        end
-      end
-
-      class IndexedPropertyDeleter < Interceptor
-        def call(index, info)
-          intercept(info) do |obj, dontintercept|
-            @access.idelete(obj, index, &dontintercept)
-          end
-        end
-      end
-
-      class IndexedPropertyEnumerator < Interceptor
-        def call(info)
-          intercept(info) do |obj, dontintercept|
-            @access.indices(obj, &dontintercept)
-          end
-        end
-      end
-    end
-  end
-end
-

data/lib/v8/portal/proxies.rb

@@ -1,151 +0,0 @@
-module V8
-  class Portal
-    class Proxies
-
-      def initialize
-        @js_proxies_rb2js = {}
-        @js_proxies_js2rb = {}
-        @rb_proxies_rb2js = {}
-        @rb_proxies_js2rb = {}
-        @clear_js_proxy = ClearJSProxy.new(@js_proxies_rb2js, @js_proxies_js2rb)
-        @clear_rb_proxy = ClearRubyProxy.new(@rb_proxies_rb2js, @rb_proxies_js2rb)
-      end
-
-      def js2rb(js)
-        if rb = js_proxy_2_rb_object(js)
-          return rb
-        elsif rb = js_object_2_rb_proxy(js)
-          return rb
-        else
-          proxy = block_given? ? yield(js) : Object.new
-          register_ruby_proxy proxy, :for => js if proxy && js && js.kind_of?(V8::C::Handle)
-          return proxy
-        end
-      end
-
-      def rb2js(rb)
-        if js = rb_proxy_2_js_object(rb)
-          return js
-        elsif js = rb_object_2_js_proxy(rb)
-          return js
-        else
-          proxy = block_given? ? yield(rb) : V8::C::Object::New()
-          register_javascript_proxy proxy, :for => rb unless @js_proxies_rb2js[rb]
-          return proxy
-        end
-      end
-
-      def register_javascript_proxy(proxy, options = {})
-        target = options[:for] or fail ArgumentError, "must specify the object that you're proxying with the :for => param"
-        fail ArgumentError, "javascript proxy must be a V8::C::Handle, not #{proxy.class}" unless proxy.kind_of?(V8::C::Handle)
-        fail DoubleProxyError, "target already has a registered proxy" if @js_proxies_rb2js[target]
-
-        @js_proxies_js2rb[proxy] = target
-        @js_proxies_rb2js[target] = proxy
-        proxy.MakeWeak(nil, @clear_js_proxy)
-      end
-
-      # Lookup the JavaScript proxy for a natively Ruby object
-      # @param [Object] object the Ruby object
-      # @return [V8::C::Handle] the JavaScript proxy representing `object`
-      def rb_object_2_js_proxy(object)
-        @js_proxies_rb2js[object]
-      end
-
-      # Look up a natively Ruby object given its JavaScript proxy
-      # @param [V8::C::Handle] proxy the JavaScript proxy
-      # @return [Object] the Ruby object represented by `proxy`
-      def js_proxy_2_rb_object(proxy)
-        @js_proxies_js2rb[proxy]
-      end
-
-      def register_ruby_proxy(proxy, options = {})
-        target = options[:for] or fail ArgumentError, "must specify the object that you're proxying with the :for => param"
-        fail ArgumentError, "'#{proxy.inspect}' is not a Handle to an actual V8 object" unless target.kind_of?(V8::C::Handle)
-        @rb_proxies_rb2js[proxy.object_id] = target
-        @rb_proxies_js2rb[target] = proxy.object_id
-        ObjectSpace.define_finalizer(proxy, @clear_rb_proxy)
-      end
-
-      # Looks up the Ruby proxy for an object that is natively JavaScript
-      # @param [V8::C::Handle] object the JavaScript whose proxy we want
-      # @return [Object] the Ruby proxy for `object`
-      def js_object_2_rb_proxy(object)
-        if id = @rb_proxies_js2rb[object]
-          ObjectSpace._id2ref id
-        end
-      rescue RangeError
-        # sometimes, the Ruby proxy has been garbage collected, but
-        # the finalizer which runs has not been called. That's OK
-        # we just clear out the entry, and return nil so that a new
-        # proxy can be created.
-        @clear_rb_proxy.call(id)
-        return nil
-      end
-
-      # Looks up a native JavaScript object by its Ruby proxy
-      # @param [Object] proxy the Ruby proxy
-      # @return [V8::C::Handle] the native JavaScript object
-      def rb_proxy_2_js_object(proxy)
-        @rb_proxies_rb2js[proxy.object_id]
-      end
-
-      def js_empty?
-        @js_proxies_rb2js.empty? && @js_proxies_js2rb.empty?
-      end
-
-      def rb_empty?
-        @rb_proxies_rb2js.empty? && @rb_proxies_js2rb.empty?
-      end
-
-      def empty?
-        js_empty? && rb_empty?
-      end
-      DoubleProxyError = Class.new(StandardError)
-
-      class ClearJSProxy
-
-        def initialize(rb2js, js2rb)
-          @rb2js, @js2rb = rb2js, js2rb
-        end
-
-        def call(proxy, parameter)
-          rb = @js2rb[proxy]
-          @js2rb.delete(proxy)
-          @rb2js.delete(rb)
-        end
-      end
-
-      # @Private
-      # Remove the linkage between a Ruby proxy and a native
-      # JavaScript object. In general, this object is registered
-      # as a finalizer on the Ruby proxy itself, so that when it is
-      # garbage collected, it releases the back reference to the
-      # native JavaScript object.
-      #
-      # It is important to do this as soon as is reasonably possible
-      # so that the native JavaScript object can itself be garbage 
-      # collected (provided there are no other references to it)
-      class ClearRubyProxy
-        def initialize(rb2js, js2rb)
-          @rb2js, @js2rb = rb2js, js2rb
-        end
-
-        # takes the object id of a Ruby proxy that has been garbage collected
-        # and releases the reference to the native JavaScript object that
-        # it was bound to.
-        # @param[Fixnum] proxy_id the proxy id of the garbage collected Ruby proxy
-        def call(proxy_id)
-          # TODO: this if-check should be synchronized, so that if called manually
-          # it will not conflict with the finalization thread. It's not so heinous
-          # if the refererence gets cleared twice, but we definiteily dont't want
-          # to double-decrement the v8 GC hint.
-          if js = @rb2js[proxy_id]
-            @rb2js.delete(proxy_id)
-            @js2rb.delete(js)
-          end
-        end
-      end
-    end
-  end
-end