iso8601 0.7.0 → 0.8.0

data/lib/iso8601/errors.rb

@@ -29,6 +29,10 @@ module ISO8601
       end
     end
     ##
+    # Raised when the type is unexpected
+    class TypeError < StandardError
+    end
+    ##
     # Raise when the base is not suitable.
     class DurationBaseError < StandardError
       def initialize(duration)

data/lib/iso8601/time.rb

@@ -14,7 +14,7 @@ module ISO8601
 
     def_delegators(:@time,
       :to_time, :to_date, :to_datetime,
-      :hour, :minute, :zone, :hash)
+      :hour, :minute, :zone)
     ##
     # The separator used in the original ISO 8601 string.
     attr_reader :separator
@@ -39,6 +39,25 @@ module ISO8601
       @second = @time.second + @time.second_fraction.to_f
     end
     ##
+    # @param [#hash] contrast The contrast to compare against
+    #
+    # @return [Boolean]
+    def ==(contrast)
+      (hash == contrast.hash)
+    end
+    ##
+    # @param [#hash] contrast The contrast to compare against
+    #
+    # @return [Boolean]
+    def eql?(contrast)
+      (hash == contrast.hash)
+    end
+    ##
+    # @return [Fixnum]
+    def hash
+      [atoms, self.class].hash
+    end
+    ##
     # Forwards the time the given amount of seconds.
     #
     # @param [Numeric] seconds The seconds to add

data/lib/iso8601/version.rb

@@ -1,5 +1,5 @@
 module ISO8601
   ##
   # The gem version
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/spec/iso8601/atoms_spec.rb

@@ -1,8 +1,6 @@
-# encoding: utf-8
-
 require 'spec_helper'
 
-describe ISO8601::Atom do
+RSpec.describe ISO8601::Atom do
   it "should raise a TypeError when receives anything but a Numeric value" do
     expect { ISO8601::Atom.new('1') }.to raise_error
     expect { ISO8601::Atom.new(true) }.to raise_error
@@ -20,16 +18,28 @@ describe ISO8601::Atom do
     expect { ISO8601::Atom.new(1, 10) }.to raise_error
   end
   it "should create a new atom" do
-    ISO8601::Atom.new(-1).should be_an_instance_of(ISO8601::Atom)
+    expect(ISO8601::Atom.new(-1)).to be_an_instance_of(ISO8601::Atom)
   end
   describe '#to_i' do
     it "should return an integer" do
-      ISO8601::Atom.new(1).to_i.should be_a_kind_of(Integer)
-      ISO8601::Atom.new(1.0).to_i.should be_a_kind_of(Integer)
+      expect(ISO8601::Atom.new(1).to_i).to be_a_kind_of(Integer)
+      expect(ISO8601::Atom.new(1.0).to_i).to be_a_kind_of(Integer)
     end
     it "should return the integer part of the given number" do
-      n = 1.0
-      ISO8601::Atom.new(n).to_i.should == n.to_i
+      expect(ISO8601::Atom.new(1.0).to_i).to eq(1.0.to_i)
+    end
+  end
+  describe '#to_f' do
+    it "should return a float" do
+      expect(ISO8601::Atom.new(1).to_f).to be_a_kind_of(Float)
+      expect(ISO8601::Atom.new(1.0).to_f).to be_a_kind_of(Float)
+    end
+  end
+  describe '#value' do
+    it "should return the simplest value representation" do
+      expect(ISO8601::Atom.new(1).value).to eq(1)
+      expect(ISO8601::Atom.new(1.0).value).to eq(1)
+      expect(ISO8601::Atom.new(1.1).value).to eq(1.1)
     end
   end
   describe '#factor' do
@@ -43,31 +53,50 @@ describe ISO8601::Years do
   describe '#factor' do
     it "should return the Year factor" do
       expect { ISO8601::Years.new(1).factor }.to_not raise_error
-      ISO8601::Years.new(2).factor.should == 31536000
-      ISO8601::Years.new(1).factor.should == 31536000
+      expect(ISO8601::Years.new(2).factor).to eq(31536000)
+      expect(ISO8601::Years.new(1).factor).to eq(31536000)
     end
     it "should return the Year factor for a common year" do
