therubyracer 0.10.2 → 0.11.0beta1

data/lib/v8/portal/templates.rb

@@ -1,73 +0,0 @@
-
-module V8
-  class Portal
-    class Templates
-
-      attr_reader :portal
-
-      def initialize(portal)
-        @portal = portal
-        @constructors = {}
-        @methods = {}
-        @procs = {}
-        @releases = {}
-      end
-
-      def to_constructor(ruby_class)
-        class_id = ruby_class.object_id
-        if constructor = @constructors[class_id]
-          return constructor
-        else
-          constructor = @constructors[class_id] = ConstructorAdapter.new(self, class_id)
-          ObjectSpace.define_finalizer(ruby_class, release(@constructors, class_id))
-          return constructor
-        end
-      end
-
-      def to_function(code)
-        case code
-        when Method, UnboundMethod
-          if fn = @methods[code.to_s]
-            return fn
-          else
-            function = @methods[code.to_s] = FunctionAdapter.new(@portal, code)
-            #TODO: test this weak behavior
-            function.template.MakeWeak(0, release(@methods, code.to_s))
-            return function
-          end
-        else
-          if fn = @procs[code]
-            return fn
-          else
-            function = @procs[code] = FunctionAdapter.new(@portal, code)
-            #TODO: test this weak behavior
-            function.template.MakeWeak(0, release(@procs, code))
-            return function
-          end
-        end
-      end
-
-      def proxies
-        @portal.proxies
-      end
-
-      def release(refs, id)
-        release = Release.new(@releases, refs, id)
-        @releases[release] = true
-        return release
-      end
-
-      class Release
-        def initialize(releases, refs, id)
-          @releases, @refs, @id = releases, refs, id
-        end
-
-        def call(*args)
-          @refs.delete(@id)
-          @releases.delete(self)
-        end
-
-      end
-    end
-  end
-end

data/lib/v8/stack.rb

@@ -1,66 +0,0 @@
-
-module V8
-
-  class StackTrace
-    include Enumerable
-
-    def initialize(to, native)
-      @to = to
-      @native = native
-    end
-
-    def length
-      @native.GetFrameCount()
-    end
-
-    def each
-      for i in 0..length - 1
-        yield V8::StackFrame.new(@to, @native.GetFrame(i))
-      end
-    end
-
-    def to_s
-      map {|f|"at #{f}"}.join("\n")
-    end
-  end
-
-  class StackFrame
-
-    def initialize(portal, native)
-      @to = portal
-      @native = native
-    end
-
-    def script_name
-      @to.rb(@native.GetScriptName())
-    end
-
-    def function_name
-      @to.rb(@native.GetFunctionName())
-    end
-
-    def line_number
-      @native.GetLineNumber()
-    end
-
-    def column
-      @native.GetColumn()
-    end
-
-    def eval?
-      @native.IsEval()
-    end
-
-    def constructor?
-      @native.IsConstructor()
-    end
-
-    def to_s
-      if @native.GetFunctionName()
-        "#{function_name} (#{script_name}:#{line_number}:#{column})"
-      else
-        "#{script_name}:#{line_number}:#{column}"
-      end
-    end
-  end
-end

data/lib/v8/tap.rb

@@ -1,9 +0,0 @@
-
-unless Object.method_defined?(:tap)
-  class Object
-    def tap
-      yield self
-      return self
-    end
-  end
-end

data/spec/ext/array_spec.rb

@@ -1,15 +0,0 @@
-require "spec_helper"
-
-describe V8::C::Array do
-  include V8::ExtSpec
-  
-  it "can be instantiated" do
-    a = c::Array::New()
-    a.Length().should eql(0)
-  end
-  
-  it "maintains referential integrity" do
-    v8_eval('a = []')
-    v8_eval('a').should be(v8_eval('a'))
-  end
-end

data/spec/ext/cxt_spec.rb

@@ -1,57 +0,0 @@
-
-require "#{File.dirname(__FILE__)}/../spec_helper.rb"
-
-include V8
-
-describe C::Context do
-
-  before {@lock = C::Locker.new}
-  after {@lock.delete}
-
-  it "should not have a current context if no context is open" do
-    C::Context::GetEntered().should be_nil
-  end
-
-  it "can javascript properties on the global scope via ruby when the default scope is a ruby object" do
-    V8::Context.new(:with => Object.new) do |cxt|
-      cxt['foo'] = 'bar'
-      cxt.eval('foo').should eql('bar')
-    end
-  end
-
-  it "can get the current javascript execution stack" do
-    V8::Context.new do |cxt|
-      trace = nil
-      cxt['getTrace'] = lambda do
-        trace = V8::Context.stack
-      end
-      cxt.eval(<<-JS, 'trace.js')
-      function one() {
-        return two();
-      }
-
-      function two() {
-        return three();
-      }
-
-      function three() {
-        return getTrace()
-      }
-      one();
-JS
-      trace.length.should be(4)
-      trace.to_a[0].tap do |frame|
-        frame.line_number.should == 10
-        frame.column.should == 16
-        frame.script_name.should == 'trace.js'
-        frame.function_name.should == 'three'
-        frame.should_not be_eval
-        frame.should_not be_constructor
-      end
-    end
-  end
-
-  it "has an empty stack if there is no enterned context" do
-    V8::Context.stack.should be_empty
-  end
-end

