iso8601 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
----
-SHA1:
-  metadata.gz: 7f9e6e9d7f640ea9bb6d3393080c7fe50f4a1b68
-  data.tar.gz: 45717b674acf7e8eb1a5193f398d52320d4fce89
-SHA512:
-  metadata.gz: 40249de2e3e817cb21e7c441ab3ffd1e18a852ebaf76241e913f9275924dc710dd0d9acad440778c5241ff0d6a8be7f430bab6ae9ebc66aaf03ff5373c16f9d2
-  data.tar.gz: 3733a36fb5764007920b519bed2cc938d76382416ab6592140b74dbd32ca014c8804d8ce973efe7aea9c55ca28db3cdadefcf051469b4659d8d3d670c0aa3fac
+--- 
+SHA1: 
+  metadata.gz: 6de980e2da893c391f09b68e2e4cc46bd9d67c90
+  data.tar.gz: 3853cfee5b7a1797e937e296b8ac7aff5f6c5a0d
+SHA512: 
+  metadata.gz: 5826689b055f19401bb1abd644982e3a589f12e7d44d57dda721124784401fe59ba9a8a52e68c9daf864ea2c00577366cd66d896eb3e5340a943cd979f27f799
+  data.tar.gz: 65e6b987b1334d9b1023d80a2196ea5125c889a4dbd6c7323b989058ae5d2527acb75cdff12a5e785249737a0c93bdfafdacd2f0b3aa3ee27a04eb8dcb03e56b

data/.travis.yml

@@ -3,5 +3,5 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.2
-  - rbx-2
+  - rbx-2.2.10
 script: bundle exec rspec spec

data/lib/iso8601/atoms.rb

@@ -79,16 +79,45 @@ module ISO8601
     # years” of 365 “calendar days” and 97 “leap years” of 366 “calendar days”.
     def factor
       if @base.nil?
-        (((365 * 303 + 366 * 97) / 400) * 86400) / 12
+        nobase_calculation
       elsif @atom == 0
-        month = (@base.month <= 12) ? (@base.month) : ((@base.month) % 12)
-        year = @base.year + ((@base.month) / 12).to_i
-        (::Time.utc(year, month) - ::Time.utc(@base.year, @base.month))
+        zero_calculation
+      else
+        calculation
+      end
+    end
+
+    private
+
+    def nobase_calculation
+      (((365 * 303 + 366 * 97) / 400) * 86400) / 12
+    end
+
+    def zero_calculation
+      month = (@base.month <= 12) ? (@base.month) : ((@base.month) % 12)
+      year = @base.year + ((@base.month) / 12).to_i
+
+      (::Time.utc(year, month) - ::Time.utc(@base.year, @base.month))
+    end
+
+    def calculation
+      if @base.month + @atom <= 0
+        month = @base.month + @atom
+
+        if month % 12 == 0
+          year = @base.year + (month / 12) - 1
+          month = 12
+        else
+          year = @base.year + (month / 12).floor
+          month = (12 + month > 0) ? (12 + month) : (12 + (month % -12))
+        end
       else
         month = (@base.month + @atom <= 12) ? (@base.month + @atom) : ((@base.month + @atom) % 12)
+        month = 12 if month == 0
         year = @base.year + ((@base.month + @atom) / 12).to_i
-        (::Time.utc(year, month) - ::Time.utc(@base.year, @base.month)) / @atom
       end
+
+      (::Time.utc(year, month) - ::Time.utc(@base.year, @base.month)) / @atom
     end
   end
   ##

data/lib/iso8601/date.rb

@@ -28,14 +28,13 @@ module ISO8601
     # @param [String] input The date pattern
     def initialize(input)
       @original = input
-
       @atoms = atomize(input)
-      @date = ::Date.new(*@atoms)
-    rescue ArgumentError => error
-      raise ISO8601::Errors::RangeError, input
+      @date = compose(@atoms)
     end
     ##
     # The calendar week number (1-53)
+    #
+    # @return [Integer]
     def week
       @date.cweek
     end
