iso8601 0.8.7 → 0.9.0

data/iso8601.gemspec

@@ -18,13 +18,50 @@ Gem::Specification.new do |s|
   EOD
   s.license = 'MIT'
   s.rubyforge_project = 'iso8601'
-
-  s.files = `git ls-files`.split("\n")
-  s.test_files = s.files.grep(%r{^(spec|features)/})
+  s.files = %W(CHANGELOG.md
+               CONTRIBUTING.md
+               Gemfile
+               LICENSE
+               README.md
+               Rakefile
+               iso8601.gemspec
+               docs/date-time.md
+               docs/duration.md
+               docs/time-interval.md
+               lib/iso8601.rb
+               lib/iso8601/atomic.rb
+               lib/iso8601/date.rb
+               lib/iso8601/date_time.rb
+               lib/iso8601/days.rb
+               lib/iso8601/duration.rb
+               lib/iso8601/errors.rb
+               lib/iso8601/hours.rb
+               lib/iso8601/minutes.rb
+               lib/iso8601/months.rb
+               lib/iso8601/seconds.rb
+               lib/iso8601/time.rb
+               lib/iso8601/time_interval.rb
+               lib/iso8601/version.rb
+               lib/iso8601/weeks.rb
+               lib/iso8601/years.rb
+               spec/iso8601/date_spec.rb
+               spec/iso8601/date_time_spec.rb
+               spec/iso8601/days_spec.rb
+               spec/iso8601/duration_spec.rb
+               spec/iso8601/hours_spec.rb
+               spec/iso8601/minutes_spec.rb
+               spec/iso8601/months_spec.rb
+               spec/iso8601/seconds_spec.rb
+               spec/iso8601/time_interval_spec.rb
+               spec/iso8601/time_spec.rb
+               spec/iso8601/weeks_spec.rb
+               spec/iso8601/years_spec.rb
+               spec/spec_helper.rb)
+  s.test_files = s.files.grep(%r{^spec/})
   s.require_paths = ['lib']
 
   s.has_rdoc = 'yard'
-  s.required_ruby_version = '>= 1.9.3'
-  s.add_development_dependency 'rspec', '~> 3.1'
-  s.add_development_dependency 'rubocop', '~> 0.26'
+  s.required_ruby_version = '>= 2.0.0'
+  s.add_development_dependency 'rspec', '~> 3.4'
+  s.add_development_dependency 'rubocop', '~> 0.35'
 end

data/lib/iso8601.rb

@@ -3,10 +3,18 @@
 require 'time'
 require 'forwardable'
 
-require 'iso8601/version'
-require 'iso8601/errors'
-require 'iso8601/atoms'
-require 'iso8601/date'
-require 'iso8601/time'
-require 'iso8601/date_time'
-require 'iso8601/duration'
+require_relative 'iso8601/version'
+require_relative 'iso8601/errors'
+require_relative 'iso8601/atomic'
+require_relative 'iso8601/years'
+require_relative 'iso8601/months'
+require_relative 'iso8601/weeks'
+require_relative 'iso8601/days'
+require_relative 'iso8601/hours'
+require_relative 'iso8601/minutes'
+require_relative 'iso8601/seconds'
+require_relative 'iso8601/date'
+require_relative 'iso8601/time'
+require_relative 'iso8601/date_time'
+require_relative 'iso8601/duration'
+require_relative 'iso8601/time_interval'

data/lib/iso8601/atomic.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+module ISO8601
+  module Atomic
+    include Comparable
+
+    attr_reader :atom
+
+    ##
+    # The integer representation
+    #
+    # @return [Integer]
+    def to_i
+      atom.to_i
+    end
+
+    ##
+    # The float representation
+    #
+    # @return [Float]
+    def to_f
+      atom.to_f
+    end
+
+    ##
+    # 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
+
+    ##
+    # @param [Atom] other The contrast to compare against
+    #
+    # @return [-1, 0, 1]
+    def <=>(other)
+      return nil unless other.is_a?(self.class)
+
+      to_f <=> other.to_f
+    end
+
+    ##
+    # @param [#hash] other The contrast to compare against
+    #
+    # @return [Boolean]
+    def eql?(other)
+      (hash == other.hash)
+    end
+
+    ##
+    # @return [Fixnum]
+    def hash
+      [atom, self.class].hash
+    end
+
+    ##
+    # Validates the atom is a Numeric
+    def valid_atom?(atom)
+      fail ISO8601::Errors::TypeError,
+           "The atom argument for #{self.class} should be a Numeric value." unless atom.is_a?(Numeric)
+    end
+
+    def valid_base?(base)
+      fail ISO8601::Errors::TypeError,
+           "The base argument for #{self.class} should be a ISO8601::DateTime instance or nil." unless base.is_a?(ISO8601::DateTime) || base.nil?
+    end
+  end
+end