data/spec/ext/ext_spec_helper.rb

@@ -1,27 +0,0 @@
-
-module V8::ExtSpec
-
-  def self.included(object)
-    object.class_eval do
-      before do
-        @lock = c::Locker.new
-        @cxt = c::Context::New()
-        @cxt.Enter()
-      end
-      after do
-        @cxt.Exit()
-        @cxt.Dispose()
-        @lock.delete
-      end
-    end
-  end
-
-  def v8_eval(script, sourcename = "<eval>")
-    c::Script::New(c::String::New(script), c::String::New(sourcename)).Run()
-  end
-
-  def c
-    V8::C
-  end
-
-end

data/spec/ext/func_spec.rb

@@ -1,64 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper.rb"
-
-include V8
-
-describe C::Function do
-  it "is callable" do
-    Context.new do |cxt|
-      f = cxt.eval('(function() {return "Hello World"})', '<eval>');
-      f.call().should == "Hello World"
-    end
-  end
-
-  it "receives proper argument length from ruby" do
-    Context.new do |cxt|
-      f = cxt.eval('(function() {return arguments.length})', 'eval')
-      f.call(1, 2, 3).should == 3
-    end
-  end
-
-  it "maps all arguments from ruby" do
-    Context.new do |cxt|
-      f = cxt.eval('(function(one, two, three) {return one + two + three})', 'eval')
-      f.call(1,2,3).should == 6
-    end
-  end
-
-  it "properly maps ruby objects back and forth from arguments to return value" do
-    Context.new do |cxt|
-      Object.new.tap do |this|
-         f = cxt.eval('(function() {return this})', 'eval')
-         f.methodcall(this).should be(this)
-      end
-    end
-  end
-
-  it "can be called outside of a context" do
-    Context.new do |cxt|
-      @f = cxt.eval('(function() {return "Call Me"})', 'eval')
-    end
-    @f.call().should == "Call Me"
-  end
-
-  it "is reflected properly" do
-    Context.new do |cxt|
-      cxt['say'] = lambda {|this, word, times| word * times}
-      cxt.eval('say("Hello", 3)').should == "HelloHelloHello"
-    end
-  end
-
-  it "has a name" do
-    Context.new do |cxt|
-      f = cxt.eval('(function hi() {return "Hello World"})', '<eval>')
-      f.name.should == "hi"
-    end
-  end
-
-  it "can have its name set" do
-    Context.new do |cxt|
-      f = cxt.eval('(function () {return "Goodbye World"})', '<eval>')
-      f.name = 'bye'
-      f.name.should == 'bye'
-    end
-  end
-end

data/spec/ext/object_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe V8::C::Object do
-  include V8::ExtSpec
-
-  it "always returns a copy of the same object if it is the same object" do
-    v8_eval('var o = new Object()')
-    v8_eval('o').should be(v8_eval('o'))
-  end
-end

data/spec/ext/string_spec.rb

@@ -1,11 +0,0 @@
-
-require 'spec_helper'
-
-describe V8::C::String do
-  include V8::ExtSpec
-  
-  describe "a string with null bytes" do
-    subject {c::String::New("foo\0bar")}
-    its(:Utf8Value) {should eql "foo\0bar"}
-  end
-end

data/spec/ext/try_catch_spec.rb

@@ -1,60 +0,0 @@
-require "#{File.dirname(__FILE__)}/../spec_helper.rb"
-
-include V8
-
-describe C::TryCatch do
-
-  before {@lock = C::Locker.new;@cxt = C::Context::New();}
-  after {@cxt.Dispose(); @lock.delete}
-
-  it "does not allow instance creation by default" do
-    lambda {
-     C::TryCatch.new
-    }.should raise_error
-  end
-
-  it "will do nothing if not passed a block" do
-    C::TryCatch.try.should == nil
-  end
-
-  it "executes a block in the context of a C++ stack frame" do
-    C::TryCatch.try do |catch|
-      catch.HasCaught().should be(false)
-    end
-  end
-
-  it "raises an erro if you try to access it outside of its scope" do
-    tc = C::TryCatch.try do |catch|
-      catch.tap {}
-    end
-    lambda {
-      tc.HasCaught()
-    }.should raise_error(ScriptError)
-  end
-
-    it "doesn't segfault when an error is raised in a javascript function on a native prototype" do
-      constructor = Class.new
-      constructor.class_eval do
-        def detonate(*a)
-          raise "BOOM!"
-        end
-      end
-      V8::Context.new do |cxt|
-        cxt['Boom'] = constructor
-        cxt['puts'] = method(:puts)
-        danger = <<-JS
-  Boom.prototype.boom = function() {
-    this.detonate()
-  }
-  var go = new(Boom)()
-  try {
-    go.boom()
-  } catch (e) {
-  }
-  go.boom()
-  JS
-        expect {cxt.eval(danger, 'danger.js')}.should raise_error(V8::JSError)
-      end
-    end
-
-end

