mustang 0.0.1 → 0.1.0

data/spec/v8/integer_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Integer do 
+  subject { V8::Integer }
+  setup_context
+  
+  it "inherits V8::Number" do
+    pending "Needs to separate V8::Number"
+    subject.new(10).should be_kind_of(V8::Number)
+  end
+
+  describe ".new" do
+    it "creates new v8 integer based on passed value" do
+      subject.new(10).should == 10
+      subject.new(-10).should == -10
+    end
+  end
+
+  describe "#to_i" do
+    it "returns fixnum value of represented integer" do
+      subject.new(10).to_i.should == 10
+    end
+  end
+
+  describe "an instance" do
+    it "is comparable" do
+      int = subject.new(10)
+      int.should == 10
+      int.should_not == 20
+      int.should > 5
+      int.should < 15
+      int.should <= 10
+      int.should >= 10
+    end
+    
+    it "is delegated properly" do
+      int = subject.new(3)
+      int.delegate.should == int.to_i
+    end
+  end
+end

data/spec/v8/main_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8 do
+  it "responds to .version" do
+    subject.should respond_to(:version)
+    subject.version.should =~ /^\d.\d.\d$/
+  end
+
+  it "responds to .dead?" do
+    subject.should respond_to(:dead?)
+    subject.should_not be_dead
+  end
+
+  it "responds to .alive?" do
+    subject.should respond_to(:alive?)
+    subject.should be_alive
+  end
+end

data/spec/v8/null_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Null do
+  setup_context
+
+  it "is kind of V8::NullClass" do
+    subject.should be_kind_of(V8::NullClass)
+  end
+
+  describe "#null?" do
+    it "returns true" do
+      subject.should 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
+end

data/spec/v8/number_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Number do 
+  subject { V8::Number }
+  setup_context
+  
+  it "inherits V8::Primitive" do
+    subject.new(10.5).should be_kind_of(V8::Primitive)
+  end
+
+  describe ".new" do
+    it "creates new v8 number based on passed value" do
+      subject.new(10.5).should == 10.5
+      subject.new(-10.5).should == -10.5
+    end
+  end
+
+  describe "#to_i" do
+    it "returns fixnum value of referenced number" do
+      subject.new(10.5).to_i.should == 10
+    end
+  end
+
+  describe "an instance" do
+    it "is comparable" do
+      num = subject.new(10.5)
+      num.should == 10.5
+      num.should_not == 20.5
+      num.should > 5.5
+      num.should < 15.5
+      num.should <= 10.5
+      num.should >= 10.5
+    end
+    
+    it "is delegated properly" do
+      num = subject.new(3.4)
+      num.delegate.should == num.to_f
+    end
+  end
+end

data/spec/v8/object_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Object do
+  subject { V8::Object }
+  setup_context
+
+  it "inherits V8::Value" do
+    subject.new(:foo => 1).should be_kind_of(V8::Value)
+  end
+  
+  describe ".new" do
+    it "creates new v8 object" do
+      subject.new.should be_kind_of(V8::Object)
+    end
+
+    context "when hash with properties passed" do
+      it "creates object with set given properties" do
+        obj = subject.new(:foo => 1, :bar => 2)
+        obj[:foo].should == 1
+        obj[:bar].should == 2
+      end
+    end
+  end
+  
+  describe "#[] and #[]=" do
+    it "sets and gets values of given key from current object" do
+      obj = subject.new
+      obj[:foo] = "bar"
+      obj[:foo].should == "bar"
+    end
+
+    it "can get properties by numeric keys" do
+      obj = subject.new
+      obj[1] = 'foo'
+      obj[1].should == 'foo'
+    end
+
+    it "are aliased with #get and #set" do
+      obj = subject.new
+      obj.set(:foo, "bar")
+      obj.get(:foo).should == "bar"
+    end
+  end
+
+  describe "#keys" do
+    let(:obj) { subject.new(:foo => 1, :bar => 2) }
+
+    it "returns list of keys belonging to an object" do
+      obj.keys.should == ['foo', 'bar']
+    end
+
+    it "is aliased with #properties" do
+      obj.properties.should == ['foo', 'bar']
+    end
+  end
+
+  describe "an instance" do
+    it "is enumerable" do
+      res = {}
+      obj = subject.new(:foo => 1, :bar => 2)
+      obj.each {|k,v| res[k.to_s] = v }
+      res['foo'].should == 1
+      res['bar'].should == 2
+    end
+
+    it "is delegated properly" do
+      obj = subject.new(:foo => 1, :bar => 2)
+      obj.delegate['foo'].should == 1
+      obj.delegate['bar'].should == 2
+    end
+  end
+
+  describe "in context" do
+    it "object reflected twice should be explicitly the same" do
+      cxt.eval("foo = {a:1, b:2}", "<eval>")
+      cxt[:foo].object_id.should == cxt[:foo].object_id
+    end
+  end
+end

