therubyracer 0.8.2 → 0.9.0beta1

data/lib/v8/portal/caller.rb

@@ -0,0 +1,36 @@
+
+module V8
+  class Portal
+    class Caller
+      
+      def initialize(portal)
+        @portal = portal
+      end
+      
+      def raw
+        begin
+          yield
+        rescue Exception => e
+          case e
+          when SystemExit, NoMemoryError
+            raise e
+          else
+            error = V8::C::Exception::Error(V8::C::String::New(e.message))
+            error.SetHiddenValue("TheRubyRacer::Cause", C::External::New(e))
+            V8::C::ThrowException(error)
+          end
+        end
+      end
+
+      def protect(*args, &block)
+        @portal.v8 raw(*args, &block)
+      end
+
+      def invoke(code, *args, &block)
+        protect do
+          code.call(*args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/v8/portal/constructor.rb

@@ -0,0 +1,98 @@
+
+module V8
+  class Portal
+    class ConstructorAdapter
+      attr_reader :template, :function, :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

@@ -0,0 +1,48 @@
+module V8
+  class Portal
+    class FunctionAdapter
+
+      attr_reader :template, :function
+
+      def initialize(portal, code)
+        @portal = portal
+        @caller = code.respond_to?(:call) ? Call.new(portal) : BindAndCall.new(portal)
+        @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 = []
+          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

@@ -0,0 +1,153 @@
+module V8
+  class Portal
+    class Interceptors
+      def initialize(portal)
+        @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

@@ -0,0 +1,102 @@
+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
+
+      def rb_object_2_js_proxy(object)
+        @js_proxies_rb2js[object]
+      end
+
+      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
+
+      def js_object_2_rb_proxy(object)
+        if id = @rb_proxies_js2rb[object]
+          ObjectSpace._id2ref id
+        end
+      end
+
+      def rb_proxy_2_js_object(proxy)
+        @rb_proxies_rb2js[proxy.object_id]
+      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
+
+      class ClearRubyProxy
+        def initialize(rb2js, js2rb)
+          @rb2js, @js2rb = rb2js, js2rb
+        end
+
+        def call(proxy_id)
+          js = @rb2js[proxy_id]
+          @rb2js.delete(proxy_id)
+          @js2rb.delete(js)
+        end
+      end
+    end
+  end
+end

data/lib/v8/portal/templates.rb

@@ -0,0 +1,73 @@
+
+module V8
+  class Portal
+    class Templates
+
+      attr_reader :portal
+
+      def initialize(portal)
+        @portal = portal
+        @constructors = {}
+        @methods = {}
+        @procs = {}
+        @releases = {}
+      end
+
+      def to_constructor(ruby_class)
+        class_id = ruby_class.object_id
+        if constructor = @constructors[class_id]
+          return constructor
+        else
+          constructor = @constructors[class_id] = ConstructorAdapter.new(self, class_id)
+          ObjectSpace.define_finalizer(ruby_class, release(@constructors, class_id))
+          return constructor
+        end
+      end
+
+      def to_function(code)
+        case code
+        when Method, UnboundMethod
+          if fn = @methods[code.to_s]
+            return fn
+          else
+            function = @methods[code.to_s] = FunctionAdapter.new(@portal, code)
+            #TODO: test this weak behavior
+            function.template.MakeWeak(0, release(@methods, code.to_s))
+            return function
+          end
+        else
+          if fn = @procs[code]
+            return fn
+          else
+            function = @procs[code] = FunctionAdapter.new(@portal, code)
+            #TODO: test this weak behavior
+            function.template.MakeWeak(0, release(@procs, code))
+            return function
+          end
+        end
+      end
+
+      def proxies
+        @portal.proxies
+      end
+
+      def release(refs, id)
+        release = Release.new(@releases, refs, id)
+        @releases[release] = true
+        return release
+      end
+
+      class Release
+        def initialize(releases, refs, id)
+          @releases, @refs, @id = releases, refs, id
+        end
+
+        def call(*args)
+          @refs.delete(@id)
+          @releases.delete(self)
+        end
+
+      end
+    end
+  end
+end