therubyracer-st 0.11.0beta5-x86-mingw32

data/lib/v8/version.rb

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

data/spec/c/array_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe V8::C::Array do
+  it "can store and retrieve a value" do
+    o = V8::C::Object::New()
+    a = V8::C::Array::New()
+    a.Length().should eql 0
+    a.Set(0, o)
+    a.Length().should eql 1
+    a.Get(0).Equals(o).should be_true
+  end
+
+  it "can be initialized with a length" do
+    a = V8::C::Array::New(5)
+    a.Length().should eql 5
+  end
+end

data/spec/c/constants_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe V8::C do
+  it "has constant methods for Undefined, Null, True and False" do
+    [:Undefined, :Null, :True, :False].each do |name|
+      constant = V8::C.send(name)
+      constant.should_not be_nil
+      V8::C.send(name).should be constant
+    end
+  end
+
+  it "has a value for the Empty handle" do
+    V8::C::Value::Empty.should_not be_nil
+    V8::C::Value::Empty.should be V8::C::Value::Empty
+  end
+
+  it "can access the V8 version" do
+    V8::C::V8::GetVersion().should match /^3\.11/
+  end
+end

data/spec/c/exception_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe V8::C::Exception do
+  it "can be thrown from Ruby" do
+    t = V8::C::FunctionTemplate::New(method(:explode))
+    @cxt.Global().Set("explode", t.GetFunction())
+    script = V8::C::Script::New(<<-JS, '<eval>')
+    (function() {
+      try {
+        explode()
+      } catch (e) {
+        return e.message
+      }
+    })()
+    JS
+    result = script.Run()
+    result.should_not be_nil
+    result.should be_kind_of(V8::C::String)
+    result.Utf8Value().should eql 'did not pay syntax'
+  end
+
+  def explode(arguments)
+    error = V8::C::Exception::SyntaxError('did not pay syntax')
+    V8::C::ThrowException(error)
+  end
+end

data/spec/c/external_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe V8::C::External do
+  it "can store and retrieve a value" do
+    o = Object.new
+    external = V8::C::External::New(o)
+    external.Value().should be(o)
+  end
+end

data/spec/c/function_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe V8::C::Function do
+  it "can be called" do
+    fn = run '(function() {return "foo"})'
+    fn.Call(@cxt.Global(), []).Utf8Value().should eql "foo"
+  end
+
+  it "can be called with arguments and context" do
+    fn = run '(function(one, two, three) {this.one = one; this.two = two; this.three = three})'
+    one = V8::C::Object::New()
+    two = V8::C::Object::New()
+    fn.Call(@cxt.Global(), [one, two, 3])
+    @cxt.Global().Get("one").should eql one
+    @cxt.Global().Get("two").should eql two
+    @cxt.Global().Get("three").should eql 3
+  end
+
+  it "can be called as a constructor" do
+    fn = run '(function() {this.foo = "foo"})'
+    fn.NewInstance().Get(V8::C::String::New('foo')).Utf8Value().should eql "foo"
+  end
+
+  it "can be called as a constructor with arguments" do
+    fn = run '(function(foo) {this.foo = foo})'
+    object = fn.NewInstance([V8::C::String::New("bar")])
+    object.Get(V8::C::String::New('foo')).Utf8Value().should eql "bar"
+  end
+
+  it "doesn't kill the world if invoking it throws a javascript exception" do
+    V8::C::TryCatch() do
+      fn = run '(function() { throw new Error("boom!")})'
+      fn.Call(@cxt.Global(), [])
+      fn.NewInstance([])
+    end
+  end
+
+
+  def run(source)
+    source = V8::C::String::New(source.to_s)
+    filename = V8::C::String::New("<eval>")
+    script = V8::C::Script::New(source, filename)
+    result = script.Run()
+    result.kind_of?(V8::C::String) ? result.Utf8Value() : result
+  end
+end

data/spec/c/handles_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe "setting up handles scopes" do
+  include ExplicitScoper
+
+  before do
+    def self.instance_eval(*args, &block)
+      V8::C::Locker() do
+        cxt = V8::C::Context::New()
+        begin
+          cxt.Enter()
+          super(*args, &block)
+        ensure
+          cxt.Exit()
+        end
+      end
+    end
+  end
+
+  it "can allocate handle scopes" do
+      V8::C::HandleScope() do
+        V8::C::Object::New()
+      end.class.should eql V8::C::Object
+  end
+
+  it "isn't the end of the world if a ruby exception is raised inside a HandleScope" do
+    begin
+      V8::C::HandleScope() do
+        raise "boom!"
+      end
+    rescue StandardError => e
+      e.message.should eql "boom!"
+    end
+  end
+end

