therubyracer-xcode 0.12.2

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.12.2"
+end

data/lib/v8/weak.rb

@@ -0,0 +1,82 @@
+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.
+    #
+    # If you are having problems with this, an upgrade to 2.0 is *highly*
+    # recommended.
+    #
+    # for other platforms we just use the stdlib 'weakref'
+    # implementation
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby' && RUBY_VERSION < '2.0.0'
+      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)
+          ref = V8::Weak::Ref.new(value)
+          ObjectSpace.define_finalizer(value, self.class.ensure_cleanup(@values, key, ref))
+
+          @values[key] = ref
+        end
+
+        def self.ensure_cleanup(values,key,ref)
+          proc {
+            values.delete(key) if values[key] == ref
+          }
+        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/lib/v8.rb

@@ -0,0 +1,30 @@
+require "v8/version"
+
+require 'v8/weak'
+require 'v8/init'
+require 'v8/error'
+require 'v8/stack'
+require 'v8/conversion/fundamental'
+require 'v8/conversion/indentity'
+require 'v8/conversion/reference'
+require 'v8/conversion/primitive'
+require 'v8/conversion/code'
+require 'v8/conversion/class'
+require 'v8/conversion/object'
+require 'v8/conversion/time'
+require 'v8/conversion/hash'
+require 'v8/conversion/array'
+require 'v8/conversion/proc'
+require 'v8/conversion/method'
+require 'v8/conversion/symbol'
+require 'v8/conversion/string'
+require 'v8/conversion/fixnum'
+require 'v8/conversion'
+require 'v8/access/names'
+require 'v8/access/indices'
+require 'v8/access/invocation'
+require 'v8/access'
+require 'v8/context'
+require 'v8/object'
+require 'v8/array'
+require 'v8/function'

data/spec/c/array_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe V8::C::Array do
+  requires_v8_context
+
+  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_truthy
+  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,22 @@
+require 'spec_helper'
+
+describe V8::C do
+  requires_v8_context
+
+  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\.16/
+  end
+end

data/spec/c/exception_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe V8::C::Exception do
+  requires_v8_context
+
+  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,11 @@
+require 'spec_helper'
+
+describe V8::C::External do
+  requires_v8_context
+
+  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,48 @@
+require 'spec_helper'
+
+describe V8::C::Function do
+  requires_v8_context
+
+  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,31 @@
+require 'spec_helper'
+
+describe "setting up handles scopes" do
+  around(:each) do |example|
+    V8::C::Locker() do
+      cxt = V8::C::Context::New()
+      begin
+        cxt.Enter()
+        example.run
+      ensure
+        cxt.Exit()
+      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,36 @@
+require 'spec_helper'
+
+describe V8::C::Locker do
+  it "can lock and unlock the VM" do
+    V8::C::Locker::IsLocked().should be_falsey
+    V8::C::Locker() do
+      V8::C::Locker::IsLocked().should be_truthy
+      V8::C::Unlocker() do
+        V8::C::Locker::IsLocked().should be_falsey
+      end
+    end
+    V8::C::Locker::IsLocked().should be_falsey
+  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_falsey
+    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_truthy
+      end
+    end
+  end
+end

data/spec/c/object_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe V8::C::Object do
+  requires_v8_context
+
+  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_truthy
+      info.Holder().StrictEquals(o).should be_truthy
+      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,30 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe V8::C::Script do
+  requires_v8_context
+
+  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_falsey
+    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_truthy
+  end
+end

data/spec/c/string_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe V8::C::String do
+  requires_v8_context
+
+  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,31 @@
+require 'spec_helper'
+
+describe V8::C::Template do
+  requires_v8_context
+
+  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_truthy
+    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_truthy
+        arguments.This().StrictEquals(receiver).should be_truthy
+        arguments.Holder().StrictEquals(receiver).should be_truthy
+        arguments.IsConstructCall().should be_falsey
+        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,52 @@
+require 'spec_helper'
+
+describe V8::C::External do
+  requires_v8_context
+
+  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_truthy
+      trycatch.CanContinue().should be_truthy
+      exception = trycatch.Exception()
+      exception.should_not be_nil
+      exception.IsNativeError().should be_truthy
+      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_falsey
+      stack.GetFrame(4).IsEval().should be_truthy
+      frame.IsConstructor().should be_falsey
+    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
+  skip "not ready for prime-time"
+  #it_behaves_like 'RedJS::Context'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+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 V8ContextHelpers
+  module GroupMethods
+    def requires_v8_context
+      around(:each) do |example|
+        bootstrap_v8_context(&example)
+      end
+    end
+  end
+
+  def bootstrap_v8_context
+    V8::C::Locker() do
+      V8::C::HandleScope() do
+        @cxt = V8::C::Context::New()
+        begin
+          @cxt.Enter()
+          yield
+        ensure
+          @cxt.Exit()
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include V8ContextHelpers
+  c.extend V8ContextHelpers::GroupMethods
+end