iso8601 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f6495a0f183eb9f89a063e0404b9001fd024b90d
-  data.tar.gz: c9bedd70b4ecc51ad6c1094a4f714b5d2a17fdcc
+  metadata.gz: a046b00234ecd1ead9531234435f3b28bb1e89d3
+  data.tar.gz: 53e15b12514e255b2a5aaeb451e041047b2d6ef0
 SHA512:
-  metadata.gz: 2dbe7ba46843e37298b2a4766752e74d240546ec6232e9dd1aa0e2449589351d18440ed0bf1b982c39353141d5a91b84b8f031b29697d5f09616bb6eadbfd33d
-  data.tar.gz: ced9dcc8204013b265f69e6c8a2407247386202026c83e19296acd99ec44b06a4811b7785e9becc1cae7a49c8a4005c64c4e4a519f7f06decb8bdfd727991b0f
+  metadata.gz: 4be163f63f8e4d488ecb8d6c997e17031445ab0b124644f8c0b6d33ac60cbc9b9b21f5009ba0a185f8cb08cbc7e4a3de9900c9fdccf3589fd75ea5a6cb8e2d99
+  data.tar.gz: a10fa5e91adbd1717954b81809cdf206e34f676f07f27add1cceb1530d782c7a3df5b5e8052265f10f915578538f3417c8f7890d97fe4bceedf11d2b0061ae22

data/CHANGELOG.md

@@ -1,22 +1,32 @@
-## Changes for 0.7.0
+## 0.8.0
+
+* `DateTime` has hash identity by value.
+* `Time` has hash identity by value.
+* `Date` has hash identity by value.
+* `Duration` has hash identity by value.
+* `Atom` has hash identity by value.
+* `Atom#value` returns either an integer or a float.
+* `Atom#to_s` returns a valid ISO8601 subpattern.
+
+## 0.7.0
 
 * Add decimal fractions for any component in a duration.
 * Add a catch all `ISO8601::Errors::StandardError`.
 * Add support for comma (`,`) as a separator for duration decimal fractions.
 
-## Changes for 0.6.0
+## 0.6.0
 
 * Add `#hash` to `Duration`, `Date`, `Time` and `DateTime`.
 
-## Changes for 0.5.2
+## 0.5.2
 
 * Fix `DateTime` when handling empty strings.
 
-## Changes for 0.5.1
+## 0.5.1
 
 * Fix durations with sign.
 
-## Changes for 0.5
+## 0.5.0
 
 * Drop support for Ruby 1.8.7.
 * Add support for Rubinius 2.

data/README.md

@@ -84,16 +84,16 @@ Week dates raise an error when two digit days provied instead of return monday:
     DateTime.new('2014-W15-02')  # => #<Date: 2014-04-07 ((2456755j,0s,0n),+0s,2299161j)>
 
 