@@ -74,52 +73,86 @@ module ISO8601
     # * YYYY-MM-DD, YYYYMMDD
     # * YYYY-Www, YYYYWdd
     # * YYYY-Www-D, YYYYWddD
+    # * YYYY-DDD, YYYYDDD
     #
     # @param [String] input
     #
     # @return [Array<Integer>]
     def atomize(input)
-      _, year, separator, month, day = /^(?:
-        ([+-]?\d{4})(-?)(\d{2})\2(\d{2}) | # YYYY-MM-DD
-        ([+-]?\d{4})(-?)(\d{3}) |          # YYYY-DDD
-        ([+-]?\d{4})(-)(\d{2}) |           # YYYY-MM
-        ([+-]?\d{4})                       # YYYY
-      )$/x.match(input).to_a.compact
+      week_date = /^([+-]?)\d{4}(-?)W\d{2}(?:\2\d)?$/.match(input)
+      return atomize_week_date(input, week_date[2], week_date[1]) unless week_date.nil?
 
-      if year.nil?
-        # Check if it's a Week date
-        _, year, separator, week, wday = /^(?:
-          ([+-]?\d{4})(-?)(W\d{2})\2(\d) | # YYYY-Www-D
-          ([+-]?\d{4})(-?)(W\d{2})         # YYYY-Www
-        )$/x.match(input).to_a.compact
+      _, sign, year, separator, day = /^([+-]?)(\d{4})(-?)(\d{3})$/.match(input).to_a.compact
+      return atomize_ordinal(year, day, separator, sign) unless year.nil?
 
-        unless week.nil?
-          d = ::Date.parse(input)
-          year = d.year
-          month = d.month
-          day = d.day
-        end
-      end
+      _, year, separator, month, day = /^
+        ([+-]?\d{4})   # YYYY
+        (?:
+          (-?)(\d{2})  # YYYY-MM
+          (?:
+            \2(\d{2})  # YYYY-MM-DD
+          )?
+        )?
+      $/x.match(input).to_a.compact
 
       raise ISO8601::Errors::UnknownPattern.new(@original) if year.nil?
 
       @separator = separator
 
-      return atomize_ordinal(year, month) if month && month.to_s.length == 3
-
       [year, month, day].compact.map(&:to_i)
     end
     ##
+    # Parses a week date (YYYY-Www-D, YYYY-Www) and returns its atoms.
+    #
+    # @param [String] input the date string.
+    # @param [String] separator the separator found in the input.
+    # @param [String] sign the sign found in the input.
+    #
+    # @return [Array<Integer>] date atoms.
+    def atomize_week_date(input, separator, sign)
+      date = parse(input)
+      sign = "#{sign}1".to_i
+      @separator = separator
+
+      [sign * date.year, date.month, date.day]
+    end
+    ##
     # Parses an ordinal date (YYYY-DDD) and returns its atoms.
     #
     # @param [String] year in YYYY form.
     # @param [String] day in DDD form.
+    # @param [String] separator the separator found in the input.
+    # @param [String] sign the sign found in the input.
     #
-    # @return [Array<Integer>] date atoms
-    def atomize_ordinal(year, day)
-      date = ::Date.parse([year, day].join('-'))
+    # @return [Array<Integer>] date atoms.
+    def atomize_ordinal(year, day, separator, sign)
+      date = parse([year, day].join('-'))
+      sign = "#{sign}1".to_i
+      @separator = separator
 
-      [date.year, date.month, date.day]
+      [sign * date.year, date.month, date.day]
+    end
+    ##
+    # Wraps ::Date.parse to play nice with ArgumentError.
+    #
+    # @param [String] string The formatted date.
+    #
+    # @return [::Date]
+    def parse(string)
+      ::Date.parse(string)
+    rescue ArgumentError
+      raise ISO8601::Errors::RangeError, @original
+    end
+    ##
+    # Wraps ::Date.new to play nice with ArgumentError.
+    #
+    # @param [Array<Integer>] atoms The date atoms.
+    #
+    # @return [::Date]
+    def compose(atoms)
+      ::Date.new(*atoms)
+    rescue ArgumentError
+      raise ISO8601::Errors::RangeError, @original
     end
   end
 end