-      ISO8601::Years.new(1, ISO8601::DateTime.new("2010-01-01")).factor.should == 31536000
+      expect(ISO8601::Years.new(1, ISO8601::DateTime.new("2010-01-01")).factor).to eq(31536000)
     end
     it "should return the Year factor for a leap year" do
-      ISO8601::Years.new(1, ISO8601::DateTime.new("2000-01-01")).factor.should == 31622400
+      expect(ISO8601::Years.new(1, ISO8601::DateTime.new("2000-01-01")).factor).to eq(31622400)
     end
   end
 
   describe '#to_seconds' do
     it "should return the amount of seconds" do
-      ISO8601::Years.new(2).to_seconds.should == 63072000
-      ISO8601::Years.new(-2).to_seconds.should == -63072000
+      expect(ISO8601::Years.new(2).to_seconds).to eq(63072000)
+      expect(ISO8601::Years.new(-2).to_seconds).to eq(-63072000)
     end
     it "should return the amount of seconds for a common year" do
       base = ISO8601::DateTime.new('2010-01-01')
-      ISO8601::Years.new(2, base).to_seconds.should == 63072000
-      ISO8601::Years.new(12, base).to_seconds.should == 378691200
+      expect(ISO8601::Years.new(2, base).to_seconds).to eq(63072000)
+      expect(ISO8601::Years.new(12, base).to_seconds).to eq(378691200)
     end
     it "should return the amount of seconds for a leap year" do
       base = ISO8601::DateTime.new('2000-01-01')
-      ISO8601::Years.new(2, base).to_seconds.should == 63158400
-      ISO8601::Years.new(15, base).to_seconds.should == 473385600
+      expect(ISO8601::Years.new(2, base).to_seconds).to eq(63158400)
+      expect(ISO8601::Years.new(15, base).to_seconds).to eq(473385600)
+    end
+  end
+
+  describe '#symbol' do
+    it "should return the ISO symbol" do
+      expect(ISO8601::Years.new(1)).to respond_to(:symbol)
+      expect(ISO8601::Years.new(1).symbol).to eq(:Y)
+    end
+  end
+
+  describe '#hash' do
+    let(:subject) { ISO8601::Years.new(3) }
+    it "should respond to #hash" do
+      expect(subject).to respond_to(:hash)
+    end
+    it "should build hash identity by value" do
+      contrast = ISO8601::Years.new(3)
+
+      expect(subject.hash == contrast.hash).to be_truthy
     end
   end
 end
@@ -76,38 +105,56 @@ describe ISO8601::Months do
   describe '#factor' do
     it "should return the Month factor" do
       expect { ISO8601::Months.new(1).factor }.to_not raise_error
-      ISO8601::Months.new(2).factor.should == 2628000
+      expect(ISO8601::Months.new(2).factor).to eq(2628000)
     end
     it "should return the Month factor for a common year" do
-      ISO8601::Months.new(1, ISO8601::DateTime.new('2010-01-01')).factor.should == 2678400
+      expect(ISO8601::Months.new(1, ISO8601::DateTime.new('2010-01-01')).factor).to eq(2678400)
     end
     it "should return the Month factor for a leap year" do
-      ISO8601::Months.new(1, ISO8601::DateTime.new('2000-01-01')).factor.should == 2678400
+      expect(ISO8601::Months.new(1, ISO8601::DateTime.new('2000-01-01')).factor).to eq(2678400)
     end
     it "should return the Month factor based on february for a common year" do
-      ISO8601::Months.new(1, ISO8601::DateTime.new('2010-02-01')).factor.should == 2419200
+      expect(ISO8601::Months.new(1, ISO8601::DateTime.new('2010-02-01')).factor).to eq(2419200)
     end
     it "should return the Month factor based on february for a leap year" do
-      ISO8601::Months.new(1, ISO8601::DateTime.new('2000-02-01')).factor.should == 2505600
+      expect(ISO8601::Months.new(1, ISO8601::DateTime.new('2000-02-01')).factor).to eq(2505600)
     end
   end
   describe '#to_seconds' do
     it "should return the amount of seconds" do