-
-## TODO
-
-* Recurring time intervals
-
-
-## Contributors
+## Contributing
 
 [Contributors](https://github.com/arnau/ISO8601/graphs/contributors)
 
+1. Fork it (http://github.com/arnau/ISO8601/fork)
+2. Create your feature branch (git checkout -b features/xyz)
+3. Commit your changes (git commit -am 'Add XYZ')
+4. Push to the branch (git push origin features/xyz)
+5. Create new Pull Request
+
 
 ## License
 

data/iso8601.gemspec

@@ -25,6 +25,6 @@ Gem::Specification.new do |s|
 
   s.has_rdoc = 'yard'
 
-  s.add_development_dependency 'rspec', '~> 2.14'
+  s.add_development_dependency 'rspec', '~> 3.1'
   s.add_development_dependency 'rerun', '~> 0'
 end

data/lib/iso8601.rb

@@ -8,5 +8,5 @@ require 'iso8601/errors'
 require 'iso8601/atoms'
 require 'iso8601/date'
 require 'iso8601/time'
-require 'iso8601/dateTime'
+require 'iso8601/date_time'
 require 'iso8601/duration'

data/lib/iso8601/atoms.rb

@@ -8,28 +8,75 @@ module ISO8601
   class Atom
     ##
     # @param [Numeric] atom The atom value
-    # @param [ISO8601::DateTime, nil] base (nil) The base datetime to
-    #   compute the atom factor.
+    # @param [ISO8601::DateTime, nil] base (nil) The base datetime to compute
+    #   the atom factor.
     def initialize(atom, base=nil)
-      raise TypeError, "The atom argument for #{self.inspect} should be a Numeric value." unless atom.kind_of? Numeric
-      raise TypeError, "The base argument for #{self.inspect} should be a ISO8601::DateTime instance or nil." unless base.kind_of? ISO8601::DateTime or base.nil?
+      raise TypeError, "The atom argument for #{self.inspect} should be a Numeric value." unless atom.kind_of?(Numeric)
+      raise TypeError, "The base argument for #{self.inspect} should be a ISO8601::DateTime instance or nil." unless base.kind_of?(ISO8601::DateTime) || base.nil?
       @atom = atom
       @base = base
     end
+    attr_reader :atom
+    attr_reader :base
     ##
-    # The integer representation of the atom
+    # The integer representation
+    #
+    # @return [Integer]
     def to_i
-      @atom.to_i
+      atom.to_i
+    end
+    ##
+    # The float representation
+    #
+    # @return [Float]
+    def to_f
+      atom.to_f
     end
     ##
-    # The amount of seconds of the atom
+    # Returns the ISO 8601 representation for the atom
+    #
+    # @return [String]
+    def to_s
+      (value.zero?) ? '' : "#{value}#{symbol}"
+    end
+    ##
+    # The simplest numeric representation. If modulo equals 0 returns an
+    # integer else a float.
+    #
+    # @return [Numeric]
+    def value
+      (atom % 1).zero? ? atom.to_i : atom
+    end
+    ##
+    # The amount of seconds
+    #
+    # @return [Numeric]
     def to_seconds
-      @atom * self.factor
+      atom * factor
+    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
+      [atom, self.class].hash
     end
     ##
     # The atom factor to compute the amount of seconds for the atom
     def factor
-      raise NotImplementedError, "The #factor method should be implemented for each subclass"
+      raise NotImplementedError, "The #factor method should be implemented by each subclass"
     end
   end
   ##
@@ -49,17 +96,26 @@ module ISO8601
     # The “duration year” average is calculated through time intervals of 400
     # “duration years”. Each cycle of 400 “duration years” has 303 “common
     # years” of 365 “calendar days” and 97 “leap years” of 366 “calendar days”.
+    #
+    # @return [Integer]
     def factor
-      if @base.nil?
+      if base.nil?
         ((365 * 303 + 366 * 97) / 400) * 86400
-      elsif @atom == 0
-        year = (@base.year).to_i
-        (::Time.utc(year) - ::Time.utc(@base.year))
+      elsif atom.zero?
+        year = (base.year).to_i
+        (::Time.utc(year) - ::Time.utc(base.year))
       else
-        year = (@base.year + @atom).to_i
-        (::Time.utc(year) - ::Time.utc(@base.year)) / @atom
+        year = (base.year + atom).to_i
+        (::Time.utc(year) - ::Time.utc(base.year)) / atom
       end
     end
+    ##
+    # The atom symbol.
+    #
+    # @return [Symbol]
+    def symbol
+      :Y
+    end
   end
   ##
   # A Months atom in a {ISO8601::Duration}
@@ -78,14 +134,21 @@ module ISO8601
     # “duration years”. Each cycle of 400 “duration years” has 303 “common
     # years” of 365 “calendar days” and 97 “leap years” of 366 “calendar days”.
     def factor
-      if @base.nil?
+      if base.nil?
         nobase_calculation
-      elsif @atom == 0
+      elsif atom.zero?
         zero_calculation
       else
         calculation
       end
     end
+    ##
+    # The atom symbol.
+    #
+    # @return [Symbol]
+    def symbol
+      :M
+    end
 
     private
 
@@ -94,30 +157,30 @@ module ISO8601
     end
 
     def zero_calculation
-      month = (@base.month <= 12) ? (@base.month) : ((@base.month) % 12)
-      year = @base.year + ((@base.month) / 12).to_i
+      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))
+      (::Time.utc(year, month) - ::Time.utc(base.year, base.month))
     end
 
     def calculation