data/lib/iso8601/date.rb

@@ -20,12 +20,15 @@ module ISO8601
       :to_s, :to_time, :to_date, :to_datetime,
       :year, :month, :day, :wday
     )
+
     ##
     # The original atoms
     attr_reader :atoms
+
     ##
     # The separator used in the original ISO 8601 string.
     attr_reader :separator
+
     ##
     # @param [String] input The date pattern
     def initialize(input)
@@ -33,6 +36,7 @@ module ISO8601
       @atoms = atomize(input)
       @date = compose(@atoms)
     end
+
     ##
     # The calendar week number (1-53)
     #
@@ -40,6 +44,7 @@ module ISO8601
     def week
       @date.cweek
     end
+
     ##
     # Forwards the date the given amount of days.
     #
@@ -50,6 +55,7 @@ module ISO8601
       other = other.to_days if other.respond_to?(:to_days)
       ISO8601::Date.new((@date + other).iso8601)
     end
+
     ##
     # Backwards the date the given amount of days.
     #
@@ -60,11 +66,13 @@ module ISO8601
       other = other.to_days if other.respond_to?(:to_days)
       ISO8601::Date.new((@date - other).iso8601)
     end
+
     ##
     # Converts self to an array of atoms.
     def to_a
       [year, month, day]
     end
+
     ##
     # @param [#hash] other The contrast to compare against
     #
@@ -72,6 +80,7 @@ module ISO8601
     def ==(other)
       (hash == other.hash)
     end
+
     ##
     # @param [#hash] other The contrast to compare against
     #
@@ -79,6 +88,7 @@ module ISO8601
     def eql?(other)
       (hash == other.hash)
     end
+
     ##
     # @return [Fixnum]
     def hash
@@ -103,14 +113,31 @@ module ISO8601
     #
     # @return [Array<Integer>]
     def atomize(input)
-      week_date = /^([+-]?)\d{4}(-?)W\d{2}(?:\2\d)?$/.match(input)
+      week_date = parse_weekdate(input)
       return atomize_week_date(input, week_date[2], week_date[1]) unless week_date.nil?
 
-      ordinal_regexp = /^([+-]?)(\d{4})(-?)(\d{3})$/
-      _, sign, year, separator, day = ordinal_regexp.match(input).to_a.compact
+      _, sign, year, separator, day = parse_ordinal(input)
       return atomize_ordinal(year, day, separator, sign) unless year.nil?
 
-      _, year, separator, month, day = /^
+      _, year, separator, month, day = parse_date(input)
+
+      fail ISO8601::Errors::UnknownPattern, @original if year.nil?
+
+      @separator = separator
+
+      [year, month, day].compact.map(&:to_i)
+    end
+
+    def parse_weekdate(input)
+      /^([+-]?)\d{4}(-?)W\d{2}(?:\2\d)?$/.match(input)
+    end
+
+    def parse_ordinal(input)
+      /^([+-]?)(\d{4})(-?)(\d{3})$/.match(input).to_a.compact
+    end
+
+    def parse_date(input)
+      /^
         ([+-]?\d{4})   # YYYY
         (?:
           (-?)(\d{2})  # YYYY-MM
@@ -119,13 +146,8 @@ module ISO8601
           )?
         )?
       $/x.match(input).to_a.compact
-
-      fail ISO8601::Errors::UnknownPattern, @original if year.nil?
-
-      @separator = separator
-
-      [year, month, day].compact.map(&:to_i)
     end
+
     ##
     # Parses a week date (YYYY-Www-D, YYYY-Www) and returns its atoms.
     #
@@ -141,6 +163,7 @@ module ISO8601
 
       [sign * date.year, date.month, date.day]
     end
+
     ##
     # Parses an ordinal date (YYYY-DDD) and returns its atoms.
     #
@@ -157,6 +180,7 @@ module ISO8601
 
       [sign * date.year, date.month, date.day]
     end
+
     ##
     # Wraps ::Date.parse to play nice with ArgumentError.
     #
@@ -168,6 +192,7 @@ module ISO8601
     rescue ArgumentError
       raise ISO8601::Errors::RangeError, @original
     end
+
     ##
     # Wraps ::Date.new to play nice with ArgumentError.
     #

