therubyracer 0.10.2 → 0.11.0beta1

data/spec/c/template_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe V8::C::Template do
+
+  describe V8::C::FunctionTemplate do
+    it "can be created with no arguments" do
+      t = V8::C::FunctionTemplate::New()
+      t.GetFunction().Call(@cxt.Global(),[]).StrictEquals(@cxt.Global()).should be_true
+    end
+
+    it "can be created with a callback" do
+      receiver = V8::C::Object::New()
+      f = nil
+      callback = lambda do |arguments|
+        arguments.Length().should be(2)
+        arguments[0].Utf8Value().should eql 'one'
+        arguments[1].Utf8Value().should eql 'two'
+        arguments.Callee().StrictEquals(f).should be_true
+        arguments.This().StrictEquals(receiver).should be_true
+        arguments.Holder().StrictEquals(receiver).should be_true
+        arguments.IsConstructCall().should be_false
+        arguments.Data().Value().should be(42)
+        V8::C::String::New("result")
+      end
+      t = V8::C::FunctionTemplate::New(callback, V8::C::External::New(42))
+      f = t.GetFunction()
+      f.Call(receiver, [V8::C::String::New('one'), V8::C::String::New('two')]).Utf8Value().should eql "result"
+    end
+  end
+end

data/spec/c/trycatch_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe V8::C::External do
+
+  it "can catch javascript exceptions" do
+    V8::C::V8::SetCaptureStackTraceForUncaughtExceptions(true, 99, V8::C::StackTrace::kDetailed)
+    V8::C::TryCatch() do |trycatch|
+      source = V8::C::String::New(<<-JS)
+      function one() {
+        two()
+      }
+      function two() {
+        three()
+      }
+      function three() {
+        boom()
+      }
+      function boom() {
+        throw new Error('boom!')
+      }
+      eval('one()')
+      JS
+      filename = V8::C::String::New("<eval>")
+      script = V8::C::Script::New(source, filename)
+      result = script.Run()
+      trycatch.HasCaught().should be_true
+      trycatch.CanContinue().should be_true
+      exception = trycatch.Exception()
+      exception.should_not be_nil
+      exception.IsNativeError().should be_true
+      trycatch.StackTrace().Utf8Value().should match /boom.*three.*two.*one/m
+      message = trycatch.Message();
+      message.should_not be_nil
+      message.Get().Utf8Value().should eql "Uncaught Error: boom!"
+      message.GetSourceLine().Utf8Value().should eql "        throw new Error('boom!')"
+      message.GetScriptResourceName().Utf8Value().should eql "<eval>"
+      message.GetLineNumber().should eql 11
+      stack = message.GetStackTrace()
+      stack.should_not be_nil
+      stack.GetFrameCount().should eql 6
+      frame = stack.GetFrame(0)
+      frame.GetLineNumber().should eql 11
+      frame.GetColumn().should eql 15
+      frame.GetScriptName().Utf8Value().should eql "<eval>"
+      frame.GetScriptNameOrSourceURL().Utf8Value().should eql "<eval>"
+      frame.IsEval().should be_false
+      stack.GetFrame(4).IsEval().should be_true
+      frame.IsConstructor().should be_false
+    end
+  end
+end

