iso8601 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7914ac8d5219dd6b3fe4628c4d7ad8f152e8e2c6
-  data.tar.gz: 2cbee2da317086254dc93762a8513d20b7e68c0e
+SHA256:
+  metadata.gz: 3c7b4ba1e602e306fa8bc033780f6a4f239aa2d592b4721f78e17dfc20bf61bc
+  data.tar.gz: e7eeec472d8ed97d6ca44790b633c5ce881c26ae7363db7d6f786b7c8032b6e1
 SHA512:
-  metadata.gz: 6a32d6585c8d0a226317237e2741ba15a7bc156a727ce4e73c04d04bcc85f987bfb1f6f6a29b40508de57ee4dbe96ad6b036306449479a3c19a4ba947cf2d88e
-  data.tar.gz: fb5653793de6ec27dc4ef8acef0364ad9744fc3770cf0606f4071b07cd4057afb3aa41c9d478bf588527cbda0bde82dddc7a2d072885678680becac6b537a339
+  metadata.gz: 6a2c878595f95c960deb2c70ea2a27adf74930545518147d3d0364ef23874a4efb54c5b6f640ef4df463994eed013afb78b3d7002b7796ef588873f966907cb6
+  data.tar.gz: ea64e2bb8a9bebb77f8ad5d4611db9c72904e815abfd8047843b0dee1c5f4c6b9e95d081c23738f4098c80229774f707c598e61437e698c8f5b93f5d1448c9d1

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.10.0
+
+* Fix `TimeInterval` with `<duration>/<end>` patterns and leap years.
+* Fix decimal fractions on date atoms. **WARNING** some duration patterns are
+  no longer valid.
+
 ## 0.9.1
 
 * Fix `Duration#to_pattern` for negative durations based on a `Numeric` (thanks @figwit).

data/CONTRIBUTING.md

@@ -26,10 +26,9 @@ bundle install
 Add your code and tests and check it passes:
 
 ```sh
-make test  # mri, rbx, jruby
+make test  # mri, jruby
 # or
 make mri-test
-make rbx-test
 make jruby-test
 ```
 

data/README.md

@@ -1,4 +1,4 @@
-# ISO8601
+u ISO8601
 
 Version 0.9.0 is **not compatible** with previous versions.  Atoms and Durations
 changed their interface when treating base dates so it is only applied when
@@ -24,7 +24,6 @@ times) standard.
 ## Supported versions
 
 * MRI 2.x
-* RBX 2
 * JRuby 9
 
 ## Documentation
@@ -49,7 +48,6 @@ take a look to the implementation notes:
 You can alse target specific runtimes:
 
     $ make mri-test
-    $ make rbx-test
     $ make jruby-test
 
 ### Raw

data/Rakefile

@@ -1,2 +1 @@
-#!/usr/bin/env rake
 require 'bundler/gem_tasks'

data/iso8601.gemspec

@@ -1,8 +1,7 @@
-# encoding: utf-8
-
 $LOAD_PATH.push File.expand_path('../lib', __FILE__)
 require 'iso8601/version'
 
+# rubocop:disable Metrics/BlockLength
 Gem::Specification.new do |s|
   s.name = 'iso8601'
   s.version = ISO8601::VERSION
@@ -11,14 +10,14 @@ Gem::Specification.new do |s|
   s.email = 'arnau.siches@gmail.com'
   s.homepage = 'https://github.com/arnau/ISO8601'
   s.summary = "Ruby parser to work with ISO 8601 dateTimes and durations - http://en.wikipedia.org/wiki/ISO_8601"
-  s.description = <<-EOD
+  s.description = <<-DESC
     ISO8601 is a simple implementation in Ruby of the ISO 8601 (Data elements and
     interchange formats - Information interchange - Representation of dates
     and times) standard.
-  EOD
+  DESC
   s.license = 'MIT'
   s.rubyforge_project = 'iso8601'