-      if @base.month + @atom <= 0
-        month = @base.month + @atom
+      if base.month + atom <= 0
+        month = base.month + atom
 
         if month % 12 == 0
-          year = @base.year + (month / 12) - 1
+          year = base.year + (month / 12) - 1
           month = 12
         else
-          year = @base.year + (month / 12).floor
+          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
+        month = (base.month + atom <= 12) ? (base.month + atom) : ((base.month + atom) % 12)
+        month = 12 if month.zero?
+        year = base.year + ((base.month + atom) / 12).to_i
       end
 
-      (::Time.utc(year, month) - ::Time.utc(@base.year, @base.month)) / @atom
+      (::Time.utc(year, month) - ::Time.utc(base.year, base.month)) / atom
     end
   end
   ##
@@ -128,6 +191,13 @@ module ISO8601
     def factor
       604800
     end
+    ##
+    # The atom symbol.
+    #
+    # @return [Symbol]
+    def symbol
+      :W
+    end
   end
   ##
   # The Days atom in a {ISO8601::Duration}
@@ -141,6 +211,13 @@ module ISO8601
     def factor
       86400
     end
+    ##
+    # The atom symbol.
+    #
+    # @return [Symbol]
+    def symbol
+      :D
+    end
   end
   ##
   # The Hours atom in a {ISO8601::Duration}
@@ -150,6 +227,13 @@ module ISO8601
     def factor
       3600
     end
+    ##
+    # The atom symbol.
+    #
+    # @return [Symbol]
+    def symbol
+      :H
+    end
   end
   ##
   # The Minutes atom in a {ISO8601::Duration}
@@ -159,6 +243,13 @@ module ISO8601
     def factor
       60
     end
+    ##
+    # The atom symbol.
+    #
+    # @return [Symbol]
+    def symbol
+      :M
+    end
   end
   ##
   # The Seconds atom in a {ISO8601::Duration}
@@ -172,5 +263,12 @@ module ISO8601
     def factor
       1
     end
+    ##
+    # The atom symbol.
+    #
+    # @return [Symbol]
+    def symbol
+      :S
+    end
   end
 end

data/lib/iso8601/date.rb

@@ -1,14 +1,14 @@
 module ISO8601
   ##
-  # A Date representation
+  # A Date representation.
   #
   # @example
-  #     d = Date.new('2014-05-28')
+  #     d = ISO8601::Date.new('2014-05-28')
   #     d.year  # => 2014
   #     d.month # => 5
   #
   # @example Week dates
-  #     d = Date.new('2014-W15-2')
+  #     d = ISO8601::Date.new('2014-W15-2')
   #     d.day   # => 27
   #     d.wday  # => 2
   #     d.week # => 15
@@ -17,7 +17,7 @@ module ISO8601
 
     def_delegators(:@date,
       :to_s, :to_time, :to_date, :to_datetime,
-      :year, :month, :day, :wday, :hash)
+      :year, :month, :day, :wday)
     ##
     # The original atoms
     attr_reader :atoms
@@ -61,6 +61,25 @@ module ISO8601
     def to_a
       [year, month, day]
     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
 
     private
     ##

data/lib/iso8601/{dateTime.rb → date_time.rb}

@@ -12,7 +12,7 @@ module ISO8601
 
     def_delegators(:@date_time,
       :strftime, :to_time, :to_date, :to_datetime,
-      :year, :month, :day, :hour, :minute, :zone, :hash)
+      :year, :month, :day, :hour, :minute, :zone)
 
     attr_reader :second
 
@@ -57,6 +57,26 @@ module ISO8601
     def to_a
       [year, month, day, hour, minute, second, zone]
     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
+      [second, self.class].hash
+    end
+
 
     private
     ##

data/lib/iso8601/duration.rb

@@ -2,111 +2,111 @@
 
 module ISO8601
   ##
