therubyracer-freebsd 0.10.1 → 0.11.1p2

data/spec/v8/error_spec.rb

@@ -1,131 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe V8::JSError do
-
-  before(:each) do
-    @cxt = V8::Context.new
-    @cxt['one'] = lambda do
-      @cxt.eval('two()', 'one.js')
-    end
-    @cxt['two'] = lambda do
-      @cxt.eval('three()', 'two.js')
-    end
-  end
-
-  it "captures a message without over nesting when the error is an error" do
-    throw! do |e|
-      e.message.should == "BOOM!"
-    end
-  end
-
-  it "captures the js message without over nesting when the error is a normal object" do
-    throw!('{foo: "bar"}') do |e|
-      e.message.should == "[object Object]"
-    end
-    throw!('{message: "bar"}') do |e|
-      e.message.should == "bar"
-    end
-  end
-
-  it "captures a thrown value as the message" do
-    throw!('"BOOM!"') do |e|
-      e.message.should == "BOOM!"
-    end
-    throw!('6') do |e|
-      e.message.should == '6'
-    end
-  end
-
-  it "has a reference to the root javascript cause" do
-    throw!('"I am a String"') do |e|
-      e.should_not be_in_ruby
-      e.should be_in_javascript 
-      e.value.should == "I am a String"
-    end
-  end
-
-  it "has a reference to the root ruby cause if one exists" do
-    StandardError.new("BOOM!").tap do |bomb|
-      @cxt['boom'] = lambda do
-        raise bomb
-      end
-      lambda {
-        @cxt.eval('boom()', 'boom.js')
-      }.should(raise_error do |raised|
-        raised.should be_in_ruby 
-        raised.should_not be_in_javascript 
-        raised.value.should be(bomb)
-      end)
-    end
-  end
-
-  describe "backtrace" do
-
-    it "is mixed with ruby and javascript" do
-      throw! do |e|
-        e.backtrace.first.should == "at three.js:1:7"
-        e.backtrace[1].should =~ /error_spec.rb/
-        e.backtrace[2].should == "at two.js:1:1"
-        e.backtrace[3].should =~ /error_spec.rb/
-        e.backtrace[4].should == "at one.js:1:1"
-      end
-    end
-    
-    it "can be set to show only ruby frames" do
-      throw! do |e|
-        e.backtrace(:ruby).each do |frame|
-          frame.should =~ /(\.rb|):\d+/
-        end
-      end
-    end
-    
-    it "can be set to show only javascript frames" do
-      throw! do |e|
-        e.backtrace(:javascript).each do |frame|
-          frame.should =~ /\.js:\d:\d/
-        end
-      end
-    end
-    
-    it "includes a mystery marker when the original frame is unavailable because what got thrown wasn't an error" do
-      throw!("6") do |e|
-        e.backtrace.first.should == 'at three.js:1:1'
-      end
-    end
-    
-    it "has a source name and line number when there is a javascript SyntaxError" do
-      lambda do
-        @cxt.eval(<<-INVALID, 'source.js')
-"this line is okay";
-"this line has a syntax error because it ends with a colon":
-"this line is also okay";
-"how do I find out that line 2 has the syntax error?";
-INVALID
-      end.should raise_error(V8::JSError) {|error|
-        error.backtrace.first.should == 'at source.js:2:60'
-      }
-    end
-
-    it "can start with ruby at the bottom" do
-      @cxt['boom'] = lambda do
-        raise StandardError, "Bif!"
-      end
-      lambda {
-        @cxt.eval('boom()', "boom.js")
-      }.should(raise_error {|e|
-        e.backtrace.first.should =~ /error_spec\.rb/
-        e.backtrace[1].should =~ /boom.js/
-      })
-    end
-  end
-  
-  
-  def throw!(js = "new Error('BOOM!')", &block)
-    @cxt['three'] = lambda do
-      @cxt.eval("throw #{js}", 'three.js')
-    end
-    lambda do
-      @cxt['one'].call()
-    end.should(raise_error(V8::JSError, &block))
-  end
-end

