therubyracer-freebsd 0.10.1

data/lib/v8/portal/proxies.rb

@@ -0,0 +1,151 @@
+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

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

data/lib/v8/stack.rb

@@ -0,0 +1,66 @@
+
+module V8
+
+  class StackTrace
+    include Enumerable
+
+    def initialize(to, native)
+      @to = to
+      @native = native
+    end
+
+    def length
+      @native.GetFrameCount()
+    end
+
+    def each
+      for i in 0..length - 1
+        yield V8::StackFrame.new(@to, @native.GetFrame(i))
+      end
+    end
+
+    def to_s
+      map {|f|"at #{f}"}.join("\n")
+    end
+  end
+
+  class StackFrame
+
+    def initialize(portal, native)
+      @to = portal
+      @native = native
+    end
+
+    def script_name
+      @to.rb(@native.GetScriptName())
+    end
+
+    def function_name
+      @to.rb(@native.GetFunctionName())
+    end
+
+    def line_number
+      @native.GetLineNumber()
+    end
+
+    def column
+      @native.GetColumn()
+    end
+
+    def eval?
+      @native.IsEval()
+    end
+
+    def constructor?
+      @native.IsConstructor()
+    end
+
+    def to_s
+      if @native.GetFunctionName()
+        "#{function_name} (#{script_name}:#{line_number}:#{column})"
+      else
+        "#{script_name}:#{line_number}:#{column}"
+      end
+    end
+  end
+end

data/lib/v8/tap.rb

@@ -0,0 +1,9 @@
+
+unless Object.method_defined?(:tap)
+  class Object
+    def tap
+      yield self
+      return self
+    end
+  end
+end

data/lib/v8/version.rb

@@ -0,0 +1,3 @@
+module V8
+  VERSION = "0.10.1"
+end

data/spec/ext/array_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe V8::C::Array do
+  include V8::ExtSpec
+  
+  it "can be instantiated" do
+    a = c::Array::New()
+    a.Length().should eql(0)
+  end
+  
+  it "maintains referential integrity" do
+    v8_eval('a = []')
+    v8_eval('a').should be(v8_eval('a'))
+  end
+end

data/spec/ext/cxt_spec.rb

@@ -0,0 +1,57 @@
+
+require "#{File.dirname(__FILE__)}/../spec_helper.rb"
+
+include V8
+
+describe C::Context do
+
+  before {@lock = C::Locker.new}
+  after {@lock.delete}
+
+  it "should not have a current context if no context is open" do
+    C::Context::GetEntered().should be_nil
+  end
+
+  it "can javascript properties on the global scope via ruby when the default scope is a ruby object" do
+    V8::Context.new(:with => Object.new) do |cxt|
+      cxt['foo'] = 'bar'
+      cxt.eval('foo').should eql('bar')
+    end
+  end
+
+  it "can get the current javascript execution stack" do
+    V8::Context.new do |cxt|
+      trace = nil
+      cxt['getTrace'] = lambda do
+        trace = V8::Context.stack
+      end
+      cxt.eval(<<-JS, 'trace.js')
+      function one() {
+        return two();
+      }
+
+      function two() {
+        return three();
+      }
+
+      function three() {
+        return getTrace()
+      }
+      one();
+JS
+      trace.length.should be(4)
+      trace.to_a[0].tap do |frame|
+        frame.line_number.should == 10
+        frame.column.should == 16
+        frame.script_name.should == 'trace.js'
+        frame.function_name.should == 'three'
+        frame.should_not be_eval
+        frame.should_not be_constructor
+      end
+    end
+  end
+
+  it "has an empty stack if there is no enterned context" do
+    V8::Context.stack.should be_empty
+  end
+end

data/spec/ext/ext_spec_helper.rb

@@ -0,0 +1,27 @@
+
+module V8::ExtSpec
+
+  def self.included(object)
+    object.class_eval do
+      before do
+        @lock = c::Locker.new
+        @cxt = c::Context::New()
+        @cxt.Enter()
+      end
+      after do
+        @cxt.Exit()
+        @cxt.Dispose()
+        @lock.delete
+      end
+    end
+  end
+
+  def v8_eval(script, sourcename = "<eval>")
+    c::Script::New(c::String::New(script), c::String::New(sourcename)).Run()
+  end
+
+  def c
+    V8::C
+  end
+
+end

data/spec/ext/func_spec.rb

@@ -0,0 +1,64 @@
+require "#{File.dirname(__FILE__)}/../spec_helper.rb"
+
+include V8
+
+describe C::Function do
+  it "is callable" do
+    Context.new do |cxt|
+      f = cxt.eval('(function() {return "Hello World"})', '<eval>');
+      f.call().should == "Hello World"
+    end
+  end
+
+  it "receives proper argument length from ruby" do
+    Context.new do |cxt|
+      f = cxt.eval('(function() {return arguments.length})', 'eval')
+      f.call(1, 2, 3).should == 3
+    end
+  end
+
+  it "maps all arguments from ruby" do
+    Context.new do |cxt|
+      f = cxt.eval('(function(one, two, three) {return one + two + three})', 'eval')
+      f.call(1,2,3).should == 6
+    end
+  end
+
+  it "properly maps ruby objects back and forth from arguments to return value" do
+    Context.new do |cxt|
+      Object.new.tap do |this|
+         f = cxt.eval('(function() {return this})', 'eval')
+         f.methodcall(this).should be(this)
+      end
+    end
+  end
+
+  it "can be called outside of a context" do
+    Context.new do |cxt|
+      @f = cxt.eval('(function() {return "Call Me"})', 'eval')
+    end
+    @f.call().should == "Call Me"
+  end
+
+  it "is reflected properly" do
+    Context.new do |cxt|
+      cxt['say'] = lambda {|this, word, times| word * times}
+      cxt.eval('say("Hello", 3)').should == "HelloHelloHello"
+    end
+  end
+
+  it "has a name" do
+    Context.new do |cxt|
+      f = cxt.eval('(function hi() {return "Hello World"})', '<eval>')
+      f.name.should == "hi"
+    end
+  end
+
+  it "can have its name set" do
+    Context.new do |cxt|
+      f = cxt.eval('(function () {return "Goodbye World"})', '<eval>')
+      f.name = 'bye'
+      f.name.should == 'bye'
+    end
+  end
+end