data/lib/iso8601/dateTime.rb

@@ -16,6 +16,9 @@ module ISO8601
 
     attr_reader :second
 
+    FORMAT = '%Y-%m-%dT%H:%M:%S%:z'
+    FORMAT_WITH_FRACTION = '%Y-%m-%dT%H:%M:%S.%2N%:z'
+
     ##
     # @param [String] date_time The datetime pattern
     def initialize(date_time)
@@ -29,7 +32,7 @@ module ISO8601
     # @param [Numeric] seconds The seconds to add
     def +(seconds)
       moment = @date_time.to_time.localtime(zone) + seconds
-      format = moment.subsec.zero? ? "%Y-%m-%dT%H:%M:%S%:z" : "%Y-%m-%dT%H:%M:%S.%16N%:z"
+      format = moment.subsec.zero? ? FORMAT : FORMAT_WITH_FRACTION
 
       ISO8601::DateTime.new(moment.strftime(format))
     end
@@ -38,15 +41,15 @@ module ISO8601
     #
     # @param [Numeric] seconds The seconds to substract
     def -(seconds)
-      moment = @date_time.to_time.localtime(zone) - seconds.round(1)
-      format = moment.subsec.zero? ? "%Y-%m-%dT%H:%M:%S%:z" : "%Y-%m-%dT%H:%M:%S.%2N%:z"
+      moment = @date_time.to_time.localtime(zone) - seconds
+      format = moment.subsec.zero? ? FORMAT : FORMAT_WITH_FRACTION
 
       ISO8601::DateTime.new(moment.strftime(format))
     end
     ##
     # Converts DateTime to a formated string
     def to_s
-      format = @date_time.second_fraction.zero? ? "%Y-%m-%dT%H:%M:%S%:z" : "%Y-%m-%dT%H:%M:%S.%2N%:z"
+      format = @date_time.second_fraction.zero? ? FORMAT : FORMAT_WITH_FRACTION
       @date_time.strftime(format)
     end
     ##

data/lib/iso8601/time.rb

@@ -24,17 +24,19 @@ module ISO8601
     ##
     # The original atoms
     attr_reader :atoms
+
+    FORMAT = 'T%H:%M:%S%:z'
+    FORMAT_WITH_FRACTION = 'T%H:%M:%S.%2N%:z'
+
     ##
     # @param [String] input The time pattern
     # @param [Date] base The base date to determine the time
     def initialize(input, base = ::Date.today)
       @original = input
-
+      @base = base
       @atoms = atomize(input)
-      @time = ::DateTime.new(*[base.year, base.month, base.day], *@atoms)
+      @time = compose(@atoms, @base)
       @second = @time.second + @time.second_fraction.to_f
-    rescue ArgumentError => error
-      raise ISO8601::Errors::RangeError, input
     end
     ##
     # Forwards the time the given amount of seconds.
@@ -44,7 +46,7 @@ module ISO8601
     # @return [ISO8601::Time] New time resulting of the addition
     def +(seconds)
       moment = @time.to_time.localtime(zone) + seconds
-      format = moment.subsec.zero? ? "T%H:%M:%S%:z" : "T%H:%M:%S.%16N%:z"
+      format = moment.subsec.zero? ? FORMAT : FORMAT_WITH_FRACTION
 
       ISO8601::Time.new(moment.strftime(format), ::Date.parse(moment.strftime('%Y-%m-%d')))
     end
@@ -56,15 +58,15 @@ module ISO8601
     # @return [ISO8601::Time] New time resulting of the substraction
     def -(seconds)
       moment = @time.to_time.localtime(zone) - seconds
-      format = moment.subsec.zero? ? "T%H:%M:%S%:z" : "T%H:%M:%S.%16N%:z"
+      format = moment.subsec.zero? ? FORMAT : FORMAT_WITH_FRACTION
 
       ISO8601::Time.new(moment.strftime(format), ::Date.parse(moment.strftime('%Y-%m-%d')))
     end
     ##
     # Converts self to a time component representation.
     def to_s