data/spec/v8/portal/proxies_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-describe V8::Portal::Proxies do
-  include V8::ExtSpec
-
-
-  context "for Ruby objects which are embedded into javascript" do
-
-    it "allows you to resolve the Ruby object's JavaScript proxy" do
-      js_proxy = c::Object::New()
-      rb_object = Object.new
-      subject.register_javascript_proxy js_proxy, :for => rb_object
-      subject.rb_object_2_js_proxy(rb_object).should be(js_proxy)
-      subject.js_proxy_2_rb_object(js_proxy).should be(rb_object)
-    end
-
-    it "requires a Ruby object which is the actual object that is proxied" do
-      expect {subject.register_javascript_proxy c::Object::New()}.should raise_error(ArgumentError)
-    end
-
-    it "can only register proxies which are low-level JavaScript objects" do
-      expect {subject.register_javascript_proxy Object.new, :for => Object.new}.should raise_error(ArgumentError)
-    end
-
-    it "is only allowed to have a single JavaScript proxy" do
-      rb_object = Object.new
-      subject.register_javascript_proxy c::Object::New(), :for => rb_object
-      expect {subject.register_javascript_proxy c::Object::New(), :for => rb_object}.should raise_error(V8::Portal::Proxies::DoubleProxyError)
-    end
-  end
-
-  context "for a JavaScript objects which are embedded into Ruby" do
-
-    it "allows you to resolve the JavaScript object's Ruby proxy" do
-      rb_proxy = Object.new
-      js_object = c::Object::New()
-      subject.register_ruby_proxy rb_proxy, :for => js_object
-      subject.js_object_2_rb_proxy(js_object).should be(rb_proxy)
-      subject.rb_proxy_2_js_object(rb_proxy).should be(js_object)
-    end
-
-    it "requires a JavaScript low level javascript object as the actual object that is proxied" do
-      expect {subject.register_javascript_proxy Object.new, :for => c::Object::New()}.should raise_error(ArgumentError)
-    end
-
-    it "will not a proxy twice if the proxy creator block actually registers the proxy inside it" do
-      target = Object.new
-      proxy = c::Object::New()
-      expect {subject.rb2js(target) do |object|
-        subject.register_javascript_proxy(proxy, :for => object)
-        c::Object::New()
-      end}.should_not raise_error
-      subject.rb2js(target).should be(proxy)
-    end
-
-    context "looking up a Ruby object from a random JavaScript object" do
-      it "checks first if it's a native Ruby object with a javascript proxy" do
-        target = Object.new
-        proxy = c::Object::New()
-        subject.register_javascript_proxy proxy, :for => target
-        subject.js2rb(proxy).should be(target)
-      end
-      it "then sees if maybe it's a native JavaScript that has a Ruby proxy" do
-        target = c::Object::New()
-        proxy = Object.new
-        subject.register_ruby_proxy proxy, :for => target
-        subject.js2rb(target).should be(proxy)
-      end
-      it "will assume that it is a native JavaScript object that needs a Ruby proxy if no corresponding Ruby object can be found" do
-        js = c::Object::New()
-        proxy = subject.js2rb(js) do |target|
-          {:target => target}
-        end
-        subject.js2rb(js).should be(proxy)
-      end
-    end
-
-    context "looking up a JavaScript object from a random Ruby object" do
-      it "checks first if it's a native JavaScript object with a Ruby proxy" do
-        target = c::Object::New()
-        proxy = Object.new
-        subject.register_ruby_proxy proxy, :for => target
-        subject.rb2js(proxy).should be(target)
-      end
-
-      it "then sees if maybe it's a native Ruby object that has a JavaScript proxy" do
-        target = Object.new
-        proxy = c::Object::New()
-        subject.register_javascript_proxy proxy, :for => target
-        subject.rb2js(target).should be(proxy)
-      end
-
-      it "assumes that it is a native Ruby object that needs a JavaScript proxy if no corresponding JavaScript object can be found" do
-        rb = Object.new
-        proxy = nil
-        js = subject.rb2js(rb) do |target|
-          target.should be(rb)
-          proxy = c::Object::New()
-        end
-        proxy.should_not be_nil
-        js.should be(proxy)
-        subject.rb2js(rb).should be(proxy)
-      end
-    end
-  end
-end

data/specmem/handle_memspec.rb

@@ -1,41 +0,0 @@
-
-require 'spec_helper'
-
-describe V8::C::Handle do
-  include V8::MemSpec
-  context "A JavaScript Object reflected into Ruby" do
-
-    before do
-      @weakref_callback = WeakrefCallback.new
-    end
-
-    it "has a strong reference from the ruby side, which is not released until the Ruby reference goes away" do
-      handle = c::Handle::New(object = c::Object::New())
-      handle.MakeWeak(nil, @weakref_callback)
-      ruby_gc do
-        v8_gc
-        @weakref_callback.should_not have_been_invoked
-        handle.should_not be_dead
-      end
-      ruby_gc do
-        object = nil
-        v8_gc
-        @weakref_callback.should have_been_invoked
-        handle.should be_dead
-      end
-    end
-
-    private
-
-    class WeakrefCallback
-
-      def call(value, parameters)
-        @invoked = true
-      end
-
-      def has_been_invoked?
-        @invoked
-      end
-    end
-  end
-end

