coercible 0.0.1

data/spec/unit/coercible/coercer/hash/to_time_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Coercer::Hash, '.to_time' do
+  subject { object.to_time(hash) }
+
+  let(:object) { described_class.new }
+
+  context 'when time segments are missing' do
+    let(:time_now) { Time.local(2011, 1, 1) }
+    let(:hash)     { {}                     }
+
+    before do
+      Time.stub!(:now).and_return(time_now)  # freeze time
+    end
+
+    it { should be_instance_of(Time) }
+
+    it 'uses the Time now to populate the segments' do
+      should eql(time_now)
+    end
+  end
+
+  context 'when time segments are integers' do
+    let(:hash) { { :year => 2011, :month => 1, :day => 1, :hour => 1, :min => 1, :sec => 1 } }
+
+    it { should be_instance_of(Time) }
+
+    it { should eql(Time.local(2011, 1, 1, 1, 1, 1)) }
+  end
+
+  context 'when time segments are strings' do
+    let(:hash) { { :year => '2011', :month => '1', :day => '1', :hour => '1', :min => '1', :sec => '1' } }
+
+    it { should be_instance_of(Time) }
+
+    it { should eql(Time.local(2011, 1, 1, 1, 1, 1)) }
+  end
+end

data/spec/unit/coercible/coercer/integer/to_boolean_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Coercer::Integer, '.to_boolean' do
+  subject { object.to_boolean(fixnum) }
+
+  let(:object) { described_class.new }
+
+  context 'when the fixnum is 1' do
+    let(:fixnum) { 1 }
+
+    it { should be(true) }
+  end
+
+  context 'when the fixnum is 0' do
+    let(:fixnum) { 0 }
+
+    it { should be(false) }
+  end
+
+  context 'when the fixnum is not 1 or 0' do
+    let(:fixnum) { -1 }
+
+    specify do
+      expect { subject }.to raise_error(UnsupportedCoercion)
+    end
+  end
+end

data/spec/unit/coercible/coercer/integer/to_decimal_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Coercer::Integer, '.to_decimal' do
+  subject { object.to_decimal(fixnum) }
+
+  let(:object) { described_class.new }
+  let(:fixnum) { 1               }
+
+  it { should be_instance_of(BigDecimal) }
+
+  it { should eql(BigDecimal('1.0')) }
+end

data/spec/unit/coercible/coercer/integer/to_float_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Coercer::Integer, '.to_float' do
+  subject { object.to_float(fixnum) }
+
+  let(:object) { described_class.new }
+  let(:fixnum) { 1               }
+
+  it { should be_instance_of(Float) }
+
+  it { should eql(1.0) }
+end

data/spec/unit/coercible/coercer/integer/to_integer_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Coercer::Integer, '.to_integer' do
+  subject { described_class.new.to_integer(value) }
+
+  let(:value) { 1 }
+
+  it { should be(value) }
+end

data/spec/unit/coercible/coercer/integer/to_string_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Coercer::Integer, '.to_string' do
+  subject { object.to_string(integer) }
+
+  let(:object)  { described_class.new }
+  let(:integer) { 1               }
+
+  it { should be_instance_of(String) }
+
+  it { should eql('1') }
+end

data/spec/unit/coercible/coercer/integer_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Coercer::Integer do
+  it_behaves_like 'Configurable' do
+    describe '.config_name' do
+      subject { described_class.config_name }
+
+      it { should be(:integer) }
+    end
+  end
+end

data/spec/unit/coercible/coercer/numeric/to_decimal_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Coercer::Numeric, '.to_decimal' do
+  subject { object.to_decimal(numeric) }
+
+  let(:object)  { described_class.new }
+  let(:numeric) { Rational(2, 2)  }
+
+  it { should eql(BigDecimal('1.0')) }
+end

data/spec/unit/coercible/coercer/numeric/to_float_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Coercer::Numeric, '.to_float' do
+  subject { object.to_float(numeric) }
+
+  let(:object)  { described_class.new }
+  let(:numeric) { Rational(2, 2)  }
+
+  it { should eql(1.0) }
+end