-  # Represents a duration in ISO 8601 format
+  # A duration representation. When no base is provided, all atoms use an
+  # average factor which affects the result of any computation like `#to_seconds`.
+  #
+  # @example
+  #     d = ISO8601::Duration.new('P2Y1MT2H')
+  #     d.years  # => #<ISO8601::Years:0x000000051adee8 @atom=2.0, @base=nil>
+  #     d.months # => #<ISO8601::Months:0x00000004f230b0 @atom=1.0, @base=nil>
+  #     d.days   # => #<ISO8601::Days:0x00000005205468 @atom=0, @base=nil>
+  #     d.hours  # => #<ISO8601::Hours:0x000000051e02a8 @atom=2.0, @base=nil>
+  #     d.to_seconds # => 65707200.0
+  #
+  # @example Explicit base date time
+  #     d = ISO8601::Duration.new('P2Y1MT2H', ISO8601::DateTime.new('2014-08017'))
+  #     d.years  # => #<ISO8601::Years:0x000000051adee8 @atom=2.0, @base=#<ISO8601::DateTime...>>
+  #     d.months # => #<ISO8601::Months:0x00000004f230b0 @atom=1.0, @base=#<ISO8601::DateTime...>>
+  #     d.days   # => #<ISO8601::Days:0x00000005205468 @atom=0, @base=#<ISO8601::DateTime...>>
+  #     d.hours  # => #<ISO8601::Hours:0x000000051e02a8 @atom=2.0, @base=#<ISO8601::DateTime...>>
+  #     d.to_seconds # => 65757600.0
+  #
+  # @example Number of seconds versus patterns
+  #     di = ISO8601::Duration.new(65707200)
+  #     dp = ISO8601::Duration.new('P2Y1MT2H')
+  #     ds = ISO8601::Duration.new('P65707200S')
+  #     di == dp # => true
+  #     di == ds # => true
   #
-  # @todo Support fraction values for years, months, days, weeks, hours
-  #   and minutes
   class Duration
-    attr_reader :base, :atoms
     ##
-    # @param [String, Numeric] pattern The duration pattern
+    # @param [String, Numeric] input The duration pattern
     # @param [ISO8601::DateTime, nil] base (nil) The base datetime to
-    #   calculate the duration properly
-    def initialize(pattern, base = nil)
-      # we got seconds instead of an ISO8601 duration
-      pattern = "PT#{pattern}S" if (pattern.kind_of? Numeric)
-      @duration = /^(\+|-)? # Sign
-                   P(
-                      (
-                        (\d+(?:[,.]\d+)?Y)? # Years
-                        (\d+(?:[.,]\d+)?M)? # Months
-                        (\d+(?:[.,]\d+)?D)? # Days
-                        (T
-                          (\d+(?:[.,]\d+)?H)? # Hours
-                          (\d+(?:[.,]\d+)?M)? # Minutes
-                          (\d+(?:[.,]\d+)?S)? # Seconds
-                        )? # Time
-                      )
-                      |(\d+(?:[.,]\d+)?W) # Weeks
-                    ) # Duration
-                  $/x.match(pattern) or raise ISO8601::Errors::UnknownPattern.new(pattern)
-
-      @base = base
-      valid_pattern?
-      valid_base?
-      @atoms = {
-        :years => @duration[4].nil? ? 0 : @duration[4].chop.to_f * sign,
-        :months => @duration[5].nil? ? 0 : @duration[5].chop.to_f * sign,
-        :weeks => @duration[11].nil? ? 0 : @duration[11].chop.to_f * sign,
-        :days => @duration[6].nil? ? 0 : @duration[6].chop.to_f * sign,
-        :hours => @duration[8].nil? ? 0 : @duration[8].chop.to_f * sign,
-        :minutes => @duration[9].nil? ? 0 : @duration[9].chop.to_f * sign,
-        :seconds => @duration[10].nil? ? 0 : @duration[10].chop.to_f * sign
-      }
-      valid_fractions?
+    #   calculate the duration against an specific point in time.
+    def initialize(input, base = nil)
+      @original = input
+      @pattern = to_pattern
+      @atoms = atomize(@pattern)
+      @base = validate_base(base)
     end
     ##
