mustang 0.0.1 → 0.1.0

data/spec/v8/data_spec.rb

@@ -0,0 +1,39 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Data do
+  setup_context
+
+  describe "#error?" do
+    it "returns false" do
+      subject.should_not be_error
+    end
+  end
+  
+  describe "#null?" do
+    it "returns false" do
+      subject.should_not be_null
+    end
+  end
+
+  describe "#undefined?" do
+    it "returns false" do
+      subject.should_not be_undefined
+    end
+  end
+
+  describe "#empty?" do
+    it "returns false" do
+      subject.should_not be_empty
+    end
+  end
+
+  describe "#value?" do
+    it "returns true when data is kind of value" do
+      V8::Integer.new(1).should be_value
+    end
+
+    it "returns false when data is not kind of value" do
+      V8::Undefined.should_not be_value
+    end
+  end
+end

data/spec/v8/date_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Date do 
+  subject { V8::Date }
+  setup_context
+  
+  before do
+    @now = Time.now
+  end
+
+  it "inherits V8::Value" do
+    subject.new(@now).should be_kind_of(V8::Value)
+  end
+
+  describe ".new" do
+    it "creates new v8 date based on passed value" do
+      subject.new(@now).to_i.should be_eql(@now.to_i)
+    end
+  end
+
+  describe "#to_i" do
+    it "returns fixnum value of represented date" do
+      subject.new(@now).to_i.should == @now.to_i
+    end
+  end
+
+  describe "#to_time" do
+    it "returns Time representation" do
+      subject.new(@now).to_time.to_i.should == @now.to_i
+    end
+  end
+
+  describe "an instance" do
+    it "is comparable" do
+      date = subject.new(@now)
+      date.should > @now-10
+      date.should < @now+10
+    end
+    
+    it "is delegated properly" do
+      date = subject.new(@now)
+      date.delegate.should == date.to_time
+    end
+  end
+end

data/spec/v8/empty_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Empty do
+  setup_context
+
+  it "is kind of V8::EmptyClass" do
+    subject.should be_kind_of(V8::EmptyClass)
+  end
+
+  describe "#null?" do
+    it "returns false" do
+      subject.should_not be_null
+    end
+  end
+
+  describe "#undefined?" do
+    it "returns false" do
+      subject.should_not be_undefined
+    end
+  end
+
+  describe "#empty?" do
+    it "returns true" do
+      subject.should be_empty
+    end
+  end
+end

data/spec/v8/errors_spec.rb