data/lib/iso8601/date_time.rb

@@ -25,6 +25,7 @@ module ISO8601
       @date_time = parse(date_time)
       @second = @date_time.second + @date_time.second_fraction.to_f.round(1)
     end
+
     ##
     # Addition
     #
@@ -34,6 +35,7 @@ module ISO8601
 
       self.class.new(moment.strftime('%Y-%m-%dT%H:%M:%S.%N%:z'))
     end
+
     ##
     # Substraction
     #
@@ -43,24 +45,28 @@ module ISO8601
 
       self.class.new(moment.strftime('%Y-%m-%dT%H:%M:%S.%N%:z'))
     end
+
     ##
     # Converts DateTime to a formated string
     def to_s
-      second_format = (second % 1).zero? ? '%02d' % second : '%04.1f' % second
+      second_format = format((second % 1).zero? ? '%02d' : '%04.1f', second)
 
-      "%04d-%02d-%02dT%02d:%02d:#{second_format}#{zone}" % atoms
+      format("%04d-%02d-%02dT%02d:%02d:#{second_format}#{zone}", *atoms)
     end
+
     ##
     # Converts DateTime to an array of atoms.
     def to_a
       [year, month, day, hour, minute, second, zone]
     end
     alias_method :atoms, :to_a
+
     ##
     # Converts DateTime to a floating point number of seconds since the Epoch.
     def to_f
       to_time.to_f
     end
+
     ##
     # @param [#hash] other The contrast to compare against
     #
@@ -68,6 +74,7 @@ module ISO8601
     def ==(other)
       (hash == other.hash)
     end
+
     ##
     # @param [#hash] other The contrast to compare against
     #
@@ -75,6 +82,7 @@ module ISO8601
     def eql?(other)
       (hash == other.hash)
     end
+
     ##
     # @return [Fixnum]
     def hash
@@ -106,6 +114,7 @@ module ISO8601
 
       ::DateTime.new(*(date_atoms + time_atoms).compact)
     end
+
     ##
     # Validates the date has the right pattern.
     #
@@ -122,6 +131,7 @@ module ISO8601
 
       date.atoms << date.separator
     end
+
     ##
     # @return [Array<String, nil>]
     def parse_time(input)
@@ -141,11 +151,12 @@ module ISO8601
 
       true
     end
+
     ##
     # If time is provided date must use a complete representation
     def valid_representation?(date, time)
       year, month, day = date
-      hour, _ = time
+      hour = time.first
 
       date.nil? || !(!year.nil? && (month.nil? || day.nil?) && !hour.nil?)
     end

data/lib/iso8601/days.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module ISO8601
+  ##
+  # The Days atom in a {ISO8601::Duration}
+  #
+  # A "calendar day" is the time interval which starts at a certain time of day
+  # at a certain "calendar day" and ends at the same time of day at the next
+  # "calendar day".
+  class Days
+    include Atomic
+
+    AVERAGE_FACTOR = 86400
+
+    ##
+    # @param [Numeric] atom The atom value
+    def initialize(atom)
+      valid_atom?(atom)
+
+      @atom = atom
+    end
+
+    ##
+    # The Day factor
+    #
+    # @return [Numeric]
+    def factor
+      AVERAGE_FACTOR
+    end
+
+    ##
+    # The amount of seconds
+    #
+    # @return [Numeric]
+    def to_seconds
+      AVERAGE_FACTOR * atom
+    end
+
+    ##
+    # The atom symbol.
+    #
+    # @return [Symbol]
+    def symbol
+      :D
+    end
+  end
+end

data/lib/iso8601/duration.rb

@@ -3,148 +3,129 @@
 module ISO8601
   ##
   # A duration representation. When no base is provided, all atoms use an
-  # average factor which affects the result of any computation like
-  # `#to_seconds`.
+  # average factor to compute the amount of 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.years  # => #<ISO8601::Years:0x000000051adee8 @atom=2.0>
+  #     d.months # => #<ISO8601::Months:0x00000004f230b0 @atom=1.0>
+  #     d.days   # => #<ISO8601::Days:0x00000005205468 @atom=0>
+  #     d.hours  # => #<ISO8601::Hours:0x000000051e02a8 @atom=2.0>
   #     d.to_seconds # => 65707200.0
   #
   # @example Explicit base date time
   #     base = ISO8601::DateTime.new('2014-08017')