+    # Raw atoms result of parsing the given pattern.
+    #
+    # @return [Hash<Float>]
+    attr_reader :atoms
+    ##
+    # Datetime base.
+    #
+    # @return [ISO8601::DateTime, nil]
+    attr_reader :base
+    ##
     # Assigns a new base datetime
     #
     # @return [ISO8601::DateTime, nil]
     def base=(value)
-      @base = value
-      valid_base?
-      return @base
+      @base = validate_base(value)
+      @base
     end
     ##
     # @return [String] The string representation of the duration
-    def to_s
-      @duration[0]
-    end
+    attr_reader :pattern
+    alias_method :to_s, :pattern
     ##
     # @return [ISO8601::Years] The years of the duration
     def years
-      ISO8601::Years.new(@atoms[:years], @base)
+      ISO8601::Years.new(atoms[:years], base)
     end
     ##
     # @return [ISO8601::Months] The months of the duration
     def months
       # Changes the base to compute the months for the right base year
-      base = @base.nil? ? nil : @base + self.years.to_seconds
-      ISO8601::Months.new(@atoms[:months], base)
+      month_base = base.nil? ? nil : base + years.to_seconds
+      ISO8601::Months.new(atoms[:months], month_base)
     end
     ##
     # @return [ISO8601::Weeks] The weeks of the duration
     def weeks
-      ISO8601::Weeks.new(@atoms[:weeks], @base)
+      ISO8601::Weeks.new(atoms[:weeks], base)
     end
     ##
     # @return [ISO8601::Days] The days of the duration
     def days
-      ISO8601::Days.new(@atoms[:days], @base)
+      ISO8601::Days.new(atoms[:days], base)
     end
     ##
     # @return [ISO8601::Hours] The hours of the duration
     def hours
-      ISO8601::Hours.new(@atoms[:hours], @base)
+      ISO8601::Hours.new(atoms[:hours], base)
     end
     ##
     # @return [ISO8601::Minutes] The minutes of the duration
     def minutes
-      ISO8601::Minutes.new(@atoms[:minutes], @base)
+      ISO8601::Minutes.new(atoms[:minutes], base)
     end
     ##
     # @return [ISO8601::Seconds] The seconds of the duration
     def seconds
-      ISO8601::Seconds.new(@atoms[:seconds], @base)
+      ISO8601::Seconds.new(atoms[:seconds], base)
     end
     ##
-    # @return [Numeric] The duration in seconds
-    def to_seconds
-      years, months, weeks, days, hours, minutes, seconds = self.years.to_seconds, self.months.to_seconds, self.weeks.to_seconds, self.days.to_seconds, self.hours.to_seconds, self.minutes.to_seconds, self.seconds.to_seconds
-      return years + months + weeks + days + hours + minutes + seconds
-    end
+    # The Integer representation of the duration sign.
+    #
+    # @return [Integer]
+    attr_reader :sign
     ##
     # @return [ISO8601::Duration] The absolute representation of the duration
     def abs
-      absolute = self.to_s.sub(/^[-+]/, '')
-      return ISO8601::Duration.new(absolute)
+      self.class.new(pattern.sub(/^[-+]/, ''), base)
     end
     ##
     # Addition
@@ -116,10 +116,12 @@ module ISO8601
     # @raise [ISO8601::Errors::DurationBaseError] If bases doesn't match
     # @return [ISO8601::Duration]
     def +(duration)
-      raise ISO8601::Errors::DurationBaseError.new(duration) if @base.to_s != duration.base.to_s
+      compare_bases(duration)
+
       d1 = to_seconds
       d2 = duration.to_seconds
-      return seconds_to_iso(d1 + d2)
+
+      seconds_to_iso(d1 + d2)
     end
     ##
     # Substraction
@@ -129,15 +131,12 @@ module ISO8601
     # @raise [ISO8601::Errors::DurationBaseError] If bases doesn't match
     # @return [ISO8601::Duration]
     def -(duration)
