therubyracer 0.7.5 → 0.8.0.pre

data/lib/v8/array.rb

@@ -3,9 +3,9 @@ module V8
   class Array < V8::Object
     
     def each
-      @context.enter do
+      @portal.open do |to|
         for i in 0..(@native.Length() - 1)
-          yield To.rb(@native.Get(i))
+          yield to.rb(@native.Get(i))
         end
       end
     end

data/lib/v8/context.rb

@@ -2,12 +2,14 @@ require 'stringio'
 
 module V8
   class Context    
-    attr_reader :native, :scope
+    attr_reader :native, :scope, :access
     def initialize(opts = {})
-      @native = opts[:with] ? C::Context::New(Access.rubyobject) : C::Context::New()
+      @access = Access.new
+      @to = Portal.new(self, @access)
+      @native = opts[:with] ? C::Context::New(@to.rubytemplate) : C::Context::New()
       @native.enter do
+        @scope = @to.rb(@native.Global())
         @native.Global().SetHiddenValue(C::String::New("TheRubyRacer::RubyObject"), C::External::New(opts[:with])) if opts[:with]
-        @scope = To.rb(@native.Global())
       end
       yield(self) if block_given?
     end
@@ -20,15 +22,15 @@ module V8
       value = nil
       C::TryCatch.try do |try|
         @native.enter do
-          script = C::Script::Compile(To.v8(javascript.to_s), To.v8(filename.to_s))
+          script = C::Script::Compile(@to.v8(javascript.to_s), @to.v8(filename.to_s))
           if try.HasCaught()
-            err = JSError.new(try)
+            err = JSError.new(try, @to)
           else
             result = script.Run()
             if try.HasCaught()
-              err = JSError.new(try)
+              err = JSError.new(try, @to)
             else
-              value = To.rb(result)
+              value = @to.rb(result)
             end
           end
         end

data/lib/v8/error.rb

@@ -3,7 +3,8 @@ module V8
   class JSError < StandardError
     attr_reader :value, :boundaries
 
-    def initialize(try)
+    def initialize(try, to)
+      @to = to
       begin
         super(initialize_unsafe(try))
       rescue Exception => e
@@ -15,7 +16,7 @@ module V8
 
     def initialize_unsafe(try)
       message = nil
-      ex = To.rb(try.Exception())
+      ex = @to.rb(try.Exception())
       @boundaries = [Boundary.new(:rbframes => caller(3), :jsframes => parse_js_frames(try))]
       if V8::Object === ex
         if msg = ex['message']
@@ -79,7 +80,7 @@ module V8
         end if trace_javascript
         rbcontext = b.rbframes
         jscontext = b.jsframes
-        rbframes.reject! {|f| f =~ /lib\/v8\/\w+\.rb/} unless trace_framework
+        rbframes.reject! {|f| f =~ /lib\/v8\/.*\.rb/} unless trace_framework
         mixed.unshift(*rbframes) if trace_ruby
         mixed.unshift(*jsframes) if trace_javascript
       end
@@ -87,7 +88,7 @@ module V8
     end
 
     def parse_js_frames(try)
-      raw = To.rb(try.StackTrace())
+      raw = @to.rb(try.StackTrace())
       if raw && !raw.empty?
         raw.split("\n")[1..-1].tap do |frames|
           frames.each {|frame| frame.strip!.chomp!(",")}

data/lib/v8/function.rb

@@ -5,10 +5,10 @@ module V8
       err = nil
       return_value = nil
       C::TryCatch.try do |try|
-        @context.enter do
-          this = To.v8(thisObject)
-          return_value = To.rb(@native.Call(this, To.v8(args)))
-          err = JSError.new(try) if try.HasCaught()
+        @portal.open do |to|
+          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
@@ -16,39 +16,12 @@ module V8
     end
     
     def call(*args)
-      self.methodcall(@context.Global(), *args)
+      self.methodcall(@portal.context.native.Global(), *args)
     end
     
     def new(*args)