data/spec/unit/coercible/coercer/numeric/to_integer_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Coercer::Numeric, '.to_integer' do
+  subject { object.to_integer(numeric) }
+
+  let(:object)  { described_class.new }
+  let(:numeric) { Rational(2, 2)  }
+
+  it { should eql(1) }
+end

data/spec/unit/coercible/coercer/numeric/to_string_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Coercer::Numeric, '.to_string' do
+  subject { object.to_string(numeric) }
+
+  let(:object)  { described_class.new }
+  let(:numeric) { Rational(2, 2)  }
+
+  let(:coerced_value) { RUBY_VERSION < '1.9' ? '1' : '1/1' }
+
+  it { should eql(coerced_value) }
+end

data/spec/unit/coercible/coercer/object/to_array_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Coercer::Object, '.to_array' do
+  subject { object.to_array(value) }
+
+  let(:object)  { described_class.new }
+  let(:value)   { Object.new      }
+  let(:coerced) { [ value ]       }
+
+  context 'when the value responds to #to_ary' do
+    before do
+      value.should_receive(:to_ary).with().and_return(coerced)
+    end
+
+    it { should be(coerced) }
+
+    it 'does not call #to_a if #to_ary is available' do
+      value.should_not_receive(:to_a)
+      subject
+    end
+  end
+
+  context 'when the value responds to #to_a but not #to_ary' do
+    before do
+      value.should_receive(:to_a).with().and_return(coerced)
+    end
+
+    it { should be(coerced) }
+  end
+
+  context 'when the value does not respond to #to_ary or #to_a' do
+    it { should be_instance_of(Array) }
+
+    it { should == coerced }
+  end
+
+  context 'when the value returns nil from #to_ary' do
+    before do
+      value.should_receive(:to_ary).with().and_return(nil)
+    end
+
+    it 'calls #to_a as a fallback' do
+      value.should_receive(:to_a).with().and_return(coerced)
+      should be(coerced)
+    end
+
+    it 'wraps the value in an Array if #to_a is not available' do
+      should == coerced
+    end
+  end
+end

data/spec/unit/coercible/coercer/object/to_hash_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Coercer::Object, '.to_hash' do
+  subject { object.to_hash(value) }
+
+  let(:object) { described_class.new }
+  let(:value)  { stub('value')   }
+
+  context 'when the value responds to #to_hash' do
+    let(:coerced) { stub('coerced') }
+
+    before do
+      value.should_receive(:to_hash).with().and_return(coerced)
+    end
+
+    it { should be(coerced) }
+  end
+
+  context 'when the value does not respond to #to_hash' do
+    it { should be(value) }
+  end
+end

data/spec/unit/coercible/coercer/object/to_integer_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Coercer::Object, '.to_integer' do
+  subject { object.to_integer(value) }
+
+  let(:object) { described_class.new }
+  let(:value)  { stub('value')   }
+
+  context 'when the value responds to #to_int' do
+    let(:coerced) { stub('coerced') }
+
+    before do
+      value.should_receive(:to_int).with().and_return(coerced)
+    end
+
+    it { should be(coerced) }
+  end
+
+  context 'when the value does not respond to #to_int' do
+    it { should be(value) }
+  end
+end

data/spec/unit/coercible/coercer/object/to_string_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Coercer::Object, '.to_string' do
+  subject { object.to_string(value) }
+
+  let(:object) { described_class.new }
+  let(:value)  { Object.new      }
+
+  context 'when the value responds to #to_str' do
+    let(:coerced) { stub('coerced') }
+
+    before do
+      value.should_receive(:to_str).with().and_return(coerced)
+    end
+
+    it { should be(coerced) }
+  end
+
+  context 'when the value does not respond to #to_str' do
+    it { should be(value) }
+  end
+end