data/spec/v8/primitive_spec.rb

@@ -0,0 +1,9 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Primitive do 
+  setup_context
+  
+  it "inherits V8::Value" do
+    V8::Primitive.new(0).should be_kind_of(V8::Value)
+  end
+end

data/spec/v8/regexp_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Regexp do 
+  subject { V8::Regexp }
+  setup_context
+  
+  it "inherits V8::Number" do
+    subject.new(/foo(bar)?/).should be_kind_of(V8::Value)
+  end
+
+  describe ".new" do
+    context "when ruby regexp passed" do
+      it "creates new v8 regexp based on it" do
+        subject.new(/foo(bar)?/im).should == /foo(bar)?/im
+      end
+    end
+
+    context "when string and flags passed" do
+      it "creates new v8 regexp based on them" do
+        subject.new("foo(bar)?", Regexp::IGNORECASE).should == /foo(bar)?/i
+      end
+    end
+
+    context "when string only passed" do
+      it "creates new v8 regexp based on it" do
+        subject.new("foo(bar)?").should == /foo(bar)?/
+      end
+    end
+  end
+
+  describe "#source" do
+    it "returns regexp source" do
+      subject.new("foo(bar.*)").source.should == "foo(bar.*)"
+    end
+  end
+
+  describe "#options" do
+    it "returns ruby regexp flags value" do
+      subject.new("foo", Regexp::IGNORECASE).options.should == 1
+      subject.new("foo", Regexp::EXTENDED).options.should == 2
+      subject.new("foo", Regexp::MULTILINE).options.should == 4
+    end
+  end
+
+  describe "#flags" do
+    it "returns v8 regexp flags value" do
+      subject.new("foo", Regexp::EXTENDED).flags.should == 1
+      subject.new("foo", Regexp::IGNORECASE).flags.should == 2
+      subject.new("foo", Regexp::MULTILINE).flags.should == 4
+    end
+  end
+
+  describe "#to_regexp" do
+    it "returns fixnum value of represented regexp" do
+      subject.new(/foo(bar)?/).to_regexp.should == /foo(bar)?/
+    end
+  end
+
+  describe "an instance" do
+    it "is delegated properly" do
+      rxp = subject.new(/foo/)
+      rxp.delegate.should == rxp.to_regexp
+    end
+  end
+end

data/spec/v8/string_spec.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::String do
+  subject { V8::String }
+  setup_context
+
+  it "inherits V8::Primitive" do
+    subject.new("foo").should be_kind_of(V8::Primitive)
+  end
+
+  describe ".new" do
+    it "creates new v8 string based on passed value" do
+      subject.new("foo").to_s.should == "foo"
+    end
+  end
+
+  describe "#to_ascii" do
+    it "returns ASCII value of represented string" do
+      subject.new("foobar").to_ascii.should == "foobar"
+    end
+  end
+
+  describe "#to_utf8" do
+    it "returns UTF-8 value of represented string" do
+      subject.new("zażółć").to_utf8.should == "zażółć"
+    end
+    
+    it "is aliased by #to_s" do
+      subject.new("foobar").to_s.should == "foobar"
+    end
+  end
+
+  describe "an instance" do
+    it "is comparable" do
+      str = subject.new("foo")
+      str.should == "foo"
+      str.should_not == "bar"
+      str.should > "a"
+      str.should < "foobar"
+    end
+    
+    it "is delegated properly" do
+      str = subject.new("foo")
+      str.delegate.should == str.to_s
+    end
+  end
+end

data/spec/v8/undefined_spec.rb

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

data/spec/v8/value_spec.rb