-      @context.enter do
-        To.rb(@native.NewInstance(To.v8(args)))
-      end
-    end
-
-    def self.rubyprotect
-      begin
-        To.v8(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 self.rubycall(rubycode, *args)
-      rubyprotect do
-        rubycode.call(*args)
-      end
-    end
-
-    def self.rubysend(obj, message, *args)
-      rubyprotect do
-        obj.send(message, *args)
+      @portal.open do |to|
+        to.rb(@native.NewInstance(to.v8(args)))
       end
     end
   end

data/lib/v8/object.rb

@@ -3,35 +3,33 @@ module V8
   class Object
     include Enumerable
 
-    def initialize(native, context = nil)
-      @native = native
-      @context = context || C::Context::GetEntered()
-      raise ScriptError, "V8::Object.new called without an open V8 context" unless @context
+    def initialize(native, portal)
+      @native, @portal = native, portal
     end
 
     def [](key)
-      @context.enter do
-        To.rb(@native.Get(To.v8(key)))
+      @portal.open do |to|
+        to.rb(@native.Get(to.v8(key)))
       end
     end
 
     def []=(key, value)
       value.tap do
-        @context.enter do
-          @native.Set(To.v8(key), To.v8(value))
+        @portal.open do |to|
+          @native.Set(to.v8(key), to.v8(value))
         end
       end
     end
 
     def to_s
-      @context.enter do
-        To.rb(@native.ToString())
+      @portal.open do |to|
+        to.rb(@native.ToString())
       end
     end
 
     def each
-      @context.enter do
-        for prop in To.rb(@native.GetPropertyNames())
+      @portal.open do |to|
+        for prop in to.rb(@native.GetPropertyNames())
           yield prop, self[prop]
         end
       end

data/lib/v8/portal.rb

@@ -0,0 +1,325 @@
+
+module V8
+  class Portal
+    attr_reader :context
+
+    def initialize(context, access)
+      @context, @access = context, access
+      @named_property_getter = Interceptor(NamedPropertyGetter)
+      @named_property_setter = Interceptor(NamedPropertySetter)
+      @named_property_query = nil
+      @named_property_deleter = nil
+      @named_property_enumerator = Interceptor(NamedPropertyEnumerator)
+
+      @indexed_property_getter = Interceptor(IndexedPropertyGetter)
+      @indexed_property_setter = Interceptor(IndexedPropertySetter)
+      @indexed_property_query = nil
+      @indexed_property_deleter = nil
+      @indexed_property_enumerator = Interceptor(IndexedPropertyEnumerator)
+
+      @constructors = Hash.new do |h, cls|
+        h[cls] = template = C::FunctionTemplate::New() do |arguments|
+          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
+            arguments.This().tap do |this|
+              this.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), arguments[0])              
+            end
+          end
+        end
+        template.tap do
+          setuptemplate(template.InstanceTemplate())
+          if cls != ::Object && cls.superclass != ::Object && cls.superclass != ::Class
+            template.Inherit(@constructors[cls.superclass])
+          end
+          if cls.name && cls.name =~ /(::)?(\w+?)$/
+            template.SetClassName(C::String::NewSymbol("rb::" + $2))
+          else
+            template.SetClassName("Ruby")
+          end
+        end
+      end
+
+      @instances = Hash.new do |h, obj|
+        args = C::Array::New(1)
+        args.Set(0, C::External::New(obj))
+        h[obj] = @constructors[obj.class].GetFunction().NewInstance(args)
+      end
+
+      @functions = Functions.new(self)
+
+      @embedded_constructors = Hash.new do |h, cls|
+        template = @constructors[cls]
+        template.SetCallHandler() do |arguments|
+          wrap = nil
+          if arguments.Length() > 0 && arguments[0].kind_of?(C::External)
+            wrap = arguments[0]
+          else
+            rbargs = []
+            for i in 0..arguments.Length() - 1
+              rbargs << rb(arguments[i])
+            end
+            instance = rubysend(cls, :new, *rbargs)
+            wrap = C::External::New(instance)
+          end
+          arguments.This().tap do |this|
+            this.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), wrap)
+          end
+        end
+        h[cls] = template
+      end
+    end
+
+    def open
+      @context.native.enter do
+        yield(self)
+      end if block_given?
+    end
+
+    def rb(value)
+      case value
+      when V8::C::Function  then peer(value) {V8::Function}
+      when V8::C::Array     then peer(value) {V8::Array}
+      when V8::C::Object    then peer(value) {V8::Object}
+      when V8::C::String    then value.Utf8Value()
+      when V8::C::Date      then Time.at(value.NumberValue())
+      when V8::C::Value     then nil if value.IsEmpty()
+      else
+        value
+      end
+    end
+
+    def v8(value)
+      case value
+      when V8::Object
+        value.instance_eval {@native}
+      when String
+        C::String::New(value.to_s)
+      when Symbol
+        C::String::NewSymbol(value.to_s)
+      when Proc,Method,UnboundMethod
+        @functions[value]
+      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, value|
+            o.Set(v8(key), v8(value))
+          end
+        end
+      when ::Time
+        C::Date::New(value)
+      when ::Class
+        @embedded_constructors[value].GetFunction().tap do |f|
+          f.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"), C::External::New(value))
+          #set the function's prototype object to the object that will have the named property handlers
+          prototype = rubytemplate.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())
+          f.SetPrototype(prototype)
+        end
+      when nil,Numeric,TrueClass,FalseClass, C::Value
+        value
+      else
+        @instances[value]
+      end
+    end
+
+    def rubyprotect
+      begin
+        v8 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 rubycall(rubycode, *args, &block)
+      rubyprotect do
+        rubycode.call(*args, &block)
+      end
+    end
+
+    def rubysend(obj, message, *args, &block)
+      rubyprotect do
+        obj.send(message, *args, &block)
+      end
+    end
+    
+    def rubytemplate
+      C::ObjectTemplate::New().tap do |t|
+        setuptemplate(t)
+      end
+    end
+    
+    def setuptemplate(t)
+      t.SetNamedPropertyHandler(
+        @named_property_getter,
+        @named_property_setter,
+        nil,
+        nil,
+        @named_property_enumerator
+      )
+      t.SetIndexedPropertyHandler(
+        @indexed_property_getter,
+        @indexed_property_setter,
+        nil,
+        nil,
+        @indexed_property_enumerator
+      )
+    end
+
+    private
+
+    def peer(value)
+      external = value.GetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyObject"))
+      if external && !external.IsEmpty()
+        external.Value()
+      else
+        yield.new(value, self)
+      end
+    end
+
+    class Interceptor
+      def initialize(portal, access)
+        @to, @access = portal, access
+      end
+
+      def intercept(info, retval = nil, &code)
+        obj = @to.rb(info.This())
+        intercepts = true
+        result = @to.rubyprotect do
+          dontintercept = proc do
+            intercepts = false
+          end
+          code.call(obj, dontintercept)
+        end
+        intercepts ? (retval || result) : C::Empty
+      end
+
+    end
+
+    def Interceptor(cls)
+      cls.new self, @access
+    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 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