@@ -0,0 +1,142 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Exception handling" do
+  setup_context
+
+  it "returns v8 error object when JS code is broken" do
+    exc = cxt.eval("broken$code", "<eval>")
+    exc.should be_kind_of(V8::Error)
+    exc.should be_error
+  end
+end
+
+describe V8::Error do
+  setup_context
+
+  it "inherits V8::Data" do
+    subject.should be_kind_of(V8::Data)
+  end
+
+  it "#reference_error? returns false" do
+    subject.should_not be_reference_error
+  end
+  
+  it "#syntax_error? returns false" do
+    subject.should_not be_syntax_error
+  end
+  
+  it "#range_error? returns false" do
+    subject.should_not be_range_error
+  end
+
+  it "#type_error? returns false" do
+    subject.should_not be_type_error
+  end
+  
+  it "#error? return true" do
+    subject.should be_error
+  end
+
+  describe "info methods" do
+    let(:exc) do
+      cxt.eval("var a=1;\nbroken$code [{", "<eval>")
+    end
+
+    describe "#message" do
+      it "returns error message string" do
+        exc.message.should == "Unexpected end of input"
+      end
+    end
+    
+    describe "#line_no" do
+      it "returns broken line number" do
+        exc.line_no.should == 2
+      end
+    end
+
+    describe "#script_name" do
+      it "returns broken script name" do
+        exc.script_name.should == "<eval>"
+      end
+    end
+
+    describe "#source_line" do
+      it "returns broken source line" do
+        exc.source_line.should == "broken$code [{"
+      end
+    end
+
+    describe "#start_col" do
+      it "returns start column of broken code" do
+        exc.start_col.should == 14
+      end
+    end
+
+    describe "#end_col" do
+      it "returns end column of broken code" do
+        exc.end_col.should == 14
+      end
+    end
+  end
+end
+
+describe "Returned error" do
+  setup_context
+
+  it "is an ReferenceError when using undefined reference" do
+    cxt.eval("broken$code", "<eval>").should be_reference_error 
+  end
+
+  it "is an SyntaxError when invalid syntax" do
+    cxt.eval("broken {[/", "<eval>").should be_syntax_error
+  end
+
+  it "is an RangeError when maximum call stack exceeded" do
+    cxt.eval("function a() { a() }; a()", "<eval>").should be_range_error
+  end
+
+
+  it "is an TypeError when object is not a function" do
+    cxt.eval("a = 'foo'; a()", "<eval>").should be_type_error
+  end
+end
+
+describe V8::ReferenceError do
+  it "#reference_error? returns true" do
+    subject.should be_reference_error
+  end
+
+  it "#error? returns true" do
+    subject.should be_error
+  end
+end
+
+describe V8::SyntaxError do
+  it "#syntax_error? returns true" do
+    subject.should be_syntax_error
+  end
+
+  it "#error? returns true" do
+    subject.should be_error
+  end
+end
+
+describe V8::RangeError do
+  it "#range_error? returns true" do
+    subject.should be_range_error
+  end
+
+  it "#error? returns true" do
+    subject.should be_error
+  end
+end
+
+describe V8::TypeError do
+  it "#type_error? returns true" do
+    subject.should be_type_error
+  end
+
+  it "#error? returns true" do
+    subject.should be_error
+  end
+end

data/spec/v8/external_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'stringio'
+
+describe V8::External do
+  subject { V8::External }
+  setup_context
+
+  it "inherits V8::Value" do
+    subject.new(StringIO.new).should be_kind_of(V8::Value)
+  end
+  
+  describe ".new" do
+    it "creates new v8 external" do
+      obj = StringIO.new
+      subject.new(obj).should be_kind_of(V8::External)
+    end
+  end
+  
+  describe "#value" do
+    it "sets and gets values of given key from current object" do
+      obj = StringIO.new
+      ext = subject.new(obj)
+      ext.value.should == obj
+    end
+
+    it "is aliased with #to_obj" do
+      obj = StringIO.new
+      ext = subject.new(obj)
+      ext.to_obj.should == obj
+    end
+  end
+
+  describe "an instance" do
+    it "is delegated properly" do
+      class Bar
+        def bar; return 'bar'; end
+      end
+
+      obj = V8::External.new(Bar.new)
+      obj.delegate.bar.should == 'bar'
+      obj.bar.should == 'bar'
+    end
+  end
+end

data/spec/v8/function_spec.rb

