therubyracer 0.5.0-x86-linux → 0.11.0beta5-x86-linux

data/lib/v8/object.rb

@@ -1,38 +1,79 @@
+class V8::Object
+  include Enumerable
+  attr_reader :native
+  alias_method :to_v8, :native
 
-module V8
-  class Object
-    include Enumerable
-    
-    def initialize(native)
-      @native = native
-    end
-    
-    def [](key)
-      @native.context.open do
-        To.ruby(@native.Get(key.to_s))        
-      end
+  def initialize(native = nil)
+    @context = V8::Context.current or fail "tried to initialize a #{self.class} without being in an entered V8::Context"
+    @native = block_given? ? yield : native || V8::C::Object::New()
+    @context.link self, @native
+  end
+
+  def [](key)
+    @context.enter do
+      @context.to_ruby @native.Get(@context.to_v8(key))
     end
-    
-    def []=(key, value)
-      value.tap do
-        @native.context.open do
-          @native.Set(key.to_s, value)
-        end
-      end
+  end
+
+  def []=(key, value)
+    @context.enter do
+      @native.Set(@context.to_v8(key), @context.to_v8(value))
     end
-    
-    def each
-      for prop in @native.GetPropertyNames()
-        yield prop, self[prop]
+    return value
+  end
+
+  def keys
+    @context.enter do
+      names = @native.GetPropertyNames()
+      0.upto( names.Length() - 1).to_enum.map {|i| @context.to_ruby names.Get(i)}
+    end
+  end
+
+  def values
+    @context.enter do
+      names = @native.GetPropertyNames()
+      0.upto( names.Length() - 1).to_enum.map {|i| @context.to_ruby @native.Get(names.Get(i))}
+    end
+  end
+
+  def each
+    @context.enter do
+      names = @native.GetPropertyNames()
+      0.upto(names.Length() - 1) do |i|
+        name = names.Get(i)
+        yield @context.to_ruby(name), @context.to_ruby(@native.Get(name))
       end
     end
   end
-end
 
-class Object  
-  def eval_js(javascript)
-    V8::Context.open(:with => self) do |cxt|
-      cxt.eval(javascript)
+  def to_s
+    @context.enter do
+      @context.to_ruby @native.ToString()
+    end
+  end
+
+  def respond_to?(method)
+    super or self[method] != nil
+  end
+
+  def method_missing(name, *args, &block)
+    if name.to_s =~ /(.*)=$/
+      if args.length > 1
+        self[$1] = args
+        return args
+      else
+        self[$1] = args.first
+        return args
+      end
+    end
+    return super(name, *args, &block) unless self.respond_to?(name)
+    property = self[name]
+    if property.kind_of?(V8::Function)
+      property.methodcall(self, *args)
+    elsif args.empty?
+      property
+    else
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 0)" unless args.empty?
     end
   end
 end

data/lib/v8/util/weakcell.rb

@@ -0,0 +1,29 @@
+module V8
+  module Util
+    module Weakcell
+      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 = Ref::WeakReference.new(occupant)
+          return occupant
+        end
+      end
+    end
+  end
+end

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