-      ISO8601::Months.new(2).to_seconds.should == 5256000
+      expect(ISO8601::Months.new(2).to_seconds).to eq(5256000)
     end
     it "should return the amount of seconds for a common year" do
-      ISO8601::Months.new(2, ISO8601::DateTime.new('2010-01-01')).to_seconds.should == 5097600
+      expect(ISO8601::Months.new(2, ISO8601::DateTime.new('2010-01-01')).to_seconds).to eq(5097600)
     end
     it "should return the amount of seconds for a leap year" do
-      ISO8601::Months.new(2, ISO8601::DateTime.new('2000-01-01')).to_seconds.should == 5184000
+      expect(ISO8601::Months.new(2, ISO8601::DateTime.new('2000-01-01')).to_seconds).to eq(5184000)
     end
     it "should return the amount of seconds based on februrary for a common year" do
-      ISO8601::Months.new(2, ISO8601::DateTime.new('2010-02-01')).to_seconds.should == 5097600
+      expect(ISO8601::Months.new(2, ISO8601::DateTime.new('2010-02-01')).to_seconds).to eq(5097600)
     end
     it "should return the amount of seconds based on february for a leap year" do
-      ISO8601::Months.new(2, ISO8601::DateTime.new('2000-02-01')).to_seconds.should == 5184000
-      ISO8601::Months.new(12, ISO8601::DateTime.new('2000-02-01')).to_seconds.should == 31622400
-      ISO8601::Months.new(12, ISO8601::DateTime.new('2000-02-01')).to_seconds.should == ISO8601::Years.new(1, ISO8601::DateTime.new("2000-02-01")).to_seconds
+      expect(ISO8601::Months.new(2, ISO8601::DateTime.new('2000-02-01')).to_seconds).to eq(5184000)
+      expect(ISO8601::Months.new(12, ISO8601::DateTime.new('2000-02-01')).to_seconds).to eq(31622400)
+      expect(ISO8601::Months.new(12, ISO8601::DateTime.new('2000-02-01')).to_seconds).to eq(ISO8601::Years.new(1, ISO8601::DateTime.new("2000-02-01")).to_seconds)
+    end
+  end
+  describe '#symbol' do
+    it "should return the ISO symbol" do
+      expect(ISO8601::Months.new(1)).to respond_to(:symbol)
+      expect(ISO8601::Months.new(1).symbol).to eq(:M)
+    end
+  end
+
+  describe '#hash' do
+    let(:subject) { ISO8601::Months.new(3) }
+    it "should respond to #hash" do
+      expect(subject).to respond_to(:hash)
+    end
+    it "should build hash identity by value" do
+      contrast = ISO8601::Months.new(3)
+
+      expect(subject.hash == contrast.hash).to be_truthy
     end
   end
 end
@@ -115,13 +162,31 @@ end
 describe ISO8601::Weeks do
   describe '#factor' do
     it "should return the Week factor" do
-      ISO8601::Weeks.new(2).factor.should == 604800
+      expect(ISO8601::Weeks.new(2).factor).to eq(604800)
     end
   end
   describe '#to_seconds' do
     it "should return the amount of seconds" do
-      ISO8601::Weeks.new(2).to_seconds.should == 1209600
-      ISO8601::Weeks.new(-2).to_seconds.should == -1209600
+      expect(ISO8601::Weeks.new(2).to_seconds).to eq(1209600)
+      expect(ISO8601::Weeks.new(-2).to_seconds).to eq(-1209600)
+    end
+  end
+  describe '#symbol' do
+    it "should return the ISO symbol" do
+      expect(ISO8601::Weeks.new(1)).to respond_to(:symbol)
+      expect(ISO8601::Weeks.new(1).symbol).to eq(:W)
+    end
+  end
+
+  describe '#hash' do
+    let(:subject) { ISO8601::Weeks.new(3) }
+    it "should respond to #hash" do
+      expect(subject).to respond_to(:hash)
+    end
+    it "should build hash identity by value" do
+      contrast = ISO8601::Weeks.new(3)
+
+      expect(subject.hash == contrast.hash).to be_truthy
     end
   end
 end