@@ -0,0 +1,170 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Function do
+  subject { V8::Function }
+  setup_context
+
+  it "inherits V8::Object" do
+    subject.new(lambda { "foo" }).should be_kind_of(V8::Object)
+  end
+
+  describe ".new" do
+    context "when given proc/lambda" do
+      it "creates new function pointed to it" do
+        func = subject.new(lambda {|bar| "foo#{bar}"})
+        func.call("foo").should == "foofoo"
+      end
+    end
+
+    context "when block given" do
+      it "creates new function pointed to it" do
+        func = subject.new {|bar| "foo#{bar}" }
+        func.call("foo").should == "foofoo"
+      end
+    end
+
+    context "when object method given" do
+      it "creates new function pointed to it" do
+        class Foo
+          def initialize(foo); @foo = foo; end
+          def bar(arg); return "foo#{arg}#{@foo}"; end
+        end
+
+        foo = Foo.new('bar')
+        func = subject.new(foo.method(:bar))
+        func.call("foo").should =="foofoobar"
+      end
+    end
+  end
+
+  describe "#call_on" do
+    context "when recv is nil" do
+      it "executes function on global object" do
+        cxt.global[:foo] = 'bar' 
+        func = cxt.eval("var f = function(foo) { return this.foo+foo }; f;", "<eval>")
+        func.call_on(nil, 'bar').should == 'barbar'
+      end
+    end
+
+    context "when recv given" do
+      it "executes function on it" do
+        func = cxt.eval("var f = function(foo) { return this+foo }; f;", "<eval>")
+        func.call_on(10.to_v8, 10).should == 20
+      end
+    end
+  end
+
+  describe "#call" do
+    it "exectutes referenced javascript function" do
+      func = cxt.eval("var f = function(foo, bar) { return foo+bar }; f;", "<eval>")
+      func.call(10, 20).should == 30
+    end
+
+    context "when bound to dirreferent receiver object" do
+      it "executes function on it" do
+        func = cxt.eval("var f = function(foo) { return this+foo }; f;", "<eval>")
+        func.bind(10.to_v8)
+        func.call(10).should == 20
+      end
+    end
+
+    context "when not bound to any receiver" do
+      it "executes function on global object" do
+        func = cxt.eval("var f = function() { return this; }; f;", "<eval>")
+        func.call().should == cxt.global
+      end
+    end
+
+    context "when function cause errors" do
+      it "returns an caught error object" do
+        func = cxt.eval("var f = function() { return 'foo'+notexists; }; f;", "<eval>")
+        func.call().should be_error
+      end
+    end
+
+    context "when wrong numbers of arguments given" do
+      it "returns proper error" do
+        func = V8::Function.new(lambda {|arg| return arg })
+        func.call().should be_error
+        func.call(1).should == 1
+        func = V8::Function.new(lambda {|*args| return args.size })
+        func.call().should == 0
+        func.call(1,2,3).should == 3
+      end
+    end
+  end
+
+  describe "#bind" do
+    it "binds function with given object" do
+      func = V8::Function.new(lambda{})
+      func.bind('foo')
+      func.receiver.should == 'foo'
+    end
+  end
+
+  describe "#receiver" do
+    context "when no object bound to function" do
+      it "returns nil" do
+        func = V8::Function.new(lambda{})
+        func.receiver.should_not be
+      end
+    end
+
+    context "when object bound to function" do
+      it "returns it" do
+        func = V8::Function.new(lambda{})
+        func.bind(1)
+        func.receiver.should == 1
+      end
+    end
+  end
+
+  describe "#name= and #name" do
+    it "sets and gets function's unique name" do
+      func = V8::Function.new(lambda{})
+      func.name = 'foo'
+      func.name.should == 'foo'
+    end
+  end
+
+  describe "#origin" do
+    context "when function has been created from ruby proc/lambda/method" do
+      it "returns it" do
+        proc = Proc.new {}
+        func = V8::Function.new(proc)
+        func.origin.should == proc
+      end
+    end
+
+    context "when function has been taken from javascript" do
+      it "returns nil" do
+        func = cxt.eval("var f = function(){}; f", "<eval>")
+        func.origin.should_not be
+      end
+    end
+  end
+
+  describe "#to_proc" do
+    context "when function has been created from ruby proc/lambda/method" do
+      it "returns it" do
+        proc = Proc.new {}
+        func = V8::Function.new(proc)
+        func.to_proc.should == proc
+      end
+    end
+
+    context "when function has been taken from javascript" do
+      it "returns nil" do
+        func = cxt.eval("var f = function(){}; f", "<eval>")
+        func.to_proc.should_not be
+      end
+    end
+  end
+  
+  describe "in context" do
+    it "object reflected twice should be explicitly the same" do
+      cxt.eval("foo = function() {}", "<eval>")
+      cxt[:foo].object_id.should == cxt[:foo].object_id
+    end
+  end
+end