data/spec/mem/blunt_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe "A Very blunt test to make sure that we aren't doing stupid leaks", :memory => true do
+  before do
+    if Object.const_defined?(:RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+      pending 'need to figure out how to do memory sanity checks on rbx'
+    end
+    #allocate a single context to make sure that v8 loads its snapshot and
+    #we pay the overhead.
+    V8::Context.new
+    @start_memory = process_memory
+    GC.stress = true
+  end
+
+  after do
+    GC.stress = false
+  end
+  it "won't increase process memory by more than 50% no matter how many contexts we create" do
+    500.times do
+       V8::Context.new
+       run_v8_gc
+    end
+    process_memory.should <= @start_memory * 1.5
+  end
+
+  it "can eval simple value passing statements repeatedly without significantly increasing memory" do
+    V8::C::Locker() do
+      cxt = V8::Context.new
+      500.times do
+        cxt.eval('7 * 6')
+        run_v8_gc
+      end
+    end
+      process_memory.should <= @start_memory * 1.1
+  end
+
+  def process_memory
+    /\w*[ ]*#{Process.pid}[ ]*([.,\d]*)[ ]*([.,\d]*)[ ]*([\d]*)[ ]*([\d]*)/.match(`ps aux`)[4].to_i
+  end
+
+end
+

data/spec/redjs_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'redjs/load_specs'
+module RedJS
+  Context = V8::Context
+  Error = V8::Error
+end
+describe V8::Context do
+  pending "not ready for prime-time"
+  #it_behaves_like 'RedJS::Context'
+end

data/spec/spec_helper.rb

@@ -1,9 +1,45 @@
-
 require 'v8'
-require 'erb'
-require Pathname(__FILE__).dirname.join('ext/ext_spec_helper')
-require Pathname(__FILE__).dirname.join('../specmem/spec_helper')
+
+def run_v8_gc
+  V8::C::V8::LowMemoryNotification()
+  while !V8::C::V8::IdleNotification() do
+  end
+end
+
 def rputs(msg)
   puts "<pre>#{ERB::Util.h(msg)}</pre>"
   $stdout.flush
 end
+
+module ExplicitScoper;end
+module Autoscope
+  def instance_eval(*args, &block)
+    return super unless low_level_c_spec? && !explicitly_defines_scope?
+    V8::C::Locker() do
+      V8::C::HandleScope() do
+        @cxt = V8::C::Context::New()
+        begin
+          @cxt.Enter()
+          super(*args, &block)
+        ensure
+          @cxt.Exit()
+        end
+      end
+    end
+  end
+
+  def low_level_c_spec?
+    return false unless described_class
+    described_class.name =~ /^V8::C::/
+  end
+
+  def explicitly_defines_scope?
+    is_a?(ExplicitScoper)
+  end
+end
+
+RSpec.configure do |c|
+  c.before(:each) do
+    extend Autoscope
+  end
+end

data/spec/threading_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe "using v8 from multiple threads", :threads => true do
+
+  it "creates contexts from within threads" do
+    10.times.collect do
+      Thread.new do
+        V8::Context.new
+      end
+    end.each {|t| t.join}
+    V8::Context.new
+  end
+
+  it "executes codes on multiple threads simultaneously" do
+    5.times.collect{V8::Context.new}.collect do |ctx|
+      Thread.new do
+        ctx['x'] = 99
+        while ctx['x'] > 0
+          ctx.eval 'for (i=10000;i;i--){};--x'
+        end
+      end
+    end.each {|t| t.join}
+  end
+
+  it "can access the current thread id" do
+    V8::C::Locker() do
+      V8::C::V8::GetCurrentThreadId().should_not be_nil
+    end
+  end
+
+  it "can pre-empt a running JavaScript thread" do
+    pending "need to release the GIL while executing V8 code"
+    begin
+      V8::C::Locker::StartPreemption(2)
+      thread_id = nil
+      Thread.new do
+        loop until thread_id
+        puts "thread id: #{thread_id}"
+        V8::C::V8::TerminateExecution(thread_id)
+      end
+      Thread.new do
+        V8::C::Locker() do
+          thread_id = V8::C::V8::GetCurrentThreadId()
+          V8::Context.new {|cxt| cxt.eval('while (true) {}')}
+        end
+      end
+      V8::C::V8::TerminateExecution(thread_id)
+    ensure
+      V8::C::Locker::StopPreemption()
+    end
+  end
+end

data/spec/v8/context_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe V8::Context do
+  it "can be disposed of" do
+    cxt = V8::Context.new
+    cxt.enter do
+      cxt['object'] = V8::Object.new
+    end
+    cxt.dispose()
+
+    lambda {cxt.eval('1 + 1')}.should raise_error
+    lambda {cxt['object']}.should raise_error
+  end
+
+  it "can be disposed of any number of times" do
+    cxt = V8::Context.new
+    10.times {cxt.dispose()}
+  end
+end

data/spec/v8/conversion_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'bigdecimal'
+describe V8::Conversion do
+  it "can embed BigDecimal values" do
+    cxt = V8::Context.new
+    cxt['big'] = BigDecimal.new('1.1')
+    cxt['big'].should eql BigDecimal.new('1.1')
+  end
+end

data/spec/v8/error_spec.rb

@@ -1,131 +1,21 @@
-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
+require 'spec_helper'
+
+describe V8::Error do
+  it "uses the same ruby exception through multiple language boundaries" do
+    V8::Context.new do |cxt|
+      error = StandardError.new('potato')
+      cxt['one'] = lambda do
+        cxt.eval('two()', 'one.js')
       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
+      cxt['two'] = lambda do
+        cxt.eval('three()', 'two.js')
       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!"
+      cxt['three'] = lambda do
+        raise error
       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')
+        cxt.eval('three()')
+      }.should raise_error {|e| e.should be error}
     end
-    lambda do
-      @cxt['one'].call()
-    end.should(raise_error(V8::JSError, &block))
   end
-end
+end

data/spec/v8/function_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe V8::Function do
+  it "uses the global context if it is invoked with nil as the context" do
+    @cxt = V8::Context.new
+    @cxt['foo'] = 'bar'
+    @cxt.eval('(function() {return this.foo})').methodcall(nil).should eql 'bar'
+  end
+end

data/therubyracer.gemspec

@@ -1,29 +1,20 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "v8/version"
-require 'pathname'
+require File.expand_path('../lib/v8/version', __FILE__)
 
-Gem::Specification.new do |s|
-  s.name = 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"
+Gem::Specification.new do |gem|
+  gem.authors       = ["Charles Lowell"]
+  gem.email         = ["javascript-and-friends@googlegroups.com"]
+  gem.summary       = "Embed the V8 Javascript interpreter into Ruby"
+  gem.description   = "Call javascript code and manipulate javascript objects from ruby. Call ruby code and manipulate ruby objects from javascript."
+  gem.homepage      = "http://github.com/cowboyd/therubyracer"
 
-  root = Pathname(__FILE__).dirname
-  s.files = `git ls-files`.split("\n")
-  s.files += Dir.chdir(root.join("spec/redjs")) do
-    `git ls-files`.split("\n").map {|f| "spec/redjs/#{f}"}
-  end
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.extensions = ["ext/v8/extconf.rb"]
-  s.require_paths = ["lib", "ext"]
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "therubyracer"
+  gem.extensions    = ["ext/v8/extconf.rb"]
+  gem.require_paths = ["lib", "ext"]
+  gem.version       = V8::VERSION
 
-  s.add_dependency "libv8", "~> 3.3.10"
-
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rspec", "~> 2.0"
-  s.add_development_dependency "rake-compiler"
+  gem.add_dependency 'ref'
 end