@@ -129,11 +194,29 @@ end
 describe ISO8601::Days do
   describe '#factor' do
     it "should return the Day factor" do
-      ISO8601::Days.new(2).factor.should == 86400
+      expect(ISO8601::Days.new(2).factor).to eq(86400)
     end
     it "should return the amount of seconds" do
-      ISO8601::Days.new(2).to_seconds.should == 172800
-      ISO8601::Days.new(-2).to_seconds.should == -172800
+      expect(ISO8601::Days.new(2).to_seconds).to eq(172800)
+      expect(ISO8601::Days.new(-2).to_seconds).to eq(-172800)
+    end
+  end
+  describe '#symbol' do
+    it "should return the ISO symbol" do
+      expect(ISO8601::Days.new(1)).to respond_to(:symbol)
+      expect(ISO8601::Days.new(1).symbol).to eq(:D)
+    end
+  end
+
+  describe '#hash' do
+    let(:subject) { ISO8601::Days.new(3) }
+    it "should respond to #hash" do
+      expect(subject).to respond_to(:hash)
+    end
+    it "should build hash identity by value" do
+      contrast = ISO8601::Days.new(3)
+
+      expect(subject.hash == contrast.hash).to be_truthy
     end
   end
 end
@@ -141,11 +224,29 @@ end
 describe ISO8601::Hours do
   describe '#factor' do
     it "should return the Hour factor" do
-      ISO8601::Hours.new(2).factor.should == 3600
+      expect(ISO8601::Hours.new(2).factor).to eq(3600)
     end
     it "should return the amount of seconds" do
-      ISO8601::Hours.new(2).to_seconds.should == 7200
-      ISO8601::Hours.new(-2).to_seconds.should == -7200
+      expect(ISO8601::Hours.new(2).to_seconds).to eq(7200)
+      expect(ISO8601::Hours.new(-2).to_seconds).to eq(-7200)
+    end
+  end
+  describe '#symbol' do
+    it "should return the ISO symbol" do
+      expect(ISO8601::Hours.new(1)).to respond_to(:symbol)
+      expect(ISO8601::Hours.new(1).symbol).to eq(:H)
+    end
+  end
+
+  describe '#hash' do
+    let(:subject) { ISO8601::Hours.new(3) }
+    it "should respond to #hash" do
+      expect(subject).to respond_to(:hash)
+    end
+    it "should build hash identity by value" do
+      contrast = ISO8601::Hours.new(3)
+
+      expect(subject.hash == contrast.hash).to be_truthy
     end
   end
 end
@@ -153,11 +254,29 @@ end
 describe ISO8601::Minutes do
   describe '#factor' do
     it "should return the Minute factor" do
-      ISO8601::Minutes.new(2).factor.should == 60
+      expect(ISO8601::Minutes.new(2).factor).to eq(60)
     end
     it "should return the amount of seconds" do
-      ISO8601::Minutes.new(2).to_seconds.should == 120
-      ISO8601::Minutes.new(-2).to_seconds.should == -120
+      expect(ISO8601::Minutes.new(2).to_seconds).to eq(120)
+      expect(ISO8601::Minutes.new(-2).to_seconds).to eq(-120)
+    end
+  end
+  describe '#symbol' do
+    it "should return the ISO symbol" do
+      expect(ISO8601::Minutes.new(1)).to respond_to(:symbol)
+      expect(ISO8601::Minutes.new(1).symbol).to eq(:M)
+    end
+  end
+
+  describe '#hash' do
+    let(:subject) { ISO8601::Minutes.new(3) }
+    it "should respond to #hash" do
+      expect(subject).to respond_to(:hash)
+    end
+    it "should build hash identity by value" do
+      contrast = ISO8601::Minutes.new(3)
+
+      expect(subject.hash == contrast.hash).to be_truthy
     end
   end
 end
@@ -165,12 +284,29 @@ end
 describe ISO8601::Seconds do
   describe '#factor' do
     it "should return the Second factor" do
-      ISO8601::Seconds.new(2).factor.should == 1
+      expect(ISO8601::Seconds.new(2).factor).to eq(1)
     end
     it "should return the amount of seconds" do