-  s.files = %W(CHANGELOG.md
+  s.files = %w[CHANGELOG.md
                CONTRIBUTING.md
                Gemfile
                LICENSE
@@ -56,14 +55,14 @@ Gem::Specification.new do |s|
                spec/iso8601/time_spec.rb
                spec/iso8601/weeks_spec.rb
                spec/iso8601/years_spec.rb
-               spec/spec_helper.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 = '>= 2.0.0'
-  s.add_development_dependency 'rspec', '~> 3.4'
-  s.add_development_dependency 'rubocop', '~> 0.40'
-  s.add_development_dependency 'pry', '~> 0.10.3'
-  s.add_development_dependency 'pry-doc', '~> 0.8.0'
+  s.add_development_dependency 'rspec', '~> 3.6'
+  s.add_development_dependency 'rubocop', '~> 0.50'
+  s.add_development_dependency 'pry', '~> 0.11.0'
+  s.add_development_dependency 'pry-doc', '~> 0.11.0'
 end

data/lib/iso8601.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'time'
 require 'forwardable'
 

data/lib/iso8601/atomic.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ISO8601
   module Atomic
     include Comparable
@@ -27,7 +25,7 @@ module ISO8601
     #
     # @return [String]
     def to_s
-      (value.zero?) ? '' : "#{value}#{symbol}"
+      value.zero? ? '' : "#{value}#{symbol}"
     end
 
     ##
@@ -66,13 +64,13 @@ module ISO8601
     ##
     # 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)
+      raise(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?
+      raise(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

@@ -112,6 +112,7 @@ module ISO8601
     # @param [String] input
     #
     # @return [Array<Integer>]
+    # rubocop:disable Metrics/AbcSize
     def atomize(input)
       week_date = parse_weekdate(input)
       return atomize_week_date(input, week_date[2], week_date[1]) unless week_date.nil?
@@ -121,7 +122,7 @@ module ISO8601
 
       _, year, separator, month, day = parse_date(input)
 
-      fail ISO8601::Errors::UnknownPattern, @original if year.nil?
+      raise(ISO8601::Errors::UnknownPattern, @original) if year.nil?
 
       @separator = separator
 

data/lib/iso8601/date_time.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ISO8601
   ##
   # A DateTime representation
@@ -59,7 +57,7 @@ module ISO8601
     def to_a
       [year, month, day, hour, minute, second, zone]
     end
-    alias_method :atoms, :to_a
+    alias atoms to_a
 
     ##
     # Converts DateTime to a floating point number of seconds since the Epoch.
@@ -98,8 +96,9 @@ module ISO8601
     # It enhances the parsing capabilities of the native DateTime.
     #
     # @param [String] date_time The ISO representation
+    # rubocop:disable Metrics/AbcSize
     def parse(date_time)
-      fail ISO8601::Errors::UnknownPattern, date_time if date_time.empty?
+      raise(ISO8601::Errors::UnknownPattern, date_time) if date_time.empty?
 
       date, time = date_time.split('T')
 
@@ -107,10 +106,8 @@ module ISO8601
       time_atoms = Array(time && parse_time(time))
       separators = [date_atoms.pop, time_atoms.pop]
 
-      fail ISO8601::Errors::UnknownPattern,
-           @original unless valid_representation?(date_atoms, time_atoms)
-      fail ISO8601::Errors::UnknownPattern,
-           @original unless valid_separators?(separators)
+      raise(ISO8601::Errors::UnknownPattern, @original) unless valid_representation?(date_atoms, time_atoms)
+      raise(ISO8601::Errors::UnknownPattern, @original) unless valid_separators?(separators)
 
       ::DateTime.new(*(date_atoms + time_atoms).compact)
     end
@@ -146,7 +143,7 @@ module ISO8601
       return true if separators.length == 1 || separators[0] == :ignore
 
       unless separators.all?(&:empty?)
-        return false if (separators.first.length != separators.last.length)
+        return false if separators.first.length != separators.last.length
       end
 
       true

data/lib/iso8601/days.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ISO8601
   ##
   # The Days atom in a {ISO8601::Duration}

data/lib/iso8601/duration.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ISO8601
   ##
   # A duration representation. When no base is provided, all atoms use an
@@ -24,6 +22,7 @@ module ISO8601
   #     di == dp # => true
   #     di == ds # => true
   #
+  # rubocop:disable Metrics/ClassLength
   class Duration
     ##
     # @param [String, Numeric] input The duration pattern
@@ -42,7 +41,7 @@ module ISO8601
     ##
     # @return [String] The string representation of the duration
     attr_reader :pattern
-    alias_method :to_s, :pattern
+    alias to_s pattern
 
     ##
     # @return [ISO8601::Years] The years of the duration
@@ -188,7 +187,7 @@ module ISO8601
     #
     # @return [Hash<Float>]
     def atomize(input)
-      duration = parse(input) || fail(ISO8601::Errors::UnknownPattern, input)
+      duration = parse(input) || raise(ISO8601::Errors::UnknownPattern, input)
 
       valid_pattern?(duration)
 
@@ -212,7 +211,7 @@ module ISO8601
     end
 
     def sign_to_i(sign)
-      (sign == '-') ? -1 : 1
+      sign == '-' ? -1 : 1
     end
 
     def parse(input)
@@ -220,9 +219,9 @@ module ISO8601
         (?<sign>\+|-)?
         P(?:
           (?:
-            (?:(?<years>\d+(?:[,.]\d+)?)Y)?
-            (?:(?<months>\d+(?:[.,]\d+)?)M)?
-            (?:(?<days>\d+(?:[.,]\d+)?)D)?
+            (?:(?<years>\d+)Y)?
+            (?:(?<months>\d+)M)?
+            (?:(?<days>\d+)D)?
             (?<time>T
               (?:(?<hours>\d+(?:[.,]\d+)?)H)?
               (?:(?<minutes>\d+(?:[.,]\d+)?)M)?
@@ -238,10 +237,11 @@ module ISO8601
     # @param [Numeric] value The seconds to promote
     #
     # @return [ISO8601::Duration]
+    # rubocop:disable Metrics/AbcSize
     def seconds_to_iso(value)
       return self.class.new('PT0S') if value.zero?
 
-      sign_str = (value < 0) ? '-' : ''
+      sign_str = value < 0 ? '-' : ''
       value = value.abs
 
       y, y_mod = decompose_atom(value, years)
@@ -266,11 +266,11 @@ module ISO8601
     end
 
     def to_time_s(*args)
-      (args.map(&:value).reduce(&:+) > 0) ? "T#{args.map(&:to_s).join('')}" : ''
+      args.map(&:value).reduce(&:+) > 0 ? "T#{args.map(&:to_s).join('')}" : ''
     end
 
     def validate_base(input)
-      fail ISO8601::Errors::TypeError unless input.nil? || input.is_a?(ISO8601::DateTime)
+      raise(ISO8601::Errors::TypeError) unless input.nil? || input.is_a?(ISO8601::DateTime)
 
       input
     end
@@ -288,20 +288,19 @@ module ISO8601
       missing_time = (weeks.nil? && !components[:time].nil? && time.empty?)
       empty = missing_time || all.empty?
 
-      fail ISO8601::Errors::UnknownPattern,
-           @pattern if empty
+      raise(ISO8601::Errors::UnknownPattern, @pattern) if empty
     end
 
     def valid_fractions?(values)
       values = values.reject(&:zero?)
-      fractions = values.select { |a| (a % 1) != 0 }
+      fractions = values.reject { |a| (a % 1).zero? }
       consistent = (fractions.size == 1 && fractions.last != values.last)
 
-      fail ISO8601::Errors::InvalidFractions if fractions.size > 1 || consistent
+      raise(ISO8601::Errors::InvalidFractions) if fractions.size > 1 || consistent
     end
 
     def compare_bases(other, base)
-      fail ISO8601::Errors::DurationBaseError, other if base != other.base
+      raise(ISO8601::Errors::DurationBaseError, other) if base != other.base
     end
 
     ##
@@ -321,7 +320,7 @@ module ISO8601
       when Numeric
         other.to_f
       else
-        fail(ISO8601::Errors::TypeError, other)
+        raise(ISO8601::Errors::TypeError, other)
       end
     end
   end

data/lib/iso8601/hours.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ISO8601
   ##
   # The Hours atom in a {ISO8601::Duration}

data/lib/iso8601/minutes.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ISO8601
   ##
   # The Minutes atom in a {ISO8601::Duration}

data/lib/iso8601/months.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ISO8601
   ##
   # A Months atom in a {ISO8601::Duration}
@@ -36,7 +34,7 @@ module ISO8601
     # @return [Numeric]
     def factor(base = nil)
       return AVERAGE_FACTOR if base.nil?
-      return zero_calculation(base) if atom.zero?
+      return calculation(1, base) if atom.zero?
 
       calculation(atom, base)
     end
@@ -49,12 +47,7 @@ module ISO8601
     #
     # @return [Numeric]
     def to_seconds(base = nil)
-      valid_base?(base)
-
-      return (AVERAGE_FACTOR * atom) if base.nil?
-      return zero_calculation(base) if atom.zero?
-
-      calculation(atom, base) * atom
+      factor(base) * atom
     end
 
     ##
@@ -67,27 +60,20 @@ module ISO8601
 
     private
 
-    def zero_calculation(base)
-      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(atom, base)
       initial = base.month + atom
       if initial <= 0
         month = base.month + atom
 
-        if initial % 12 == 0
+        if (initial % 12).zero?
           year = base.year + (initial / 12) - 1
           month = 12
         else
           year = base.year + (initial / 12).floor
-          month = (12 + initial > 0) ? (12 + initial) : (12 + (initial % -12))
+          month = 12 + initial > 0 ? (12 + initial) : (12 + (initial % -12))
         end
       else
-        month = (initial <= 12) ? initial : (initial % 12)
+        month = initial <= 12 ? initial : (initial % 12)
         month = 12 if month.zero?
         year = base.year + ((base.month + atom) / 12).to_i
       end

data/lib/iso8601/seconds.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ISO8601
   ##
   # The Seconds atom in a {ISO8601::Duration}

data/lib/iso8601/time.rb

@@ -113,12 +113,12 @@ module ISO8601
     # @param [String] input
     #
     # @return [Array<Integer, Float>]
+    # rubocop:disable Metrics/AbcSize
     def atomize(input)
       _, time, zone = parse_timezone(input)
       _, hour, separator, minute, second = parse_time(time)
 
-      fail ISO8601::Errors::UnknownPattern,
-           @original if hour.nil?
+      raise(ISO8601::Errors::UnknownPattern, @original) if hour.nil?
 
       @separator = separator
       require_separator = require_separator(minute)
@@ -129,8 +129,7 @@ module ISO8601
 
       atoms = [hour, minute, second, zone].compact
 
-      fail ISO8601::Errors::UnknownPattern,
-           @original unless valid_zone?(zone, require_separator)
+      raise(ISO8601::Errors::UnknownPattern, @original) unless valid_zone?(zone, require_separator)
 
       atoms
     end
@@ -180,7 +179,7 @@ module ISO8601
     #
     # @return [::DateTime]
     def compose(atoms, base)
-      ::DateTime.new(*[base.year, base.month, base.day], *atoms)
+      ::DateTime.new(base.year, base.month, base.day, *atoms)
     rescue ArgumentError
       raise ISO8601::Errors::RangeError, @original
     end

data/lib/iso8601/time_interval.rb

@@ -95,7 +95,7 @@ module ISO8601
       when Array
         from_atoms(input)
       else
-        fail(ISO8601::Errors::TypeError, 'The pattern must be a String or a Hash')
+        raise(ISO8601::Errors::TypeError, 'The pattern must be a String or a Hash')
       end
     end
 
@@ -111,14 +111,14 @@ module ISO8601
     #
     # @return [ISO8601::DateTime] start time
     attr_reader :first
-    alias_method :start_time, :first
+    alias start_time first
 
     ##
     # The end time (last) of the interval.
     #
     # @return [ISO8601::DateTime] end time
     attr_reader :last
-    alias_method :end_time, :last
+    alias end_time last
 
     ##
     # The pattern for the interval.
@@ -129,7 +129,7 @@ module ISO8601
 
       "#{@atoms.first}/#{@atoms.last}"
     end
-    alias_method :to_s, :pattern
+    alias to_s pattern
 
     ##
     # The size of the interval. If any bound is a Duration, the
@@ -137,8 +137,8 @@ module ISO8601
     #
     # @return [Float] Size of the interval in seconds
     attr_reader :size
-    alias_method :to_f, :size
-    alias_method :length, :size
+    alias to_f size
+    alias length size
 
     ##
     # Checks if the interval is empty.
@@ -159,13 +159,13 @@ module ISO8601
     #
     # @return [Boolean]
     def include?(other)
-      fail(ISO8601::Errors::TypeError, 'The parameter must respond_to #to_time') \
+      raise(ISO8601::Errors::TypeError, "The parameter must respond_to #to_time") \
         unless other.respond_to?(:to_time)
 
       (first.to_time <= other.to_time &&
        last.to_time >= other.to_time)
     end
-    alias_method :member?, :include?
+    alias member? include?
 
     ##
     # Returns true if the interval is a subset of the given interval.
@@ -177,7 +177,7 @@ module ISO8601
     #
     # @return [Boolean]
     def subset?(other)
-      fail(ISO8601::Errors::TypeError, "The parameter must be an instance of #{self.class}") \
+      raise(ISO8601::Errors::TypeError, "The parameter must be an instance of #{self.class}") \
         unless other.is_a?(self.class)
 
       other.include?(first) && other.include?(last)
@@ -193,7 +193,7 @@ module ISO8601
     #
     # @return [Boolean]
     def superset?(other)
-      fail(ISO8601::Errors::TypeError, "The parameter must be an instance of #{self.class}") \
+      raise(ISO8601::Errors::TypeError, "The parameter must be an instance of #{self.class}") \
         unless other.is_a?(self.class)
 
       include?(other.first) && include?(other.last)
@@ -209,8 +209,7 @@ module ISO8601
     #
     # @return [Boolean]
     def intersect?(other)
-      fail(ISO8601::Errors::TypeError,
-           "The parameter must be an instance of #{self.class}") \
+      raise(ISO8601::Errors::TypeError, "The parameter must be an instance of #{self.class}") \
         unless other.is_a?(self.class)
 
       include?(other.first) || include?(other.last)
@@ -225,7 +224,7 @@ module ISO8601
     #
     # @return [Boolean]
     def intersection(other)
-      fail(ISO8601::Errors::IntervalError, "The intervals are disjoint") \
+      raise(ISO8601::Errors::IntervalError, "The intervals are disjoint") \
         if disjoint?(other) && other.disjoint?(self)
 
       return self if subset?(other)
@@ -274,14 +273,30 @@ module ISO8601
       @atoms.hash
     end
 
+    def self.valid_date_time?(time, message = "Expected a ISO8601::DateTime")
+      return true if time.is_a?(ISO8601::DateTime)
+
+      raise(ISO8601::Errors::TypeError, message)
+    end
+
+    def self.guard_from_datetimes(atoms, message)
+      atoms.all? { |x| valid_date_time?(x, message) }
+    end
+
+    def self.guard_from_duration(atoms, message)
+      raise(ISO8601::Errors::TypeError, message) \
+        unless atoms.any? { |x| x.is_a?(ISO8601::Duration) } &&
+               atoms.any? { |x| x.is_a?(ISO8601::DateTime) }
+    end
+
     private
 
     # Initialize a TimeInterval ISO8601 by a pattern. If you initialize it with
     # a duration pattern, the second argument is mandatory because you need to
     # specify an start/end point to calculate the interval.
     #
-    # @param [String] pattern This parameter define a full time interval. These
-    #     patterns are defined in the ISO8601:
+    # @param [String] pattern This parameter defines a full time interval.
+    #     Valid patterns are defined in the ISO8601 as:
     #         * <start_time>/<end_time>
     #         * <start_time>/<duration>
     #         * <duration>/<end_time>
@@ -289,19 +304,21 @@ module ISO8601
     # @raise [ISO8601::Errors::UnknownPattern] If given pattern is not a valid
     #     ISO8601 pattern.
     def parse(pattern)
-      fail(ISO8601::Errors::UnknownPattern, pattern) unless pattern.include?('/')
+      raise(ISO8601::Errors::UnknownPattern, pattern) unless pattern.include?('/')
 
       @pattern = pattern
       subpatterns = pattern.split('/')
 
-      fail(ISO8601::Errors::UnknownPattern, pattern) if subpatterns.size != 2
+      raise(ISO8601::Errors::UnknownPattern, pattern) if subpatterns.size != 2
 
-      @atoms = subpatterns.map { |x| parse_subpattern(x) }
+      fst = parse_start_subpattern(subpatterns.first)
+      snd = parse_subpattern(subpatterns.last)
+      @atoms = [fst, snd]
       @first, @last, @size = limits(@atoms)
     end
 
     def sort_pair(a, b)
-      (a.first < b.first) ? [a, b] : [b, a]
+      a.first < b.first ? [a, b] : [b, a]
     end
 
     ##
@@ -316,6 +333,12 @@ module ISO8601
       ISO8601::DateTime.new(pattern)
     end
 
+    def parse_start_subpattern(pattern)
+      return ISO8601::Duration.new("-#{pattern}") if pattern.start_with?('P')
+
+      ISO8601::DateTime.new(pattern)
+    end
+
     ##
     # See the constructor methods.
     #
@@ -334,13 +357,10 @@ module ISO8601
     def limits(atoms)
       valid_atoms?(atoms)
 
-      if atoms.none? { |x| x.is_a?(ISO8601::Duration) }
-        return tuple_by_both(atoms)
-      elsif atoms.first.is_a?(ISO8601::Duration)
-        return tuple_by_end(atoms)
-      else
-        return tuple_by_start(atoms)
-      end
+      return tuple_by_both(atoms) if atoms.none? { |x| x.is_a?(ISO8601::Duration) }
+      return tuple_by_end(atoms) if atoms.first.is_a?(ISO8601::Duration)
+
+      tuple_by_start(atoms)
     end
 
     def tuple_by_both(atoms)
@@ -351,9 +371,9 @@ module ISO8601
 
     def tuple_by_end(atoms)
       seconds = atoms.first.to_seconds(atoms.last)
-      [(atoms.last - seconds),
+      [(atoms.last + seconds),
        atoms.last,
-       seconds]
+       seconds.abs]
     end
 
     def tuple_by_start(atoms)
@@ -364,29 +384,12 @@ module ISO8601
     end
 
     def valid_atoms?(atoms)
-      fail(ISO8601::Errors::UnknownPattern,
-           "The pattern of a time interval can't be <duration>/<duration>") \
+      raise(ISO8601::Errors::UnknownPattern, "The pattern of a time interval can't be <duration>/<duration>") \
         if atoms.all? { |x| x.is_a?(ISO8601::Duration) }
     end
 
     def valid_date_time?(time)
-      self.valid_date_time?(time)
-    end
-
-    def self.valid_date_time?(time, message = 'Expected a ISO8601::DateTime')
-      return true if time.is_a?(ISO8601::DateTime)
-
-      fail(ISO8601::Errors::TypeError, message)
-    end
-
-    def self.guard_from_datetimes(atoms, message)
-      atoms.all? { |x| valid_date_time?(x, message) }
-    end
-
-    def self.guard_from_duration(atoms, message)
-      fail(ISO8601::Errors::TypeError, message) \
-        unless atoms.any? { |x| x.is_a?(ISO8601::Duration) } &&
-               atoms.any? { |x| x.is_a?(ISO8601::DateTime) }
+      valid_date_time?(time)
     end
   end
 end

data/lib/iso8601/version.rb

@@ -1,5 +1,5 @@
 module ISO8601
   ##
   # The gem version
-  VERSION = '0.9.1'
+  VERSION = '0.10.0'.freeze
 end

data/lib/iso8601/weeks.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ISO8601
   ##
   # A Weeks atom in a {ISO8601::Duration}

data/lib/iso8601/years.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 module ISO8601
   ##
   # A Years atom in a {ISO8601::Duration}
@@ -47,16 +45,18 @@ module ISO8601
     ##
     # The amount of seconds
     #
+    # TODO: Fractions of year will fail
+    #
     # @param [ISO8601::DateTime, nil] base (nil) The base datetime to compute
     #   the year length.
     #
     # @return [Numeric]
     def to_seconds(base = nil)
       valid_base?(base)
+      return factor(base) * atom if base.nil?
+      target = ::Time.utc(base.year + atom.to_i, base.month, base.day, base.hour, base.minute, base.second)
 
-      return (AVERAGE_FACTOR * atom) if base.nil?
-
-      ::Time.utc(year(atom, base)) - ::Time.utc(base.year)
+      target - base.to_time
     end
 
     ##

data/spec/iso8601/date_time_spec.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'spec_helper'
 
 describe ISO8601::DateTime do

data/spec/iso8601/duration_spec.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'spec_helper'
 
 RSpec.describe ISO8601::Duration do
@@ -22,21 +20,13 @@ RSpec.describe ISO8601::Duration do
   end
 
   it "should raise a ISO8601::Errors::InvalidFraction for any invalid patterns" do
-    expect { ISO8601::Duration.new('P1.5Y0.5M') }.to raise_error(ISO8601::Errors::InvalidFractions)
-    expect { ISO8601::Duration.new('P1.5Y1M') }.to raise_error(ISO8601::Errors::InvalidFractions)
-    expect { ISO8601::Duration.new('P1.5MT10.5S') }.to raise_error(ISO8601::Errors::InvalidFractions)
+    expect { ISO8601::Duration.new('PT10.5M10.5S') }.to raise_error(ISO8601::Errors::InvalidFractions)
   end
 
   it "should parse any allowed pattern" do
     expect { ISO8601::Duration.new('P1Y') }.to_not raise_error
-    expect { ISO8601::Duration.new('P0.5Y') }.to_not raise_error
-    expect { ISO8601::Duration.new('P0,5Y') }.to_not raise_error
     expect { ISO8601::Duration.new('P1Y1M') }.to_not raise_error
-    expect { ISO8601::Duration.new('P1Y0.5M') }.to_not raise_error
-    expect { ISO8601::Duration.new('P1Y0,5M') }.to_not raise_error
     expect { ISO8601::Duration.new('P1Y1M1D') }.to_not raise_error
-    expect { ISO8601::Duration.new('P1Y1M0.5D') }.to_not raise_error
-    expect { ISO8601::Duration.new('P1Y1M0,5D') }.to_not raise_error
     expect { ISO8601::Duration.new('P1Y1M1DT1H') }.to_not raise_error
     expect { ISO8601::Duration.new('P1Y1M1DT0.5H') }.to_not raise_error
     expect { ISO8601::Duration.new('P1Y1M1DT0,5H') }.to_not raise_error
@@ -268,8 +258,8 @@ RSpec.describe ISO8601::Duration do
     end
 
     it "should equal by hash identity" do
-      expect(ISO8601::Duration.new('PT1H').eql? ISO8601::Duration.new('PT1H')).to be_truthy
-      expect(ISO8601::Duration.new('PT1H').eql? ISO8601::Duration.new('PT60M')).to be_falsy
+      expect(ISO8601::Duration.new('PT1H').eql?(ISO8601::Duration.new('PT1H'))).to be_truthy
+      expect(ISO8601::Duration.new('PT1H').eql?(ISO8601::Duration.new('PT60M'))).to be_falsy
     end
   end
 

data/spec/iso8601/hours_spec.rb

@@ -5,17 +5,17 @@ RSpec.describe ISO8601::Hours do
     let(:subject) { ISO8601::Hours.new(1) }
 
     it "should respond to the Atomic interface" do
-      [:factor,
-       :to_seconds,
-       :symbol,
-       :to_i,
-       :to_f,
-       :to_s,
-       :value,
-       :<=>,
-       :eql?,
-       :hash,
-       :valid_atom?].each { |m| expect(subject).to respond_to(m) }
+      %i[factor
+         to_seconds
+         symbol
+         to_i
+         to_f
+         to_s
+         value
+         <=>
+         eql?
+         hash
+         valid_atom?].each { |m| expect(subject).to respond_to(m) }
     end
   end
 

data/spec/iso8601/minutes_spec.rb

@@ -5,17 +5,17 @@ RSpec.describe ISO8601::Minutes do
     let(:subject) { ISO8601::Minutes.new(1) }
 
     it "should respond to the Atomic interface" do
-      [:factor,
-       :to_seconds,
-       :symbol,
-       :to_i,
-       :to_f,
-       :to_s,
-       :value,
-       :<=>,
-       :eql?,
-       :hash,
-       :valid_atom?].each { |m| expect(subject).to respond_to(m) }
+      %i[factor
+         to_seconds
+         symbol
+         to_i
+         to_f
+         to_s
+         value
+         <=>
+         eql?
+         hash
+         valid_atom?].each { |m| expect(subject).to respond_to(m) }
     end
   end
 

data/spec/iso8601/months_spec.rb

@@ -7,21 +7,25 @@ RSpec.describe ISO8601::Months do
   let(:common_february) { ISO8601::DateTime.new('2010-02-01') }
   let(:leap_february) { ISO8601::DateTime.new('2000-02-01') }
 
+  let(:common_december) { ISO8601::DateTime.new('2017-12-01') }
+  let(:leap_december) { ISO8601::DateTime.new('2000-12-01') }
+
+
   describe 'Atomic' do
     let(:subject) { ISO8601::Months.new(1) }
 
     it "should respond to the Atomic interface" do
-      [:factor,
-       :to_seconds,
-       :symbol,
-       :to_i,
-       :to_f,
-       :to_s,
-       :value,
-       :<=>,
-       :eql?,
-       :hash,
-       :valid_atom?].each { |m| expect(subject).to respond_to(m) }
+      %i[factor
+         to_seconds
+         symbol
+         to_i
+         to_f
+         to_s
+         value
+         <=>
+         eql?
+         hash
+         valid_atom?].each { |m| expect(subject).to respond_to(m) }
     end
   end
 
@@ -29,6 +33,7 @@ RSpec.describe ISO8601::Months do
     it "should return the Month factor" do
       expect { ISO8601::Months.new(1).factor }.to_not raise_error
       expect(ISO8601::Months.new(2).factor).to eq(2628000)
+      expect(ISO8601::Months.new(0).factor).to eq(2628000)
     end
 
     it "should return the Month factor for a common year" do
@@ -55,6 +60,9 @@ RSpec.describe ISO8601::Months do
 
     it "should return the amount of seconds for a common year" do
       expect(ISO8601::Months.new(2).to_seconds(common_year)).to eq(5097600)
+      expect(ISO8601::Months.new(1).to_seconds(common_year)).to eq(2678400)
+      expect(ISO8601::Months.new(0).to_seconds(common_year)).to eq(0)
+      expect(ISO8601::Months.new(0).to_seconds(common_december)).to eq(0)
     end
 
     it "should return the amount of seconds for a leap year" do

data/spec/iso8601/seconds_spec.rb

@@ -5,17 +5,17 @@ RSpec.describe ISO8601::Seconds do
     let(:subject) { ISO8601::Seconds.new(1) }
 
     it "should respond to the Atomic interface" do
-      [:factor,
-       :to_seconds,
-       :symbol,
-       :to_i,
-       :to_f,
-       :to_s,
-       :value,
-       :<=>,
-       :eql?,
-       :hash,
-       :valid_atom?].each { |m| expect(subject).to respond_to(m) }
+      %i[factor
+         to_seconds
+         symbol
+         to_i
+         to_f
+         to_s
+         value
+         <=>
+         eql?
+         hash
+         valid_atom?].each { |m| expect(subject).to respond_to(m) }
     end
   end
 

data/spec/iso8601/time_interval_spec.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 require 'spec_helper'
 
 RSpec.describe ISO8601::TimeInterval do
@@ -56,19 +54,13 @@ RSpec.describe ISO8601::TimeInterval do
     context "allowed patterns" do
       it "should parse <start>/<duration>" do
         expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y') }.to_not raise_error
-        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P0.5Y') }.to_not raise_error
-        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y0.5M') }.to_not raise_error
-        expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y0,5M') }.to_not raise_error
         expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y1M1D') }.to_not raise_error
         expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y1M1DT1H1M1.0S') }.to_not raise_error
         expect { ISO8601::TimeInterval.parse('2007-03-01T13:00:00Z/P1Y1M1DT1H1M1,0S') }.to_not raise_error
       end
 
       it "should parse <duration>/<end>" do
-        expect { ISO8601::TimeInterval.parse('P1Y0,5M/2010-05-09T10:30:12+04') }.to_not raise_error
         expect { ISO8601::TimeInterval.parse('P1Y1M1D/2010-05-09T10:30:12+04:00') }.to_not raise_error
-        expect { ISO8601::TimeInterval.parse('P1Y1M0.5D/2010-05-09T10:30:12-04:00') }.to_not raise_error
-        expect { ISO8601::TimeInterval.parse('P1Y1M0,5D/2010-05-09T10:30:12-00:00') }.to_not raise_error
         expect { ISO8601::TimeInterval.parse('P1Y1M1DT1H/-2014-05-31T16:26:00Z') }.to_not raise_error
         expect { ISO8601::TimeInterval.parse('P1Y1M1DT0.5H/2014-05-31T16:26:10.5Z') }.to_not raise_error
         expect { ISO8601::TimeInterval.parse('P1Y1M1DT0,5H/2014-05-31T16:26:10,5Z') }.to_not raise_error
@@ -180,6 +172,107 @@ RSpec.describe ISO8601::TimeInterval do
       expect(ISO8601::TimeInterval.parse(pattern2).first).to eq(start_time)
       expect(ISO8601::TimeInterval.parse(pattern3).first).to eq(start_time)
     end
+
+    describe "November" do
+      pairs = [
+        {pattern: 'P1Y/2017-11-09T07:00:00Z',
+         start_time: ISO8601::DateTime.new('2016-11-09T07:00:00Z')},
+        {pattern: 'P1M/2017-11-09T07:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-10-09T07:00:00Z')},
+        {pattern: 'P1D/2017-11-09T07:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-11-08T07:00:00Z')},
+        {pattern: 'PT1H/2017-11-09T07:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-11-09T06:00:00Z')},
+      ]
+
+      pairs.each do |pair|
+        it "should calculate correctly the start_time for #{pair[:pattern]}" do
+          expect(ISO8601::TimeInterval.parse(pair[:pattern]).first.to_s).to eq(pair[:start_time].to_s)
+        end
+      end
+    end
+
+    describe "December" do
+      pairs = [
+        {pattern: 'P1Y/2017-12-09T07:00:00Z',
+         start_time: ISO8601::DateTime.new('2016-12-09T07:00:00Z')},
+        {pattern: 'P1M/2017-12-09T07:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-11-09T07:00:00Z')},
+        {pattern: 'P3D/2017-12-06T18:30:00Z',
+         start_time: ISO8601::DateTime.new('2017-12-03T18:30:00Z')},
+        {pattern: 'P1D/2017-12-09T07:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-12-08T07:00:00Z')},
+        {pattern: 'PT1H/2017-12-09T07:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-12-09T06:00:00Z')},
+      ]
+
+      pairs.each do |pair|
+        it "should calculate correctly the start_time for #{pair[:pattern]}" do
+          expect(ISO8601::TimeInterval.parse(pair[:pattern]).first.to_s).to eq(pair[:start_time].to_s)
+        end
+      end
+    end
+
+    describe "January" do
+      pairs = [
+        {pattern: 'P1Y/2017-01-01T00:00:00Z',
+         start_time: ISO8601::DateTime.new('2016-01-01T00:00:00Z')},
+        {pattern: 'P1M/2017-01-01T00:00:00Z',
+         start_time: ISO8601::DateTime.new('2016-12-01T00:00:00Z')},
+        {pattern: 'P1D/2017-01-01T00:00:00Z',
+         start_time: ISO8601::DateTime.new('2016-12-31T00:00:00Z')},
+        {pattern: 'PT1H/2017-01-01T01:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-01-01T00:00:00Z')},
+      ]
+
+      pairs.each do |pair|
+        it "should calculate correctly the start_time for #{pair[:pattern]}" do
+          expect(ISO8601::TimeInterval.parse(pair[:pattern]).first.to_s).to eq(pair[:start_time].to_s)
+        end
+      end
+    end
+
+    describe "February" do
+      pairs = [
+        {pattern: 'P1Y/2017-02-01T00:00:00Z',
+         start_time: ISO8601::DateTime.new('2016-02-01T00:00:00Z')},
+        {pattern: 'P1M/2017-02-01T00:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-01-01T00:00:00Z')},
+        {pattern: 'P1D/2017-02-01T00:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-01-31T00:00:00Z')},
+        {pattern: 'PT1H/2017-02-01T01:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-02-01T00:00:00Z')},
+      ]
+
+      pairs.each do |pair|
+        it "should calculate correctly the start_time for #{pair[:pattern]}" do
+          expect(ISO8601::TimeInterval.parse(pair[:pattern]).first.to_s).to eq(pair[:start_time].to_s)
+        end
+      end
+    end
+
+    describe "March" do
+      pairs = [
+        {pattern: 'P1Y/2017-03-01T00:00:00Z',
+         start_time: ISO8601::DateTime.new('2016-03-01T00:00:00Z')},
+        {pattern: 'P1M/2017-03-01T00:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-02-01T00:00:00Z')},
+        {pattern: 'P1D/2017-03-01T00:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-02-28T00:00:00Z')},
+        {pattern: 'PT1H/2017-03-01T01:00:00Z',
+         start_time: ISO8601::DateTime.new('2017-03-01T00:00:00Z')},
+      ]
+
+      pairs.each do |pair|
+        it "should calculate correctly the start_time for #{pair[:pattern]}" do
+          expect(ISO8601::TimeInterval.parse(pair[:pattern]).first.to_s).to eq(pair[:start_time].to_s)
+        end
+      end
+    end
+
+
+
+
   end
 
   describe "#last" do