-  #     d = ISO8601::Duration.new('P2Y1MT2H', base)
-  #     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
+  #     d.to_seconds(base) # => 65757600.0
   #
   # @example Number of seconds versus patterns
   #     di = ISO8601::Duration.new(65707200)
-  #     dp = ISO8601::Duration.new('P2Y1MT2H')
   #     ds = ISO8601::Duration.new('P65707200S')
+  #     dp = ISO8601::Duration.new('P2Y1MT2H')
   #     di == dp # => true
   #     di == ds # => true
   #
   class Duration
     ##
     # @param [String, Numeric] input The duration pattern
-    # @param [ISO8601::DateTime, nil] base (nil) The base datetime to
-    #   calculate the duration against an specific point in time.
-    def initialize(input, base = nil)
+    def initialize(input)
       @original = input
-      @pattern = to_pattern
+      @pattern = to_pattern(input)
       @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 = validate_base(value)
-      @base
-    end
+
     ##
     # @return [String] The string representation of the duration
     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])
     end
+
     ##
     # @return [ISO8601::Months] The months of the duration
     def months
-      # Changes the base to compute the months for the right base year
-      month_base = base.nil? ? nil : base + years.to_seconds
-      ISO8601::Months.new(atoms[:months], month_base)
+      ISO8601::Months.new(atoms[:months])
     end
+
     ##
     # @return [ISO8601::Weeks] The weeks of the duration
     def weeks
-      ISO8601::Weeks.new(atoms[:weeks], base)
+      ISO8601::Weeks.new(atoms[:weeks])
     end
+
     ##
     # @return [ISO8601::Days] The days of the duration
     def days
-      ISO8601::Days.new(atoms[:days], base)
+      ISO8601::Days.new(atoms[:days])
     end
+
     ##
     # @return [ISO8601::Hours] The hours of the duration
     def hours
-      ISO8601::Hours.new(atoms[:hours], base)
+      ISO8601::Hours.new(atoms[:hours])
     end
+
     ##
     # @return [ISO8601::Minutes] The minutes of the duration
     def minutes
-      ISO8601::Minutes.new(atoms[:minutes], base)
+      ISO8601::Minutes.new(atoms[:minutes])
     end
+
     ##
     # @return [ISO8601::Seconds] The seconds of the duration
     def seconds