data/spec/c/locker_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe V8::C::Locker do
+  include ExplicitScoper
+
+  it "can lock and unlock the VM" do
+    V8::C::Locker::IsLocked().should be_false
+    V8::C::Locker() do
+      V8::C::Locker::IsLocked().should be_true
+      V8::C::Unlocker() do
+        V8::C::Locker::IsLocked().should be_false
+      end
+    end
+    V8::C::Locker::IsLocked().should be_false
+  end
+
+  it "properly unlocks if an exception is thrown inside a lock block" do
+    begin
+      V8::C::Locker() do
+        raise "boom!"
+      end
+    rescue
+      V8::C::Locker::IsLocked().should be_false
+    end
+  end
+
+  it "properly re-locks if an exception is thrown inside an un-lock block" do
+    V8::C::Locker() do
+      begin
+        V8::C::Unlocker() do
+          raise "boom!"
+        end
+      rescue
+        V8::C::Locker::IsLocked().should be_true
+      end
+    end
+  end
+end

data/spec/c/object_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe V8::C::Object do
+
+  it "can store and retrieve a value" do
+    o = V8::C::Object::New()
+    key = V8::C::String::New("foo")
+    value = V8::C::String::New("bar")
+    o.Set(key, value)
+    o.Get(key).Utf8Value().should eql "bar"
+  end
+
+  it "can retrieve all property names" do
+    o = V8::C::Object::New()
+    o.Set(V8::C::String::New("foo"), V8::C::String::New("bar"))
+    o.Set(V8::C::String::New("baz"), V8::C::String::New("bang"))
+    names = o.GetPropertyNames()
+    names.Length().should eql 2
+    names.Get(0).Utf8Value().should eql "foo"
+    names.Get(1).Utf8Value().should eql "baz"
+  end
+  it "can set an accessor from ruby" do
+    o = V8::C::Object::New()
+    property = V8::C::String::New("statement")
+    callback_data = V8::C::String::New("I am Legend")
+    left = V8::C::String::New("Yo! ")
+    getter = proc do |name, info|
+      info.This().StrictEquals(o).should be_true
+      info.Holder().StrictEquals(o).should be_true
+      V8::C::String::Concat(left, info.Data())
+    end
+    setter = proc do |name, value, info|
+      left = value
+    end
+    o.SetAccessor(property, getter, setter, callback_data)
+    o.Get(property).Utf8Value().should eql "Yo! I am Legend"
+    o.Set(property, V8::C::String::New("Bro! "))
+    o.Get(property).Utf8Value().should eql "Bro! I am Legend"
+  end
+  it "always returns the same ruby object for the same V8 object" do
+    one = V8::C::Object::New()
+    two = V8::C::Object::New()
+    one.Set("two", two)
+    one.Get("two").should be two
+  end
+end

data/spec/c/script_spec.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe V8::C::Script do
+  it "can run a script and return a polymorphic result" do
+    source = V8::C::String::New("(new Array())")
+    filename = V8::C::String::New("<eval>")
+    script = V8::C::Script::New(source, filename)
+    result = script.Run()
+    result.should be_kind_of V8::C::Array
+  end
+
+  it "can accept precompiled script data" do
+    source = "7 * 6"
+    name = V8::C::String::New("<spec>")
+    origin = V8::C::ScriptOrigin.new(name)
+    data = V8::C::ScriptData::PreCompile(source, source.length)
+    data.HasError().should be_false
+    script = V8::C::Script::New(V8::C::String::New(source), origin, data)
+    script.Run().should eql 42
+  end
+
+  it "can detect errors in the script data" do
+    source = "^ = ;"
+    data = V8::C::ScriptData::PreCompile(source, source.length)
+    data.HasError().should be_true
+  end
+end

data/spec/c/string_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe V8::C::String do
+  it "can hold Unicode values outside the Basic Multilingual Plane" do
+    string = V8::C::String::New("\u{100000}")
+    string.Utf8Value().should eql "\u{100000}"
+  end
+
+  it "can naturally translate ruby strings into v8 strings" do
+    V8::C::String::Concat(V8::C::String::New("Hello "), "World").Utf8Value().should eql "Hello World"
+  end
+
+  it "can naturally translate ruby objects into v8 strings" do
+    V8::C::String::Concat(V8::C::String::New("forty two is "), 42).Utf8Value().should eql "forty two is 42"
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'v8'
+
+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