-      raise ISO8601::Errors::DurationBaseError.new(duration) if @base.to_s != duration.base.to_s
+      compare_bases(duration)
+
       d1 = to_seconds
       d2 = duration.to_seconds
-      duration = d1 - d2
-      if duration == 0
-        return ISO8601::Duration.new('PT0S')
-      else
-        return seconds_to_iso(duration)
-      end
+
+      seconds_to_iso(d1 - d2)
     end
     ##
     # @param [ISO8601::Duration] duration The duration to compare
@@ -145,67 +144,145 @@ module ISO8601
     # @raise [ISO8601::Errors::DurationBaseError] If bases doesn't match
     # @return [Boolean]
     def ==(duration)
-      raise ISO8601::Errors::DurationBaseError.new(duration) if @base.to_s != duration.base.to_s
-      (self.to_seconds == duration.to_seconds)
+      compare_bases(duration)
+
+      (to_seconds == duration.to_seconds)
+    end
+    ##
+    # @param [ISO8601::Duration] duration The duration to compare
+    #
+    # @return [Boolean]
+    def eql?(duration)
+      (hash == duration.hash)
     end
     ##
     # @return [Fixnum]
     def hash
-      @atoms.hash
+      [atoms.values, self.class].hash
+    end
+    ##
+    # Converts original input into  a valid ISO 8601 duration pattern.
+    #
+    # @return [String]
+    def to_pattern
+      (@original.kind_of? Numeric) ? "PT#{@original}S" : @original
+    end
+    ##
+    # @return [Numeric] The duration in seconds
+    def to_seconds
+      [years, months, weeks, days, hours, minutes, seconds].map(&:to_seconds).reduce(&:+)
     end
 
 
     private
     ##
-    # @param [Numeric] duration The seconds to promote
+    # Splits a duration pattern into valid atoms.
+    #
+    # Acceptable patterns:
+    #
+    # * PnYnMnD
+    # * PTnHnMnS
+    # * PnYnMnDTnHnMnS
+    # * PnW
+    #
+    # Where `n` is any number. If it contains a decimal fraction, a dot (`.`) or
+    # comma (`,`) can be used.
+    #
+    # @param [String] input
+    #
+    # @return [Hash<Float>]
+    def atomize(input)
+      duration = input.match(/^
+        (?<sign>\+|-)?
+        P(?:
+          (?:
+            (?:(?<years>\d+(?:[,.]\d+)?)Y)?
+            (?:(?<months>\d+(?:[.,]\d+)?)M)?
+            (?:(?<days>\d+(?:[.,]\d+)?)D)?
+            (?<time>T
+              (?:(?<hours>\d+(?:[.,]\d+)?)H)?
+              (?:(?<minutes>\d+(?:[.,]\d+)?)M)?
+              (?:(?<seconds>\d+(?:[.,]\d+)?)S)?
+            )?
+          ) |
+          (?<weeks>\d+(?:[.,]\d+)?W)
+        ) # Duration
+      $/x) or raise ISO8601::Errors::UnknownPattern.new(input)
+
+      valid_pattern?(duration)
+
+      @sign = (duration[:sign].nil? || duration[:sign] == '+') ? 1 : -1
+
+      keys = duration.names.map(&:to_sym)
+      values = duration.captures.map { |v| v.to_f * sign }
+      components = Hash[keys.zip(values)]
+      components.delete(:time) # clean time capture
+
+      valid_fractions?(components.values)
+
+      components
+    end
+    ##
+    # @param [Numeric] value The seconds to promote
     #
     # @return [ISO8601::Duration]