-      ISO8601::Seconds.new(atoms[:seconds], base)
+      ISO8601::Seconds.new(atoms[: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
-      self.class.new(pattern.sub(/^[-+]/, ''), base)
+      self.class.new(pattern.sub(/^[-+]/, ''))
     end
+
     ##
     # Addition
     #
     # @param [ISO8601::Duration] other The duration to add
     #
-    # @raise [ISO8601::Errors::DurationBaseError] If bases doesn't match
     # @return [ISO8601::Duration]
     def +(other)
-      compare_bases(other)
-      seconds_to_iso(to_seconds + other.to_seconds)
+      seconds_to_iso(to_seconds + fetch_seconds(other))
     end
+
     ##
     # Substraction
     #
     # @param [ISO8601::Duration] other The duration to substract
     #
-    # @raise [ISO8601::Errors::DurationBaseError] If bases doesn't match
     # @return [ISO8601::Duration]
     def -(other)
-      compare_bases(other)
-      seconds_to_iso(to_seconds - other.to_seconds)
+      seconds_to_iso(to_seconds - fetch_seconds(other))
     end
+
     ##
     # @param [ISO8601::Duration] other The duration to compare
     #
-    # @raise [ISO8601::Errors::DurationBaseError] If bases doesn't match
     # @return [Boolean]
     def ==(other)
-      compare_bases(other)
-      (to_seconds == other.to_seconds)
+      (to_seconds == fetch_seconds(other))
     end
+
     ##
     # @param [ISO8601::Duration] other The duration to compare
     #
@@ -152,42 +133,40 @@ module ISO8601
     def eql?(other)
       (hash == other.hash)
     end
+
     ##
     # @return [Fixnum]
     def hash
       [atoms.values, self.class].hash
     end
+
     ##
     # Converts original input into  a valid ISO 8601 duration pattern.
     #
     # @return [String]
-    def to_pattern
-      (@original.is_a? Numeric) ? "PT#{@original}S" : @original
+    def to_pattern(original)
+      (original.is_a? Numeric) ? "PT#{original}S" : original
     end
+
     ##
+    # @param [ISO8601::DateTime, nil] base (nil) The base datetime to
+    #   calculate the duration against an specific point in time.
+    #
     # @return [Numeric] The duration in seconds
-    def to_seconds
-      atoms = [years, months, weeks, days, hours, minutes, seconds]
-      atoms.map(&:to_seconds).reduce(&:+)
-    end
-    ##
-    # @return [Numeric] The duration in days
-    def to_days
-      (to_seconds / 86400)
-    end
-    ##
-    # @return [Integer] The integer part of the duration in seconds
-    def to_i
-      to_seconds.to_i
-    end
-    ##
-    # @return [Float] The duration in seconds coerced to float
-    def to_f
-      to_seconds.to_f
+    def to_seconds(base = nil)
+      rest = [weeks, days, hours, minutes, seconds].map(&:to_seconds)
+
+      years.to_seconds(base) + months_to_seconds(base) + rest.reduce(&:+)
     end
 
     private
 
+    # Changes the base to compute the months for the right base year
+    def months_to_seconds(base)
+      month_base = base.nil? ? nil : base + years.to_seconds(base)
+      months.to_seconds(month_base)
+    end
+
     ##
     # Splits a duration pattern into valid atoms.
     #
@@ -205,7 +184,35 @@ module ISO8601
     #
     # @return [Hash<Float>]
     def atomize(input)
-      duration = input.match(/^
+      duration = parse(input) || fail(ISO8601::Errors::UnknownPattern, input)
+
+      valid_pattern?(duration)
+
+      @sign = sign_to_i(duration[:sign])
+
+      components = parse_tokens(duration)
+      components.delete(:time) # clean time capture
+
+      valid_fractions?(components.values)
+
+      components
+    end
+
+    def parse_tokens(tokens)
+      components = tokens.names.zip(tokens.captures).map! do |k, v|
+        value = v.nil? ? v : v.tr(',', '.')
+        [k.to_sym, sign * value.to_f]
+      end
+
+      Hash[components]
+    end
+
+    def sign_to_i(sign)
+      (sign == '-') ? -1 : 1
+    end
+
+    def parse(input)
+      input.match(/^
         (?<sign>\+|-)?
         P(?:
           (?:
@@ -220,23 +227,9 @@ module ISO8601
           ) |
           (?<weeks>\d+(?:[.,]\d+)?W)
         ) # Duration
-      $/x) || fail(ISO8601::Errors::UnknownPattern, input)
-
-      valid_pattern?(duration)
-
-      @sign = (duration[:sign] == '-') ? -1 : 1
-
-      components = duration.names.zip(duration.captures).map! do |k, v|
-        value = v.nil? ? v : v.tr(',', '.')
-        [k.to_sym, sign * value.to_f]
-      end
-      components = Hash[components]
-      components.delete(:time) # clean time capture
-
-      valid_fractions?(components.values)
-
-      components
+      $/x)
     end
+
     ##
     # @param [Numeric] value The seconds to promote
     #
@@ -279,18 +272,20 @@ module ISO8601
     end
 
     def valid_pattern?(components)
-      date = [
-        components[:years], components[:months], components[:days]
-      ]
-      time = [
-        components[:hours], components[:minutes], components[:seconds]
-      ].compact
+      date = [components[:years],
+              components[:months],
+              components[:days]]
+      time = [components[:hours],
+              components[:minutes],
+              components[:seconds]].compact
       weeks = components[:weeks]
       all = [date, time, weeks].flatten.compact
 
       missing_time = (weeks.nil? && !components[:time].nil? && time.empty?)
       empty = missing_time || all.empty?
-      fail ISO8601::Errors::UnknownPattern, @pattern if empty
+
+      fail ISO8601::Errors::UnknownPattern,
+           @pattern if empty
     end
 
     def valid_fractions?(values)
@@ -301,8 +296,29 @@ module ISO8601
       fail ISO8601::Errors::InvalidFractions if fractions.size > 1 || consistent
     end
 
-    def compare_bases(other)
+    def compare_bases(other, base)
       fail ISO8601::Errors::DurationBaseError, other if base != other.base
     end
+
+    ##
+    # Fetch the number of seconds of another element.
+    #
+    # @param [ISO8601::Duration, Numeric] other Instance of a class to fetch
+    #   seconds.
+    #
+    # @raise [ISO8601::Errors::TypeError] If other param is not an instance of
+    #   ISO8601::Duration or Numeric classes
+    #
+    # @return [Float] Number of seconds of other param Object
+    def fetch_seconds(other, base = nil)
+      case other
+      when ISO8601::Duration
+        other.to_seconds(base)
+      when Numeric
+        other.to_f
+      else
+        fail(ISO8601::Errors::TypeError, other)
+      end
+    end
   end
 end