therubyracer-freebsd 0.10.1 → 0.11.1p2

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

data/lib/v8/portal/templates.rb

@@ -1,73 +0,0 @@
-
-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/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/stack.rb

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

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

data/lib/v8/version.rb

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

data/lib/v8.rb

@@ -1,23 +0,0 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
-module V8
-  require 'v8/version'
-  require 'v8/v8' #native glue
-  require 'v8/c/locker'
-  require 'v8/portal'
-  require 'v8/portal/caller'
-  require 'v8/portal/proxies'
-  require 'v8/portal/templates'
-  require 'v8/portal/function'
-  require 'v8/portal/constructor'
-  require 'v8/portal/interceptors'
-  require 'v8/context'
-  require 'v8/object'
-  require 'v8/array'
-  require 'v8/function'
-  require 'v8/tap'
-  require 'v8/access'
-  require 'v8/error'
-  require 'v8/stack'
-end

data/spec/ext/array_spec.rb

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

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

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

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

data/spec/ext/object_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe V8::C::Object do
-  include V8::ExtSpec
-
-  it "always returns a copy of the same object if it is the same object" do
-    v8_eval('var o = new Object()')
-    v8_eval('o').should be(v8_eval('o'))
-  end
-end

data/spec/ext/string_spec.rb

@@ -1,11 +0,0 @@
-
-require 'spec_helper'
-
-describe V8::C::String do
-  include V8::ExtSpec
-  
-  describe "a string with null bytes" do
-    subject {c::String::New("foo\0bar")}
-    its(:Utf8Value) {should eql "foo\0bar"}
-  end
-end

data/spec/ext/try_catch_spec.rb

@@ -1,60 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper.rb"
-
-include V8
-
-describe C::TryCatch do
-
-  before {@lock = C::Locker.new;@cxt = C::Context::New();}
-  after {@cxt.Dispose(); @lock.delete}
-
-  it "does not allow instance creation by default" do
-    lambda {
-     C::TryCatch.new
-    }.should raise_error
-  end
-
-  it "will do nothing if not passed a block" do
-    C::TryCatch.try.should == nil
-  end
-
-  it "executes a block in the context of a C++ stack frame" do
-    C::TryCatch.try do |catch|
-      catch.HasCaught().should be(false)
-    end
-  end
-
-  it "raises an erro if you try to access it outside of its scope" do
-    tc = C::TryCatch.try do |catch|
-      catch.tap {}
-    end
-    lambda {
-      tc.HasCaught()
-    }.should raise_error(ScriptError)
-  end
-
-    it "doesn't segfault when an error is raised in a javascript function on a native prototype" do
-      constructor = Class.new
-      constructor.class_eval do
-        def detonate(*a)
-          raise "BOOM!"
-        end
-      end
-      V8::Context.new do |cxt|
-        cxt['Boom'] = constructor
-        cxt['puts'] = method(:puts)
-        danger = <<-JS
-  Boom.prototype.boom = function() {
-    this.detonate()
-  }
-  var go = new(Boom)()
-  try {
-    go.boom()
-  } catch (e) {
-  }
-  go.boom()
-  JS
-        expect {cxt.eval(danger, 'danger.js')}.should raise_error(V8::JSError)
-      end
-    end
-
-end

data/spec/redjs_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-require 'redjs/load_specs'
-module RedJS
-  Context = V8::Context
-  Error = V8::JSError
-end
-describe V8::Context do
-  it_behaves_like 'RedJS::Context'
-end

data/spec/spec_helper.rb

@@ -1,9 +0,0 @@
-
-require 'v8'
-require 'erb'
-require Pathname(__FILE__).dirname.join('ext/ext_spec_helper')
-require Pathname(__FILE__).dirname.join('../specmem/spec_helper')
-def rputs(msg)
-  puts "<pre>#{ERB::Util.h(msg)}</pre>"
-  $stdout.flush
-end