therubyracer 0.11.0beta8-x86-freebsd-9

data/lib/v8/stack.rb

@@ -0,0 +1,85 @@
+
+module V8
+
+  class StackTrace
+    include Enumerable
+
+    def initialize(native)
+      @context = V8::Context.current
+      @native = native
+    end
+
+    def length
+      @context.enter do
+        @native ? @native.GetFrameCount() : 0
+      end
+    end
+
+    def each
+      return unless @native
+      @context.enter do
+        for i in 0..length - 1
+          yield V8::StackFrame.new(@native.GetFrame(i), @context)
+        end
+      end
+    end
+
+    def to_s
+      @native ? map(&:to_s).join("\n") : ""
+    end
+  end
+
+  class StackFrame
+
+    def initialize(native, context)
+      @context = context
+      @native = native
+    end
+
+    def script_name
+      @context.enter do
+        @context.to_ruby(@native.GetScriptName())
+      end
+    end
+
+    def function_name
+      @context.enter do
+        @context.to_ruby(@native.GetFunctionName())
+      end
+    end
+
+    def line_number
+      @context.enter do
+        @native.GetLineNumber()
+      end
+    end
+
+    def column
+      @context.enter do
+        @native.GetColumn()
+      end
+    end
+
+    def eval?
+      @context.enter do
+        @native.IsEval()
+      end
+    end
+
+    def constructor?
+      @context.enter do
+        @native.IsConstructor()
+      end
+    end
+
+    def to_s
+      @context.enter do
+        "at " + if !function_name.empty?
+          "#{function_name} (#{script_name}:#{line_number}:#{column})"
+        else
+          "#{script_name}:#{line_number}:#{column}"
+        end
+      end
+    end
+  end
+end

data/lib/v8/version.rb

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

data/lib/v8/weak.rb

@@ -0,0 +1,70 @@
+module V8
+  module Weak
+    # weak refs are broken on MRI 1.9 and merely slow on 1.8
+    # so we mitigate this by using the 'ref' gem. However, this
+    # only mitigates the problem. Under heavy load, you will still
+    # get different or terminated objects being returned. bad stuff
+    #
+    # for other platforms we just use the stdlib 'weakref'
+    # implementation
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
+      require 'ref'
+      Ref = ::Ref::WeakReference
+      WeakValueMap = ::Ref::WeakValueMap
+    else
+      require 'weakref'
+      class Ref
+        def initialize(object)
+          @ref = ::WeakRef.new(object)
+        end
+        def object
+          @ref.__getobj__
+        rescue ::WeakRef::RefError
+          nil
+        end
+      end
+
+      class WeakValueMap
+        def initialize
+          @values = {}
+        end
+
+        def [](key)
+          if ref = @values[key]
+            ref.object
+          end
+        end
+
+        def []=(key, value)
+          @values[key] = V8::Weak::Ref.new(value)
+        end
+      end
+    end
+
+    module Cell
+      def weakcell(name, &block)
+        unless storage = instance_variable_get("@#{name}")
+          storage = instance_variable_set("@#{name}", Storage.new)
+        end
+        storage.access(&block)
+      end
+      class Storage
+        def access(&block)
+          if @ref
+            @ref.object || populate(block)
+          else
+            populate(block)
+          end
+        end
+
+        private
+
+        def populate(block)
+          occupant = block.call()
+          @ref = V8::Weak::Ref.new(occupant)
+          return occupant
+        end
+      end
+    end
+  end
+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