@@ -0,0 +1,215 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe V8::Value do
+  subject { V8::Value }
+  setup_context
+
+  it "inherits V8::Data" do
+    subject.new(Object.new).should be_kind_of(V8::Data)
+  end
+  
+  describe ".new" do
+    it "creates new v8 value" do
+      subject.new(Object.new).should be_kind_of(V8::Value)
+    end
+  end
+
+  describe "#object?" do
+    it "returns true when value is an instance of V8::Object" do
+      V8::Object.new.should be_object
+    end
+
+    it "returns false when value is not an instance of V8::Object" do
+      V8::External.new(Object.new).should_not be_object
+    end
+
+    it "is aliased with #obj?" do
+      V8::Object.new.should be_obj
+    end
+  end
+
+  describe "#integer?" do
+    it "returns true when value is an instance of V8::Integer" do
+      V8::Integer.new(10).should be_integer
+    end
+
+    it "returns false when value is not an instance of V8::Integer" do
+      subject.new(Object.new).should_not be_integer
+    end
+
+    it "is aliased with #int?" do
+      V8::Integer.new(10).should be_int
+    end
+  end
+
+  describe "#number?" do
+    it "returns true when value is an instance of V8::Number" do
+      V8::Number.new(10).should be_number
+    end
+
+    it "returns false when value is not an instance of V8::Number" do
+      subject.new(Object.new).should_not be_number
+    end
+
+    it "is aliased with #num?" do
+      V8::Number.new(10).should be_num
+    end
+  end
+
+  describe "#string?" do
+    it "returns true when value is an instance of V8::String" do
+      V8::String.new("foo").should be_string
+    end
+
+    it "returns false when value is not an instance of V8::String" do
+      subject.new(Object.new).should_not be_string
+    end
+
+    it "is aliased with #str?" do
+      V8::String.new("foo").should be_str
+    end
+  end
+
+  describe "#external?" do
+    it "returns true when value is an instance of V8::External" do
+      V8::External.new(Object.new).should be_external
+    end
+
+    it "returns false when value is not an instance of V8::External" do
+      V8::Integer.new(10).should_not be_external
+    end
+  end
+
+  describe "#array?" do
+    it "returns true when value is an instance of V8::Array" do
+      V8::Array.new(1,2,3).should be_array
+    end
+
+    it "returns false when value is not an instance of V8::Array" do
+      subject.new(Object.new).should_not be_array
+    end
+
+    it "is aliased with #ary?" do
+      V8::Array.new.should be_ary
+    end
+  end
+
+  describe "#function?" do
+    it "returns true when value is an instance of V8::Function" do
+      V8::Function.new(proc {}).should be_function
+    end
+
+    it "returns false when value is not an instance of V8::Function" do
+      V8::Integer.new(1).should_not be_function
+    end
+
+    it "is aliased with #func?" do
+      V8::Function.new(proc {}).should be_func
+    end
+  end
+
+  describe "#regexp?" do
+    it "returns true when value is an instance of V8::Regexp" do
+      V8::Regexp.new(/foo/).should be_regexp
+    end
+
+    it "returns false when value is not an instance of V8::Regexp" do
+      V8::Integer.new(1).should_not be_regexp
+    end
+
+    it "is aliased with #regex?" do
+      V8::Regexp.new(/foo/).should be_regex
+    end
+  end
+
+  describe "#date?" do
+    it "returns true when value is an instance of V8::Date" do
+      V8::Date.new(Time.now).should be_date
+    end
+
+    it "returns false when value is not an instance of V8::Date" do
+      V8::Integer.new(1).should_not be_date
+    end
+  end
+
+  describe "#to_integer" do
+    it "returns V8 integer representation of value" do
+      val = V8::Integer.new(10)
+      subject.new(val).to_integer.should == val
+    end
+  end
+
+  describe "#to_string" do
+    it "returns V8 string representation of value" do
+      val = V8::String.new("foo")
+      subject.new(val).to_string.should == val
+    end
+  end
+
+  describe "#to_number" do
+    it "returns V8 number representation of value" do
+      val = V8::Number.new(10.5)
+      subject.new(val).to_number.should == val
+    end
+  end
+
+  describe "#to_object" do
+    it "returns V8 object representation of value" do
+      val = V8::Object.new(:foo => 1)
+      subject.new(val).to_object.should == val
+    end
+  end
+
+  describe "#to_boolean" do
+    it "return V8 boolean representation of value" do
+      V8::Object.new(:foo => 1).to_boolean.should be_true
+      V8::Integer.new(0).to_boolean.should be_false
+    end
+  end
+
+  describe "#===" do
+    it "returns true when compared objects are strictly the same" do
+      obj = V8::Object.new(:foo => 1)
+      val = subject.new(obj)
+      val.should === obj
+    end
+
+    it "returns false when compared objects are strictly different" do
+      obj = V8::Object.new(:foo => 1)
+      val = subject.new(V8::Array.new)
+      val.should_not === obj
+    end
+  end
+
+  describe "#==" do
+    it "returns true when compared objects are the same" do
+      obj1 = V8::Integer.new(1)
+      obj2 = V8::Integer.new(1)
+      subject.new(obj1).should == obj2
+    end
+
+    it "returns false when compared objects are different" do
+      obj1 = V8::Object.new(:foo => 1)
+      obj2 = V8::Object.new(:bar => 1)
+      subject.new(obj1).should_not == obj2
+    end
+  end
+
+  describe "null?" do
+    it "returns true when object is not null" do
+      V8::Object.new.should_not be_null
+    end
+  end
+
+  describe "undefined?" do
+    it "returns true when object is not undefined" do
+      V8::Object.new.should_not be_undefined
+    end
+  end
+
+  describe "empty?" do
+    it "returns true when object is not empty" do
+      V8::Object.new.should_not be_empty
+    end
+  end
+end