data/specmem/object_memspec.rb

@@ -1,14 +0,0 @@
-
-require 'spec_helper'
-
-describe V8::C::Object do
-  include V8::MemSpec
-  it "will return a new peer and not barf if the old peer has been garbage collected" do
-    v8_eval('var o = {foo: "bar"}')
-    old_id = v8_eval('o').object_id
-    ruby_gc do
-      v8_eval('o').Get(c::String::New("foo")).Utf8Value().should == "bar"
-      v8_eval('o').object_id.should_not be(old_id)
-    end
-  end
-end

data/specmem/proxies_memspec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe V8::Portal::Proxies do
-  include V8::MemSpec
-  
-  context "A Ruby object embedded into JavaScript" do
-    it "holds a hard reference to any ruby object which is linked to a javascript proxy" do
-      subject.register_javascript_proxy c::Object::New(), :for => Object.new
-      ruby_gc do
-        subject.should_not be_empty
-      end
-    end
-
-    it "releases the hard reference if its corresponding javascript object has been garbage collected" do
-      ruby_gc do
-        rb_object = Object.new
-        js_proxy = c::Object::New()
-        subject.should be_empty
-        subject.register_javascript_proxy js_proxy, :for => rb_object
-        rb_object = nil
-        subject.should_not be_empty
-        v8_gc()
-      end
-      subject.should be_empty
-    end
-  end
-
-  context "A JavaScript object embedded into Ruby" do
-    it "holds a hard reference to any JavaScript object which is linked to a Ruby proxy" do
-      proxy = Object.new
-      subject.register_ruby_proxy proxy, :for => c::Object::New()
-      ruby_gc do
-        subject.should_not be_empty
-      end
-    end
-
-    it "clears any strong references to the JavaScript object when it's Ruby proxy is garbage collected" do
-      subject.register_ruby_proxy Object.new, :for => c::Object::New()
-      subject.should_not be_empty
-      ruby_gc do
-        v8_gc
-        GC.start
-        v8_gc
-      end
-      subject.should be_empty
-    end
-  end
-
-end

data/specmem/spec_helper.rb

@@ -1,24 +0,0 @@
-require Pathname(__FILE__).dirname.join('../spec/spec_helper')
-
-module V8::MemSpec
-  
-  def self.included(cls)
-    cls.class_eval do
-      include V8::ExtSpec
-      before(:all) {V8::C::V8::SetFlagsFromString("--expose-gc")}
-    end
-  end
-  
-  def ruby_gc
-    current = GC.stress
-    GC.stress = true
-    yield
-  ensure
-    GC.stress = current
-  end
-
-  def v8_gc
-    while !c::V8::IdleNotification();end
-    v8_eval('gc()', 'gc.js')
-  end
-end

data/specthread/spec_helper.rb

@@ -1,2 +0,0 @@
-require Pathname(__FILE__).dirname.join('../spec/spec_helper')
-

data/specthread/threading_spec.rb

@@ -1,13 +0,0 @@
-
-require 'spec_helper'
-
-describe "using v8 from multiple threads" do
-  
-  it "is possible" do
-    Thread.new do
-      require 'v8'
-      V8::Context.new
-    end.join
-    V8::Context.new
-  end
-end

data/therubyracer.gemspec

@@ -1,27 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "v8/version"
-require 'pathname'
-
-Gem::Specification.new do |s|
-  s.name = "therubyracer-freebsd"
-  s.rubyforge_project = "therubyracer"
-  s.summary = "Embed the V8 Javascript interpreter into Ruby"
-  s.version = V8::VERSION
-  s.authors = ["Charles Lowell", "Bill Robertson"]
-  s.description = "Call javascript code and manipulate javascript objects from ruby. Call ruby code and manipulate ruby objects from javascript."
-  s.homepage = "http://github.com/cowboyd/therubyracer"
-  s.email = "cowboyd@thefrontside.net"
-
-  root = Pathname(__FILE__).dirname
-  s.files = `git ls-files`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.extensions = ["ext/v8/extconf.rb"]
-  s.require_paths = ["lib", "ext"]
-
-  s.add_dependency "libv8-freebsd", "~> 3.3.10"
-
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rspec", "~> 2.0"
-  s.add_development_dependency "rake-compiler"
-end