@@ -207,8 +300,8 @@ RSpec.describe ISO8601::TimeInterval do
 
   describe "#to_s" do
     it "should return the pattern if TimeInterval is initialized with a pattern" do
-      pattern = 'P1Y1M1DT0,5H/2014-05-31T16:26:10,5Z'
-      pattern2 = '2007-03-01T13:00:00Z/P1Y0,5M'
+      pattern = 'P1Y1M1DT0,5S/2014-05-31T16:26:10Z'
+      pattern2 = '2007-03-01T13:00:00Z/P1Y'
 
       expect(ISO8601::TimeInterval.parse(pattern).to_s).to eq(pattern)
       expect(ISO8601::TimeInterval.parse(pattern2).to_s).to eq(pattern2)

data/spec/iso8601/weeks_spec.rb

@@ -5,17 +5,17 @@ RSpec.describe ISO8601::Weeks do
     let(:subject) { ISO8601::Weeks.new(1) }
 
     it "should respond to the Atomic interface" do
-      [:factor,
-       :to_seconds,
-       :symbol,
-       :to_i,
-       :to_f,
-       :to_s,
-       :value,
-       :<=>,
-       :eql?,
-       :hash,
-       :valid_atom?].each { |m| expect(subject).to respond_to(m) }
+      %i[factor
+         to_seconds
+         symbol
+         to_i
+         to_f
+         to_s
+         value
+         <=>
+         eql?
+         hash
+         valid_atom?].each { |m| expect(subject).to respond_to(m) }
     end
   end
 