-      ISO8601::Seconds.new(2).to_seconds.should == 2
-      ISO8601::Seconds.new(-2).to_seconds.should == -2
+      expect(ISO8601::Seconds.new(2).to_seconds).to eq(2)
+      expect(ISO8601::Seconds.new(-2).to_seconds).to eq(-2)
     end
   end
-end
+  describe '#symbol' do
+    it "should return the ISO symbol" do
+      expect(ISO8601::Seconds.new(1)).to respond_to(:symbol)
+      expect(ISO8601::Seconds.new(1).symbol).to eq(:S)
+    end
+  end
+
+  describe '#hash' do
+    let(:subject) { ISO8601::Seconds.new(3) }
+    it "should respond to #hash" do
+      expect(subject).to respond_to(:hash)
+    end
+    it "should build hash identity by value" do
+      contrast = ISO8601::Seconds.new(3)
 
+      expect(subject.hash == contrast.hash).to be_truthy
+    end
+  end
+end

data/spec/iso8601/date_spec.rb

@@ -38,54 +38,51 @@ describe ISO8601::Date do
   context 'reduced patterns' do
     it "should parse correctly reduced dates" do
       reduced_date = ISO8601::Date.new('20100509')
-      reduced_date.year.should == 2010
-      reduced_date.month.should == 5
-      reduced_date.day.should == 9
+      expect(reduced_date.year).to eq(2010)
+      expect(reduced_date.month).to eq(5)
+      expect(reduced_date.day).to eq(9)
     end
   end
 
   it "should return the right sign for the given year" do
-    ISO8601::Date.new('-2014-05-31').year.should == -2014
-    ISO8601::Date.new('+2014-05-31').year.should == 2014
+    expect(ISO8601::Date.new('-2014-05-31').year).to eq(-2014)
+    expect(ISO8601::Date.new('+2014-05-31').year).to eq(2014)
   end
 
   it "should respond to delegated casting methods" do
-    dt = ISO8601::Date.new('2014-12-11')
-    dt.should respond_to(:to_s, :to_time, :to_date, :to_datetime)
+    expect(ISO8601::Date.new('2014-12-11')).to respond_to(:to_s, :to_time, :to_date, :to_datetime)
   end
 
   describe '#+' do
     it "should return the result of the addition" do
-      (ISO8601::Date.new('2012-07-07') + 7).to_s.should == '2012-07-14'
+      expect((ISO8601::Date.new('2012-07-07') + 7).to_s).to eq('2012-07-14')
     end
   end
 
   describe '#-' do
     it "should return the result of the substraction" do
-      (ISO8601::Date.new('2012-07-07') - 7).to_s.should == '2012-06-30'
+      expect((ISO8601::Date.new('2012-07-07') - 7).to_s).to eq('2012-06-30')
     end
   end
 
   describe '#to_a' do
     it "should return an array of atoms" do
-      dt = ISO8601::Date.new('2014-05-31').to_a
-      dt.should be_kind_of(Array)
-      dt.should == [2014, 5, 31]
+      expect(ISO8601::Date.new('2014-05-31').to_a).to eq([2014, 5, 31])
     end
   end
 
   describe '#atoms' do
     it "should return an array of original atoms" do
-      ISO8601::Date.new('2014-05-02').atoms.should == [2014, 5, 2]
-      ISO8601::Date.new('2014-05').atoms.should == [2014, 5]
-      ISO8601::Date.new('2014').atoms.should == [2014]
+      expect(ISO8601::Date.new('2014-05-02').atoms).to eq([2014, 5, 2])
+      expect(ISO8601::Date.new('2014-05').atoms).to eq([2014, 5])
+      expect(ISO8601::Date.new('2014').atoms).to eq([2014])
     end
   end
 
   describe '#hash' do
     it "should return the date hash" do
       subject = ISO8601::Date.new('2014-08-16')
-      contrast = ::Date.new(2014, 8, 16)
+      contrast = ISO8601::Date.new('2014-08-16')
 
       expect(subject).to respond_to(:hash)
       expect(subject.hash).to eq(contrast.hash)