-      strf = @time.second_fraction == 0 ? 'T%H:%M:%S%:z' : 'T%H:%M:%S.%2N%:z'
-      @time.strftime(strf)
+      format = @time.second_fraction.zero? ? FORMAT : FORMAT_WITH_FRACTION
+      @time.strftime(format)
     end
     ##
     # Converts self to an array of atoms.
@@ -111,5 +113,17 @@ module ISO8601
 
       !(wrong_pattern || invalid_separators)
     end
+    ##
+    # Wraps ::DateNew.new to play nice with ArgumentError.
+    #
+    # @param [Array<Integer>] atoms The time atoms.
+    # @param [::Date] base The base date to start computing time.
+    #
+    # @return [::DateTime]
+    def compose(atoms, base)
+      ::DateTime.new(*[base.year, base.month, base.day], *atoms)
+    rescue ArgumentError
+      raise ISO8601::Errors::RangeError, @original
+    end
   end
 end

data/lib/iso8601/version.rb

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

data/spec/iso8601/duration_spec.rb

@@ -84,58 +84,117 @@ describe ISO8601::Duration do
   end
 
   describe '#to_seconds' do
-    it "should return the seconds of a P[n]Y duration in a common year" do
-      ISO8601::Duration.new('P2Y', ISO8601::DateTime.new('2010-01-01')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2010, 1))
+    context 'positive durations' do
+      it "should return the seconds of a P[n]Y duration in a common year" do
+        ISO8601::Duration.new('P2Y', ISO8601::DateTime.new('2010-01-01')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2010, 1))
+      end
+      it "should return the seconds of a P[n]Y duration in a leap year" do
+        ISO8601::Duration.new('P2Y', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2002, 1) - Time.utc(2000, 1))
+      end
+      it "should return the seconds of a P[n]Y[n]M duration in a common year" do
+        ISO8601::Duration.new('P2Y3M', ISO8601::DateTime.new('2010-01-01')).to_seconds.should == (Time.utc(2012, 4) - Time.utc(2010, 1))
+      end
+      it "should return the seconds of a P[n]Y[n]M duration in a leap year" do
+        ISO8601::Duration.new('P2Y3M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2002, 4) - Time.utc(2000, 1))
+      end
+      it "should return the seconds of a P[n]M duration in a common year" do
+        ISO8601::Duration.new('P1M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 2) - Time.utc(2012, 1))
+        ISO8601::Duration.new('P2M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 3) - Time.utc(2012, 1))
+        ISO8601::Duration.new('P19M', ISO8601::DateTime.new('2012-05-01')).to_seconds.should == (Time.utc(2014, 12) - Time.utc(2012, 5))
+        ISO8601::Duration.new('P14M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2013, 3) - Time.utc(2012, 1))
+      end
+      it "should return the seconds of a P[n]M duration in a leap year" do
+        ISO8601::Duration.new('P1M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2000, 2) - Time.utc(2000, 1))
+        ISO8601::Duration.new('P2M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2000, 3) - Time.utc(2000, 1))
+        ISO8601::Duration.new('P14M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2001, 3) - Time.utc(2000, 1))
+      end
+      it "should return the seconds of a P[n]Y[n]M[n]D duration" do
+        ISO8601::Duration.new('P2Y11D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2014, 1, 12) - Time.utc(2012, 1))
+        ISO8601::Duration.new('P1Y1M1D', ISO8601::DateTime.new('2010-05-01')).to_seconds.should == (Time.utc(2011, 6, 2) - Time.utc(2010, 5))
+      end
+      it "should return the seconds of a P[n]D duration" do
+        ISO8601::Duration.new('P1D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 2) - Time.utc(2012, 1, 1))
+        ISO8601::Duration.new('P11D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 12) - Time.utc(2012, 1, 1))
+        ISO8601::Duration.new('P3M11D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 4, 12) - Time.utc(2012, 1))
+      end
+      it "should return the seconds of a P[n]W duration" do
+        ISO8601::Duration.new('P2W', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 15) - Time.utc(2012, 1))
+        ISO8601::Duration.new('P2W', ISO8601::DateTime.new('2012-02-01')).to_seconds.should == (Time.utc(2012, 2, 15) - Time.utc(2012, 2))
+      end
+
+      it "should return the seconds of a PT[n]H duration" do
+        ISO8601::Duration.new('PT5H', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 5) - Time.utc(2012, 1))
+        ISO8601::Duration.new('P1YT5H', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2013, 1, 1, 5) - Time.utc(2012, 1))
+      end
+
+      it "should return the seconds of a PT[n]H[n]M duration" do
+        ISO8601::Duration.new('PT5M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 0, 5) - Time.utc(2012, 1))
+        ISO8601::Duration.new('PT1H5M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 1, 5) - Time.utc(2012, 1))
+        ISO8601::Duration.new('PT1H5M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == ISO8601::Duration.new('PT65M', ISO8601::DateTime.new('2012-01-01')).to_seconds
+      end
+
+      it "should return the seconds of a PT[n]H[n]M duration" do
+        ISO8601::Duration.new('PT10S', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 0, 0, 10) - Time.utc(2012, 1))
+        ISO8601::Duration.new('PT10.4S', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == 10.4
+      end
+    end
+
+    context 'negative durations' do
+      it "should return the seconds of a -P[n]Y duration" do
+        ISO8601::Duration.new('-P2Y', ISO8601::DateTime.new('2010-01-01')).to_seconds.should == (Time.utc(2008, 1) - Time.utc(2010, 1))
+      end
+      it "should return the seconds of a -P[n]Y duration in a leap year" do
+        ISO8601::Duration.new('-P2Y', ISO8601::DateTime.new('2001-01-01')).to_seconds.should == (Time.utc(1999, 1) - Time.utc(2001, 1))
+      end
+      it "should return the seconds of a -P[n]Y[n]M duration in a common year" do
+        ISO8601::Duration.new('-P2Y3M', ISO8601::DateTime.new('2010-01-01')).to_seconds.should == (Time.utc(2007, 10) - Time.utc(2010, 1))
+      end
+      it "should return the seconds of a -P[n]Y[n]M duration in a leap year" do
+        ISO8601::Duration.new('-P2Y3M', ISO8601::DateTime.new('2001-01-01')).to_seconds.should == (Time.utc(1998, 10) - Time.utc(2001, 1))
+      end
+      it "should return the seconds of a -P[n]M duration in a common year" do
+        ISO8601::Duration.new('-P1M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2011, 12) - Time.utc(2012, 1))
+        ISO8601::Duration.new('-P1M', ISO8601::DateTime.new('2012-02-01')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 2))
+        ISO8601::Duration.new('-P2M', ISO8601::DateTime.new('2012-03-01')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 3))
+        ISO8601::Duration.new('-P36M', ISO8601::DateTime.new('2013-03-01')).to_seconds.should == (Time.utc(2010, 3) - Time.utc(2013, 3))
+        ISO8601::Duration.new('-P39M', ISO8601::DateTime.new('2013-03-01')).to_seconds.should == (Time.utc(2009, 12) - Time.utc(2013, 3))
+        ISO8601::Duration.new('-P156M', ISO8601::DateTime.new('2013-03-01')).to_seconds.should == (Time.utc(2000, 3) - Time.utc(2013, 3))
+      end
+      it "should return the seconds of a -P[n]M duration in a leap year" do
+        ISO8601::Duration.new('-P1M', ISO8601::DateTime.new('2000-02-01')).to_seconds.should == (Time.utc(2000, 1) - Time.utc(2000, 2))
+        ISO8601::Duration.new('-P2M', ISO8601::DateTime.new('2000-03-01')).to_seconds.should == (Time.utc(2000, 1) - Time.utc(2000, 3))
+        ISO8601::Duration.new('-P14M', ISO8601::DateTime.new('2001-03-01')).to_seconds.should == (Time.utc(2000, 1) - Time.utc(2001, 3))
+      end
+      it "should return the seconds of a -P[n]Y[n]M[n]D duration" do
+        ISO8601::Duration.new('-P2Y11D', ISO8601::DateTime.new('2014-01-12')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2014, 1, 12))
+        ISO8601::Duration.new('-P1Y1M1D', ISO8601::DateTime.new('2010-05-01')).to_seconds.should == (Time.utc(2009, 3, 31) - Time.utc(2010, 5))
+      end
+      it "should return the seconds of a -P[n]D duration" do
+        ISO8601::Duration.new('-P1D', ISO8601::DateTime.new('2012-01-02')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 2))
+        ISO8601::Duration.new('-P11D', ISO8601::DateTime.new('2012-01-12')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 12))
+        ISO8601::Duration.new('-P3M11D', ISO8601::DateTime.new('2012-04-12')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 4, 12))
+      end
+      it "should return the seconds of a -P[n]W duration" do
+        ISO8601::Duration.new('-P2W', ISO8601::DateTime.new('2012-01-15')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 15))
+        ISO8601::Duration.new('-P2W', ISO8601::DateTime.new('2012-02-01')).to_seconds.should == (Time.utc(2012, 2) - Time.utc(2012, 2, 15))
+      end
+
+      it "should return the seconds of a -PT[n]H duration" do
+        ISO8601::Duration.new('-PT5H', ISO8601::DateTime.new('2012-01-01T05')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 1, 5))
+        ISO8601::Duration.new('-P1YT5H', ISO8601::DateTime.new('2013-01-01T05')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2013, 1, 1, 5))
+      end
+
+      it "should return the seconds of a -PT[n]H[n]M duration" do
+        ISO8601::Duration.new('-PT5M', ISO8601::DateTime.new('2012-01-01T00:05')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 1, 0, 5))
+        ISO8601::Duration.new('-PT1H5M', ISO8601::DateTime.new('2012-01-01T01:05')).to_seconds.should == (Time.utc(2012, 1) - Time.utc(2012, 1, 1, 1, 5))
+        ISO8601::Duration.new('-PT1H5M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == ISO8601::Duration.new('-PT65M', ISO8601::DateTime.new('2012-01-01')).to_seconds
+      end
+
+      it "should return the seconds of a -PT[n]H[n]M duration" do
+        ISO8601::Duration.new('-PT10S', ISO8601::DateTime.new('2012-01-01T00:00:00')).to_seconds.should == (Time.utc(2011, 12, 31, 23, 59, 50) - Time.utc(2012, 1))
+        ISO8601::Duration.new('-PT10.4S', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == -10.4
+      end
     end
-    it "should return the seconds of a P[n]Y duration in a leap year" do
-      ISO8601::Duration.new('P2Y', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2002, 1) - Time.utc(2000, 1))
-    end
-    it "should return the seconds of a P[n]Y[n]M duration in a common year" do
-      ISO8601::Duration.new('P2Y3M', ISO8601::DateTime.new('2010-01-01')).to_seconds.should == (Time.utc(2012, 4) - Time.utc(2010, 1))
-    end
-    it "should return the seconds of a P[n]Y[n]M duration in a leap year" do
-      ISO8601::Duration.new('P2Y3M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2002, 4) - Time.utc(2000, 1))
-    end
-    it "should return the seconds of a P[n]M duration in a common year" do
-      ISO8601::Duration.new('P1M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 2) - Time.utc(2012, 1))
-      ISO8601::Duration.new('P2M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 3) - Time.utc(2012, 1))
-      ISO8601::Duration.new('P14M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2013, 3) - Time.utc(2012, 1))
-    end
-    it "should return the seconds of a P[n]M duration in a leap year" do
-      ISO8601::Duration.new('P1M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2000, 2) - Time.utc(2000, 1))
-      ISO8601::Duration.new('P2M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2000, 3) - Time.utc(2000, 1))
-      ISO8601::Duration.new('P14M', ISO8601::DateTime.new('2000-01-01')).to_seconds.should == (Time.utc(2001, 3) - Time.utc(2000, 1))
-    end
-    it "should return the seconds of a P[n]Y[n]M[n]D duration" do
-      ISO8601::Duration.new('P2Y11D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2014, 1, 12) - Time.utc(2012, 1))
-      ISO8601::Duration.new('P1Y1M1D', ISO8601::DateTime.new('2010-05-01')).to_seconds.should == (Time.utc(2011, 6, 2) - Time.utc(2010, 5))
-    end
-    it "should return the seconds of a P[n]D duration" do
-      ISO8601::Duration.new('P1D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 2) - Time.utc(2012, 1, 1))
-      ISO8601::Duration.new('P11D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 12) - Time.utc(2012, 1, 1))
-      ISO8601::Duration.new('P3M11D', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 4, 12) - Time.utc(2012, 1))
-    end
-    it "should return the seconds of a P[n]W duration" do
-      ISO8601::Duration.new('P2W', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 15) - Time.utc(2012, 1))
-      ISO8601::Duration.new('P2W', ISO8601::DateTime.new('2012-02-01')).to_seconds.should == (Time.utc(2012, 2, 15) - Time.utc(2012, 2))
-    end
-
-    it "should return the seconds of a PT[n]H duration" do
-      ISO8601::Duration.new('PT5H', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 5) - Time.utc(2012, 1))
-      ISO8601::Duration.new('P1YT5H', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2013, 1, 1, 5) - Time.utc(2012, 1))
-    end
-
-    it "should return the seconds of a PT[n]H[n]M duration" do
-      ISO8601::Duration.new('PT5M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 0, 5) - Time.utc(2012, 1))
-      ISO8601::Duration.new('PT1H5M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 1, 5) - Time.utc(2012, 1))
-      ISO8601::Duration.new('PT1H5M', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == ISO8601::Duration.new('PT65M', ISO8601::DateTime.new('2012-01-01')).to_seconds
-    end
-
-    it "should return the seconds of a PT[n]H[n]M duration" do
-      ISO8601::Duration.new('PT10S', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == (Time.utc(2012, 1, 1, 0, 0, 10) - Time.utc(2012, 1))
-      ISO8601::Duration.new('PT10.4S', ISO8601::DateTime.new('2012-01-01')).to_seconds.should == 10.4
-    end
-
   end
 
   describe '#==' do

metadata

@@ -1,53 +1,48 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: iso8601
-version: !ruby/object:Gem::Version
-  version: 0.5.0
+version: !ruby/object:Gem::Version 
+  version: 0.5.1
 platform: ruby
-authors:
+authors: 
 - Arnau Siches
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-07 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2014-07-27 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.14"
   name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.14'
   type: :development
+  requirement: *id001
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.14'
-- !ruby/object:Gem::Dependency
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id003 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   name: rerun
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
   type: :development
+  requirement: *id002
   prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: "    ISO8601 is a simple implementation in Ruby of the ISO 8601 (Data
-  elements and \n    interchange formats - Information interchange - Representation
-  of dates \n    and times) standard.\n"
+description: "    ISO8601 is a simple implementation in Ruby of the ISO 8601 (Data elements and \n    interchange formats - Information interchange - Representation of dates \n    and times) standard.\n"
 email: arnau.siches@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
-- ".gitignore"
-- ".travis.yml"
+
+files: 
+- .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
@@ -68,30 +63,29 @@ files:
 - spec/iso8601/time_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/arnau/ISO8601
-licenses:
+licenses: 
 - MIT
 metadata: {}
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ">="
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
-  requirements:
-  - - ">="
-    - !ruby/object:Gem::Version
-      version: '0'
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id003
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id003
 requirements: []
+
 rubyforge_project: iso8601
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Ruby parser to work with ISO 8601 dateTimes and durations - http://en.wikipedia.org/wiki/ISO_8601
-test_files:
+test_files: 
 - spec/iso8601/atoms_spec.rb
 - spec/iso8601/dateTime_spec.rb
 - spec/iso8601/date_spec.rb