data/spec/iso8601/years_spec.rb

@@ -8,17 +8,17 @@ RSpec.describe ISO8601::Years do
     let(:subject) { ISO8601::Years.new(1) }
 
     it "should respond to the Atomic interface" do
-      [:factor,
-       :to_seconds,
-       :symbol,
-       :to_i,
-       :to_f,
-       :to_s,
-       :value,
-       :<=>,
-       :eql?,
-       :hash,
-       :valid_atom?].each { |m| expect(subject).to respond_to(m) }
+      %i[factor
+         to_seconds
+         symbol
+         to_i
+         to_f
+         to_s
+         value
+         <=>
+         eql?
+         hash
+         valid_atom?].each { |m| expect(subject).to respond_to(m) }
     end
   end
 
@@ -31,6 +31,7 @@ RSpec.describe ISO8601::Years do
 
     it "should return the Year factor for a common year" do
       expect(ISO8601::Years.new(1).factor(common_year)).to eq(31536000)
+      expect(ISO8601::Years.new(0).factor(common_year)).to eq(31536000)
     end
 
     it "should return the Year factor for a leap year" do

data/spec/spec_helper.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 $LOAD_PATH.unshift File.expand_path('..', __FILE__)
 require 'iso8601'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iso8601
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Arnau Siches
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-21 00:00:00.000000000 Z
+date: 2017-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -16,56 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '3.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.40'
+        version: '0.50'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.40'
+        version: '0.50'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.3
+        version: 0.11.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.3
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: pry-doc
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.11.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.11.0
 description: |2
       ISO8601 is a simple implementation in Ruby of the ISO 8601 (Data elements and
       interchange formats - Information interchange - Representation of dates
@@ -134,7 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: iso8601
-rubygems_version: 2.6.4
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Ruby parser to work with ISO 8601 dateTimes and durations - http://en.wikipedia.org/wiki/ISO_8601
@@ -152,4 +152,3 @@ test_files:
 - spec/iso8601/weeks_spec.rb
 - spec/iso8601/years_spec.rb
 - spec/spec_helper.rb
-has_rdoc: yard