-    def seconds_to_iso(duration)
-      sign = '-' if (duration < 0)
-      duration = duration.abs
-      years, y_mod = (duration / self.years.factor).to_i, (duration % self.years.factor)
-      months, m_mod = (y_mod / self.months.factor).to_i, (y_mod % self.months.factor)
-      days, d_mod = (m_mod / self.days.factor).to_i, (m_mod % self.days.factor)
-      hours, h_mod = (d_mod / self.hours.factor).to_i, (d_mod % self.hours.factor)
-      minutes, mi_mod = (h_mod / self.minutes.factor).to_i, (h_mod % self.minutes.factor)
-      seconds = mi_mod.div(1) == mi_mod ? mi_mod.to_i : mi_mod.to_f # Coerce to Integer when needed (`PT1S` instead of `PT1.0S`)
-
-      seconds = (seconds != 0 or (years == 0 and months == 0 and days == 0 and hours == 0 and minutes == 0)) ? "#{seconds}S" : ""
-      minutes = (minutes != 0) ? "#{minutes}M" : ""
-      hours = (hours != 0) ? "#{hours}H" : ""
-      days = (days != 0) ? "#{days}D" : ""
-      months = (months != 0) ? "#{months}M" : ""
-      years = (years != 0) ? "#{years}Y" : ""
-
-      date = %[#{sign}P#{years}#{months}#{days}]
-      time = (hours != "" or minutes != "" or seconds != "") ? %[T#{hours}#{minutes}#{seconds}] : ""
-      date_time = date + time
-      return ISO8601::Duration.new(date_time)
-    end
-
-    def sign
-      (@duration[1].nil? or @duration[1] == "+") ? 1 : -1
-    end
-    def valid_base?
-      if !(@base.nil? or @base.kind_of? ISO8601::DateTime)
-        raise TypeError
-      end
+    def seconds_to_iso(value)
+      return self.class.new('PT0S') if value.zero?
+
+      sign_str = (value < 0) ? '-' : ''
+      value = value.abs
+
+      y, y_mod = decompose_atom(value, years)
+      m, m_mod = decompose_atom(y_mod, months)
+      d, d_mod = decompose_atom(m_mod, days)
+      h, h_mod = decompose_atom(d_mod, hours)
+      mi, mi_mod = decompose_atom(h_mod, minutes)
+      s = Seconds.new(mi_mod)
+
+      date = to_date_s(sign_str, y, m, d)
+      time = to_time_s(h, mi, s)
+
+      self.class.new(date + time)
+    end
+
+    def decompose_atom(value, atom)
+      [atom.class.new((value / atom.factor).to_i), (value % atom.factor)]
+    end
+
+    def to_date_s(sign, *args)
+      "#{sign}P#{args.map(&:to_s).join('')}"
     end
-    def valid_pattern?
-      if @duration.nil? or
-         (@duration[4].nil? and @duration[5].nil? and @duration[6].nil? and @duration[7].nil? and @duration[11].nil?) or
-         (!@duration[7].nil? and @duration[8].nil? and @duration[9].nil? and @duration[10].nil? and @duration[11].nil?)
 
-        raise ISO8601::Errors::UnknownPattern.new(@duration)
+    def to_time_s(*args)
+      (args.map(&:value).reduce(&:+) > 0) ? "T#{args.map(&:to_s).join('')}" : ''
+    end
+
+    def validate_base(input)
+      raise ISO8601::Errors::TypeError if !(input.nil? or input.kind_of? ISO8601::DateTime)
+
+      input
+    end
+    def valid_pattern?(components)
+      date = [components[:years], components[:months], components[:days]].compact
+      time = [components[:hours], components[:minutes], components[:seconds]].compact
+      weeks = components[:weeks]
+      all = [date, time, weeks].flatten.compact
+
+      if all.empty? || (!components[:time].nil? && time.empty? && weeks.nil?)
+        raise ISO8601::Errors::UnknownPattern.new(@pattern)
       end
     end
 
-    def valid_fractions?
-      values = @atoms.values.reject(&:zero?)
+    def valid_fractions?(values)
+      values = values.reject(&:zero?)
       fractions = values.select { |a| (a % 1) != 0 }
       if fractions.size > 1 || (fractions.size == 1 && fractions.last != values.last)
-        raise ISO8601::Errors::InvalidFractions.new(@duration)
+        raise ISO8601::Errors::InvalidFractions.new(@pattern)
       end
     end
+
+    def compare_bases(duration)
+      raise ISO8601::Errors::DurationBaseError.new(duration) if base.to_s != duration.base.to_s
+    end
   end
 end