data/spec/unit/coercible/coercer/string/to_boolean_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Coercer::String, '.to_boolean' do
+  subject { object.to_boolean(string) }
+
+  let(:object) { described_class.new }
+
+  %w[ 1 on ON t true T TRUE y yes Y YES ].each do |value|
+    context "with #{value.inspect}" do
+      let(:string) { value }
+
+      it { should be(true) }
+    end
+  end
+
+  %w[ 0 off OFF f false F FALSE n no N NO ].each do |value|
+    context "with #{value.inspect}" do
+      let(:string) { value }
+
+      it { should be(false) }
+    end
+  end
+
+  context 'with an invalid boolean string' do
+    let(:string) { 'non-boolean' }
+
+    specify do
+      expect { subject }.to raise_error
+    end
+  end
+end

data/spec/unit/coercible/coercer/string/to_constant_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Coercer::String, '.to_constant' do
+  subject { object.to_constant(string) }
+
+  let(:object) { described_class.new }
+
+  context 'with a non-namespaced name' do
+    let(:string) { 'String' }
+
+    it { should be(String) }
+  end
+
+  context 'with a non-namespaced qualified name' do
+    let(:string) { '::String' }
+
+    it { should be(String) }
+  end
+
+  context 'with a namespaced name' do
+    let(:string) { 'Coercible::Coercer::String' }
+
+    it { should be(Coercer::String) }
+  end
+
+  context 'with a namespaced qualified name' do
+    let(:string) { '::Coercible::Coercer::String' }
+
+    it { should be(Coercer::String) }
+  end
+
+  context 'with a name outside of the namespace' do
+    let(:string) { 'Virtus::Object' }
+
+    specify { expect { subject }.to raise_error(NameError) }
+  end
+
+  context 'when the name is unknown' do
+    let(:string) { 'Unknown' }
+
+    specify { expect { subject }.to raise_error(NameError) }
+  end
+
+  context 'when the name is invalid' do
+    let(:string) { 'invalid' }
+
+    specify { expect { subject }.to raise_error(NameError) }
+  end
+end

data/spec/unit/coercible/coercer/string/to_date_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Coercer::String, '.to_date' do
+  subject { object.to_date(string) }
+
+  let(:object) { described_class.new }
+
+  context 'with a valid date string' do
+    let(:string) { 'July, 22th, 2011' }
+
+    it { should be_instance_of(Date) }
+
+    its(:year)  { should == 2011 }
+    its(:month) { should == 7    }
+    its(:day)   { should == 22   }
+  end
+
+  context 'with an invalid date string' do
+    let(:string) { 'non-date' }
+
+    specify do
+      expect { subject }.to raise_error(UnsupportedCoercion)
+    end
+  end
+end

data/spec/unit/coercible/coercer/string/to_datetime_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+shared_examples_for 'a correct datetime object' do
+  it { should be_instance_of(DateTime) }
+
+  its(:year)  { should == year  }
+  its(:month) { should == month }
+  its(:day)   { should == day   }
+  its(:hour)  { should == hour  }
+  its(:min)   { should == min   }
+  its(:sec)   { should == sec   }
+end
+
+describe Coercer::String, '.to_datetime' do
+  subject { object.to_datetime(string) }
+
+  let(:object) { described_class.new }
+
+  context 'with a valid date string' do
+    let(:year)  { 2011 }
+    let(:month) { 7    }
+    let(:day)   { 22   }
+
+    context 'not including time part' do
+      let(:string) { "July, #{day}th, #{year}" }
+
+      let(:hour) { 0 }
+      let(:min)  { 0 }
+      let(:sec)  { 0 }
+
+      it_should_behave_like 'a correct datetime object'
+    end
+
+    context 'including time part' do
+      let(:string) { "July, #{day}, #{year}, #{hour}:#{min}:#{sec}" }
+
+      let(:hour) { 13 }
+      let(:min)  { 44 }
+      let(:sec)  { 50 }
+
+      it_should_behave_like 'a correct datetime object'
+    end
+  end
+
+  context 'with an invalid date time string' do
+    let(:string) { 'non-datetime' }
+
+    specify {
+      expect { subject }.to raise_error(UnsupportedCoercion)
+    }
+  end
+end