data/spec/redjs_helper.rb

@@ -1,3 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-include V8

data/spec/v8/portal/proxies_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-describe V8::Portal::Proxies do
-  include V8::ExtSpec
-
-
-  context "for Ruby objects which are embedded into javascript" do
-
-    it "allows you to resolve the Ruby object's JavaScript proxy" do
-      js_proxy = c::Object::New()
-      rb_object = Object.new
-      subject.register_javascript_proxy js_proxy, :for => rb_object
-      subject.rb_object_2_js_proxy(rb_object).should be(js_proxy)
-      subject.js_proxy_2_rb_object(js_proxy).should be(rb_object)
-    end
-
-    it "requires a Ruby object which is the actual object that is proxied" do
-      expect {subject.register_javascript_proxy c::Object::New()}.should raise_error(ArgumentError)
-    end
-
-    it "can only register proxies which are low-level JavaScript objects" do
-      expect {subject.register_javascript_proxy Object.new, :for => Object.new}.should raise_error(ArgumentError)
-    end
-
-    it "is only allowed to have a single JavaScript proxy" do
-      rb_object = Object.new
-      subject.register_javascript_proxy c::Object::New(), :for => rb_object
-      expect {subject.register_javascript_proxy c::Object::New(), :for => rb_object}.should raise_error(V8::Portal::Proxies::DoubleProxyError)
-    end
-  end
-
-  context "for a JavaScript objects which are embedded into Ruby" do
-
-    it "allows you to resolve the JavaScript object's Ruby proxy" do
-      rb_proxy = Object.new
-      js_object = c::Object::New()
-      subject.register_ruby_proxy rb_proxy, :for => js_object
-      subject.js_object_2_rb_proxy(js_object).should be(rb_proxy)
-      subject.rb_proxy_2_js_object(rb_proxy).should be(js_object)
-    end
-
-    it "requires a JavaScript low level javascript object as the actual object that is proxied" do
-      expect {subject.register_javascript_proxy Object.new, :for => c::Object::New()}.should raise_error(ArgumentError)
-    end
-
-    it "will not a proxy twice if the proxy creator block actually registers the proxy inside it" do
-      target = Object.new
-      proxy = c::Object::New()
-      expect {subject.rb2js(target) do |object|
-        subject.register_javascript_proxy(proxy, :for => object)
-        c::Object::New()
-      end}.should_not raise_error
-      subject.rb2js(target).should be(proxy)
-    end
-
-    context "looking up a Ruby object from a random JavaScript object" do
-      it "checks first if it's a native Ruby object with a javascript proxy" do
-        target = Object.new
-        proxy = c::Object::New()
-        subject.register_javascript_proxy proxy, :for => target
-        subject.js2rb(proxy).should be(target)
-      end
-      it "then sees if maybe it's a native JavaScript that has a Ruby proxy" do
-        target = c::Object::New()
-        proxy = Object.new
-        subject.register_ruby_proxy proxy, :for => target
-        subject.js2rb(target).should be(proxy)
-      end
-      it "will assume that it is a native JavaScript object that needs a Ruby proxy if no corresponding Ruby object can be found" do
-        js = c::Object::New()
-        proxy = subject.js2rb(js) do |target|
-          {:target => target}
-        end
-        subject.js2rb(js).should be(proxy)
-      end
-    end
-
-    context "looking up a JavaScript object from a random Ruby object" do
-      it "checks first if it's a native JavaScript object with a Ruby proxy" do
-        target = c::Object::New()
-        proxy = Object.new
-        subject.register_ruby_proxy proxy, :for => target
-        subject.rb2js(proxy).should be(target)
-      end
-
-      it "then sees if maybe it's a native Ruby object that has a JavaScript proxy" do
-        target = Object.new
-        proxy = c::Object::New()
-        subject.register_javascript_proxy proxy, :for => target
-        subject.rb2js(target).should be(proxy)
-      end
-
-      it "assumes that it is a native Ruby object that needs a JavaScript proxy if no corresponding JavaScript object can be found" do
-        rb = Object.new
-        proxy = nil
-        js = subject.rb2js(rb) do |target|
-          target.should be(rb)
-          proxy = c::Object::New()
-        end
-        proxy.should_not be_nil
-        js.should be(proxy)
-        subject.rb2js(rb).should be(proxy)
-      end
-    end
-  end
-end