iso8601 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a046b00234ecd1ead9531234435f3b28bb1e89d3
-  data.tar.gz: 53e15b12514e255b2a5aaeb451e041047b2d6ef0
+  metadata.gz: ebc324dddf45972ba0a794b182d1cc9057aba93a
+  data.tar.gz: df0e9923948069eff193d5cad7db26e244bb25aa
 SHA512:
-  metadata.gz: 4be163f63f8e4d488ecb8d6c997e17031445ab0b124644f8c0b6d33ac60cbc9b9b21f5009ba0a185f8cb08cbc7e4a3de9900c9fdccf3589fd75ea5a6cb8e2d99
-  data.tar.gz: a10fa5e91adbd1717954b81809cdf206e34f676f07f27add1cceb1530d782c7a3df5b5e8052265f10f915578538f3417c8f7890d97fe4bceedf11d2b0061ae22
+  metadata.gz: d475f9aa2193aeb8d1e935fb2b74aaeb98112184d5e3d95243d10768bc10799327a130e57def52791bf0a310de16ae5703962cb7ee8d23e8a3a56ec06b9f6f6c
+  data.tar.gz: d8e4f640791540d73a3388d11c2a4cbf01379cf34db30324b6e83fadf69213be7e099465edb1860387498d0d7221a064b2bf3829379dd37b07a7bb4f58eb15ae

data/.rubocop.yml

@@ -0,0 +1,38 @@
+Documentation:
+  Enabled: false
+
+Lint/UselessComparison:
+  Enabled: false
+
+Metrics/ClassLength:
+  Max: 150
+
+# Work in progress
+Metrics/LineLength:
+  Max: 183
+
+# Work in progress
+Metrics/MethodLength:
+  Max: 24
+
+# Work in progress
+Metrics/PerceivedComplexity:
+  Max: 8
+
+Style/Blocks:
+  Enabled: false
+
+Style/NumericLiterals:
+  MinDigits: 10
+
+Style/RegexpLiteral:
+  MaxSlashes: 0
+
+Style/StringLiterals:
+  Enabled: false
+
+Style/Encoding:
+  EnforcedStyle: when_needed
+
+Style/BracesAroundHashParameters:
+  EnforcedStyle: braces

data/.travis.yml

@@ -3,5 +3,16 @@ rvm:
   - 1.9.3
   - 2.0.0
   - 2.1.2
-  - rbx-2.2.10
+  - ruby-head
+  - rbx-2
+  - jruby-head
 script: bundle exec rspec spec
+matrix:
+  include:
+    - rvm: jruby
+      env: JRUBY_OPTS='--2.0'
+  allow_failures:
+    - rvm: jruby-head
+    - rvm: ruby-head
+    - rvm: rbx-2
+  fast_finish: true

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.8.1
+
+* Fix durations using comma (,) as a decimal separator.
+
 ## 0.8.0
 
 * `DateTime` has hash identity by value.

data/Gemfile

@@ -1,8 +1,3 @@
 source 'http://rubygems.org'
 
 gemspec
-
-group :doc do
-  gem 'yard'
-  gem 'redcarpet'
-end

data/README.md

@@ -8,6 +8,8 @@ times) standard.
 
 [![Build Status](https://secure.travis-ci.org/arnau/ISO8601.png?branch=master)](http://travis-ci.org/arnau/ISO8601/)
 
+[![Dependency Status](https://gemnasium.com/arnau/ISO8601.svg)](https://gemnasium.com/arnau/ISO8601)
+
 ## Supported versions
 
 * MRI 1.9.3
@@ -22,8 +24,8 @@ Check the [changelog](https://github.com/arnau/ISO8601/blob/master/CHANGELOG.md)
 
 ### Duration sign
 
-Because Durations and DateTime has a substraction method, Durations has
-sign to be able to represent a negative value:
+Because `Durations` and `DateTime` have a substraction method, `Durations` has
+sign to be able to represent negative values:
 
     (ISO8601::Duration.new('PT10S') - ISO8601::Duration.new('PT12S')).to_s  #=> '-PT2S'
     (ISO8601::Duration.new('-PT10S') + ISO8601::Duration.new('PT12S')).to_s #=> 'PT2S'

data/iso8601.gemspec

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-$:.push File.expand_path('../lib', __FILE__)
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
 require 'iso8601/version'
 
 Gem::Specification.new do |s|
@@ -12,8 +12,8 @@ Gem::Specification.new do |s|
   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
-    ISO8601 is a simple implementation in Ruby of the ISO 8601 (Data elements and 
-    interchange formats - Information interchange - Representation of dates 
+    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
   s.license = 'MIT'
@@ -24,7 +24,7 @@ Gem::Specification.new do |s|
   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 'rerun', '~> 0'
+  s.add_development_dependency 'rubocop', '~> 0.26'
 end

data/lib/iso8601/atoms.rb

@@ -10,9 +10,9 @@ module ISO8601
     # @param [Numeric] atom The atom value
     # @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) || base.nil?
+    def initialize(atom, base = nil)
+      fail TypeError, "The atom argument for #{inspect} should be a Numeric value." unless atom.is_a?(Numeric)
+      fail TypeError, "The base argument for #{inspect} should be a ISO8601::DateTime instance or nil." unless base.is_a?(ISO8601::DateTime) || base.nil?
       @atom = atom
       @base = base
     end
@@ -55,18 +55,18 @@ module ISO8601
       atom * factor
     end
     ##
-    # @param [#hash] contrast The contrast to compare against
+    # @param [#hash] other The contrast to compare against
     #
     # @return [Boolean]
-    def ==(contrast)
-      (hash == contrast.hash)
+    def ==(other)
+      (hash == other.hash)
     end
     ##
-    # @param [#hash] contrast The contrast to compare against
+    # @param [#hash] other The contrast to compare against
     #
     # @return [Boolean]
-    def eql?(contrast)
-      (hash == contrast.hash)
+    def eql?(other)
+      (hash == other.hash)
     end
     ##
     # @return [Fixnum]
@@ -76,26 +76,27 @@ module ISO8601
     ##
     # The atom factor to compute the amount of seconds for the atom
     def factor
-      raise NotImplementedError, "The #factor method should be implemented by each subclass"
+      fail NotImplementedError,
+           "The #factor method should be implemented by each subclass"
     end
   end
   ##
   # A Years atom in a {ISO8601::Duration}
   #
-  # A “calendar year” is the cyclic time interval in a calendar which is
+  # A "calendar year" is the cyclic time interval in a calendar which is
   # required for one revolution of the Earth around the Sun and approximated to
-  # an integral number of “calendar days”.
+  # an integral number of "calendar days".
   #
-  # A “duration year” is the duration of 365 or 366 “calendar days” depending on
-  # the start and/or the end of the corresponding time interval within the
-  # specific “calendar year”.
+  # A "duration year" is the duration of 365 or 366 "calendar days" depending
+  # on the start and/or the end of the corresponding time interval within the
+  # specific "calendar year".
   class Years < ISO8601::Atom
     ##
     # The Year factor
     #
-    # 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”.
+    # 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
@@ -120,19 +121,19 @@ module ISO8601
   ##
   # A Months atom in a {ISO8601::Duration}
   #
-  # A “calendar month” is the time interval resulting from the division of a
-  # “calendar year” in 12 time intervals.
+  # A "calendar month" is the time interval resulting from the division of a
+  # "calendar year" in 12 time intervals.
   #
-  # A “duration month” is the duration of 28, 29, 30 or 31 “calendar days”
+  # A "duration month" is the duration of 28, 29, 30 or 31 "calendar days"
   # depending on the start and/or the end of the corresponding time interval
-  # within the specific “calendar month”.
+  # within the specific "calendar month".
   class Months < ISO8601::Atom
     ##
     # The Month factor
     #
-    # The “duration month” 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”.
+    # The "duration month" 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".
     def factor
       if base.nil?
         nobase_calculation
@@ -157,25 +158,26 @@ module ISO8601
     end
 
     def zero_calculation
-      month = (base.month <= 12) ? (base.month) : ((base.month) % 12)
+      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
+      initial = base.month + atom
+      if initial <= 0
         month = base.month + atom
 
-        if month % 12 == 0
-          year = base.year + (month / 12) - 1
+        if initial % 12 == 0
+          year = base.year + (initial / 12) - 1
           month = 12
         else
-          year = base.year + (month / 12).floor
-          month = (12 + month > 0) ? (12 + month) : (12 + (month % -12))
+          year = base.year + (initial / 12).floor
+          month = (12 + initial > 0) ? (12 + initial) : (12 + (initial % -12))
         end
       else
-        month = (base.month + atom <= 12) ? (base.month + atom) : ((base.month + atom) % 12)
+        month = (initial <= 12) ? initial : (initial % 12)
         month = 12 if month.zero?
         year = base.year + ((base.month + atom) / 12).to_i
       end
@@ -202,9 +204,9 @@ 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”.
+  # 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 < ISO8601::Atom
     ##
     # The Day factor
@@ -256,7 +258,7 @@ module ISO8601
   #
   # The second is the base unit of measurement of time in the International
   # System of Units (SI) as defined by the International Committee of Weights
-  # and Measures (CIPM, i.e. Comité International des Poids et Mesures)
+  # and Measures.
   class Seconds < ISO8601::Atom
     ##
     # The Second factor

data/lib/iso8601/date.rb

@@ -15,9 +15,11 @@ module ISO8601
   class Date
     extend Forwardable
 
-    def_delegators(:@date,
+    def_delegators(
+      :@date,
       :to_s, :to_time, :to_date, :to_datetime,
-      :year, :month, :day, :wday)
+      :year, :month, :day, :wday
+    )
     ##
     # The original atoms
     attr_reader :atoms
@@ -41,20 +43,20 @@ module ISO8601
     ##
     # Forwards the date the given amount of days.
     #
-    # @param [Numeric] days The days to add
+    # @param [Numeric] other The days to add
     #
     # @return [ISO8601::Date] New date resulting of the addition
-    def +(days)
-      ISO8601::Date.new((@date + days).iso8601)
+    def +(other)
+      ISO8601::Date.new((@date + other).iso8601)
     end
     ##
     # Backwards the date the given amount of days.
     #
-    # @param [Numeric] days The days to remove
+    # @param [Numeric] other The days to remove
     #
     # @return [ISO8601::Date] New date resulting of the substraction
-    def -(days)
-      ISO8601::Date.new((@date - days).iso8601)
+    def -(other)
+      ISO8601::Date.new((@date - other).iso8601)
     end
     ##
     # Converts self to an array of atoms.
@@ -62,18 +64,18 @@ module ISO8601
       [year, month, day]
     end
     ##
-    # @param [#hash] contrast The contrast to compare against
+    # @param [#hash] other The contrast to compare against
     #
     # @return [Boolean]
-    def ==(contrast)
-      (hash == contrast.hash)
+    def ==(other)
+      (hash == other.hash)
     end
     ##
-    # @param [#hash] contrast The contrast to compare against
+    # @param [#hash] other The contrast to compare against
     #
     # @return [Boolean]
-    def eql?(contrast)
-      (hash == contrast.hash)
+    def eql?(other)
+      (hash == other.hash)
     end
     ##
     # @return [Fixnum]
@@ -82,6 +84,7 @@ module ISO8601
     end
 
     private
+
     ##
     # Splits the date component into valid atoms.
     #
@@ -101,7 +104,8 @@ module ISO8601
       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?
 
-      _, sign, year, separator, day = /^([+-]?)(\d{4})(-?)(\d{3})$/.match(input).to_a.compact
+      ordinal_regexp = /^([+-]?)(\d{4})(-?)(\d{3})$/
+      _, sign, year, separator, day = ordinal_regexp.match(input).to_a.compact
       return atomize_ordinal(year, day, separator, sign) unless year.nil?
 
       _, year, separator, month, day = /^
@@ -114,7 +118,7 @@ module ISO8601
         )?
       $/x.match(input).to_a.compact
 
-      raise ISO8601::Errors::UnknownPattern.new(@original) if year.nil?
+      fail ISO8601::Errors::UnknownPattern, @original if year.nil?
 
       @separator = separator
 

data/lib/iso8601/date_time.rb

@@ -10,9 +10,11 @@ module ISO8601
   class DateTime
     extend Forwardable
 
-    def_delegators(:@date_time,
+    def_delegators(
+      :@date_time,
       :strftime, :to_time, :to_date, :to_datetime,
-      :year, :month, :day, :hour, :minute, :zone)
+      :year, :month, :day, :hour, :minute, :zone
+    )
 
     attr_reader :second
 
@@ -29,9 +31,9 @@ module ISO8601
     ##
     # Addition
     #
-    # @param [Numeric] seconds The seconds to add
-    def +(seconds)
-      moment = @date_time.to_time.localtime(zone) + seconds
+    # @param [Numeric] other The seconds to add
+    def +(other)
+      moment = @date_time.to_time.localtime(zone) + other
       format = moment.subsec.zero? ? FORMAT : FORMAT_WITH_FRACTION
 
       ISO8601::DateTime.new(moment.strftime(format))
@@ -39,9 +41,9 @@ module ISO8601
     ##
     # Substraction
     #
-    # @param [Numeric] seconds The seconds to substract
-    def -(seconds)
-      moment = @date_time.to_time.localtime(zone) - seconds
+    # @param [Numeric] other The seconds to substract
+    def -(other)
+      moment = @date_time.to_time.localtime(zone) - other
       format = moment.subsec.zero? ? FORMAT : FORMAT_WITH_FRACTION
 
       ISO8601::DateTime.new(moment.strftime(format))
@@ -58,18 +60,18 @@ module ISO8601
       [year, month, day, hour, minute, second, zone]
     end
     ##
-    # @param [#hash] contrast The contrast to compare against
+    # @param [#hash] other The contrast to compare against
     #
     # @return [Boolean]
-    def ==(contrast)
-      (hash == contrast.hash)
+    def ==(other)
+      (hash == other.hash)
     end
     ##
-    # @param [#hash] contrast The contrast to compare against
+    # @param [#hash] other The contrast to compare against
     #
     # @return [Boolean]
-    def eql?(contrast)
-      (hash == contrast.hash)
+    def eql?(other)
+      (hash == other.hash)
     end
     ##
     # @return [Fixnum]
@@ -77,8 +79,8 @@ module ISO8601
       [second, self.class].hash
     end
 
-
     private
+
     ##
     # Parses an ISO date time, where the date and the time components are
     # optional.
@@ -87,20 +89,20 @@ module ISO8601
     #
     # @param [String] date_time The ISO representation
     def parse(date_time)
-      raise ISO8601::Errors::UnknownPattern, date_time if date_time.empty?
+      fail ISO8601::Errors::UnknownPattern, date_time if date_time.empty?
 
       date, time = date_time.split('T')
 
-      date_components = parse_date(date)
-      time_components = Array(time && parse_time(time))
-      separators = [date_components.pop, time_components.pop]
+      date_atoms = parse_date(date)
+      time_atoms = Array(time && parse_time(time))
+      separators = [date_atoms.pop, time_atoms.pop]
 
-      raise ISO8601::Errors::UnknownPattern, @original unless valid_representation?(date_components, time_components)
-      raise ISO8601::Errors::UnknownPattern, @original unless valid_separators?(separators)
+      fail ISO8601::Errors::UnknownPattern,
+           @original unless valid_representation?(date_atoms, time_atoms)
+      fail ISO8601::Errors::UnknownPattern,
+           @original unless valid_separators?(separators)
 
-      components = date_components + time_components
-
-      ::DateTime.new(*components.compact)
+      ::DateTime.new(*(date_atoms + time_atoms).compact)
     end
     ##
     # Validates the date has the right pattern.
@@ -134,13 +136,14 @@ module ISO8601
       unless separators.all?(&:empty?)
         return false if (separators.first.length != separators.last.length)
       end
-      return true
+
+      true
     end
     ##
     # If time is provided date must use a complete representation
     def valid_representation?(date, time)
       year, month, day = date
-      hour, minute, second = time
+      hour, _ = time
 
       date.nil? || !(!year.nil? && (month.nil? || day.nil?) && !hour.nil?)
     end

data/lib/iso8601/duration.rb

@@ -3,7 +3,8 @@
 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 which affects the result of any computation like
+  # `#to_seconds`.
   #
   # @example
   #     d = ISO8601::Duration.new('P2Y1MT2H')
@@ -14,11 +15,16 @@ module ISO8601
   #     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...>>
+  #     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
   #
   # @example Number of seconds versus patterns
@@ -111,49 +117,40 @@ module ISO8601
     ##
     # Addition
     #
-    # @param [ISO8601::Duration] duration The duration to add
+    # @param [ISO8601::Duration] other The duration to add
     #
     # @raise [ISO8601::Errors::DurationBaseError] If bases doesn't match
     # @return [ISO8601::Duration]
-    def +(duration)
-      compare_bases(duration)
-
-      d1 = to_seconds
-      d2 = duration.to_seconds
-
-      seconds_to_iso(d1 + d2)
+    def +(other)
+      compare_bases(other)
+      seconds_to_iso(to_seconds + other.to_seconds)
     end
     ##
     # Substraction
     #
-    # @param [ISO8601::Duration] duration The duration to substract
+    # @param [ISO8601::Duration] other The duration to substract
     #
     # @raise [ISO8601::Errors::DurationBaseError] If bases doesn't match
     # @return [ISO8601::Duration]
-    def -(duration)
-      compare_bases(duration)
-
-      d1 = to_seconds
-      d2 = duration.to_seconds
-
-      seconds_to_iso(d1 - d2)
+    def -(other)
+      compare_bases(other)
+      seconds_to_iso(to_seconds - other.to_seconds)
     end
     ##
-    # @param [ISO8601::Duration] duration The duration to compare
+    # @param [ISO8601::Duration] other The duration to compare
     #
     # @raise [ISO8601::Errors::DurationBaseError] If bases doesn't match
     # @return [Boolean]
-    def ==(duration)
-      compare_bases(duration)
-
-      (to_seconds == duration.to_seconds)
+    def ==(other)
+      compare_bases(other)
+      (to_seconds == other.to_seconds)
     end
     ##
-    # @param [ISO8601::Duration] duration The duration to compare
+    # @param [ISO8601::Duration] other The duration to compare
     #
     # @return [Boolean]
-    def eql?(duration)
-      (hash == duration.hash)
+    def eql?(other)
+      (hash == other.hash)
     end
     ##
     # @return [Fixnum]
@@ -165,16 +162,17 @@ module ISO8601
     #
     # @return [String]
     def to_pattern
-      (@original.kind_of? Numeric) ? "PT#{@original}S" : @original
+      (@original.is_a? 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(&:+)
+      atoms = [years, months, weeks, days, hours, minutes, seconds]
+      atoms.map(&:to_seconds).reduce(&:+)
     end
 
-
     private
+
     ##
     # Splits a duration pattern into valid atoms.
     #
@@ -207,15 +205,17 @@ module ISO8601
           ) |
           (?<weeks>\d+(?:[.,]\d+)?W)
         ) # Duration
-      $/x) or raise ISO8601::Errors::UnknownPattern.new(input)
+      $/x) || fail(ISO8601::Errors::UnknownPattern, input)
 
       valid_pattern?(duration)
 
-      @sign = (duration[:sign].nil? || duration[:sign] == '+') ? 1 : -1
+      @sign = (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 = 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)
@@ -258,31 +258,36 @@ module ISO8601
     end
 
     def validate_base(input)
-      raise ISO8601::Errors::TypeError if !(input.nil? or input.kind_of? ISO8601::DateTime)
+      fail ISO8601::Errors::TypeError unless input.nil? || input.is_a?(ISO8601::DateTime)
 
       input
     end
+
     def valid_pattern?(components)
-      date = [components[:years], components[:months], components[:days]].compact
-      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
 
-      if all.empty? || (!components[:time].nil? && time.empty? && weeks.nil?)
-        raise ISO8601::Errors::UnknownPattern.new(@pattern)
-      end
+      missing_time = (weeks.nil? && !components[:time].nil? && time.empty?)
+      empty = missing_time || all.empty?
+      fail ISO8601::Errors::UnknownPattern, @pattern if empty
     end
 
     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(@pattern)
-      end
+      consistent = (fractions.size == 1 && fractions.last != values.last)
+
+      fail ISO8601::Errors::InvalidFractions if fractions.size > 1 || consistent
     end
 
-    def compare_bases(duration)
-      raise ISO8601::Errors::DurationBaseError.new(duration) if base.to_s != duration.base.to_s
+    def compare_bases(other)
+      fail ISO8601::Errors::DurationBaseError, other if base != other.base
     end
   end
 end

data/lib/iso8601/errors.rb

@@ -1,23 +1,20 @@
-# encoding: utf-8
-
 module ISO8601
   ##
   # Contains all ISO8601-specific errors.
   module Errors
-
     class StandardError < ::StandardError
     end
     ##
     # Raised when the given pattern doesn't fit as ISO 8601 parser.
     class UnknownPattern < StandardError
       def initialize(pattern)
-        super("The pattern “#{pattern}” is not allowed in this implementation of ISO8601.")
+        super("Unknown pattern #{pattern}")
       end
     end
     ##
     # Raised when the given pattern contains an invalid fraction.
     class InvalidFractions < StandardError
-      def initialize(pattern)
+      def initialize
         super("Fractions are only allowed in the last component")
       end
     end
@@ -25,7 +22,7 @@ module ISO8601
     # Raised when the given date is valid but out of range.
     class RangeError < StandardError
       def initialize(pattern)
-        super("“#{pattern}” is out of range")
+        super("#{pattern} is out of range")
       end
     end
     ##

data/lib/iso8601/time.rb

@@ -12,9 +12,11 @@ module ISO8601
   class Time
     extend Forwardable
 
-    def_delegators(:@time,
+    def_delegators(
+      :@time,
       :to_time, :to_date, :to_datetime,
-      :hour, :minute, :zone)
+      :hour, :minute, :zone
+    )
     ##
     # The separator used in the original ISO 8601 string.
     attr_reader :separator
@@ -39,18 +41,18 @@ module ISO8601
       @second = @time.second + @time.second_fraction.to_f
     end
     ##
-    # @param [#hash] contrast The contrast to compare against
+    # @param [#hash] other The contrast to compare against
     #
     # @return [Boolean]
-    def ==(contrast)
-      (hash == contrast.hash)
+    def ==(other)
+      (hash == other.hash)
     end
     ##
-    # @param [#hash] contrast The contrast to compare against
+    # @param [#hash] other The contrast to compare against
     #
     # @return [Boolean]
-    def eql?(contrast)
-      (hash == contrast.hash)
+    def eql?(other)
+      (hash == other.hash)
     end
     ##
     # @return [Fixnum]
@@ -60,26 +62,28 @@ module ISO8601
     ##
     # Forwards the time the given amount of seconds.
     #
-    # @param [Numeric] seconds The seconds to add
+    # @param [Numeric] other The seconds to add
     #
     # @return [ISO8601::Time] New time resulting of the addition
-    def +(seconds)
-      moment = @time.to_time.localtime(zone) + seconds
+    def +(other)
+      moment = @time.to_time.localtime(zone) + other
       format = moment.subsec.zero? ? FORMAT : FORMAT_WITH_FRACTION
+      base = ::Date.parse(moment.strftime('%Y-%m-%d'))
 
-      ISO8601::Time.new(moment.strftime(format), ::Date.parse(moment.strftime('%Y-%m-%d')))
+      ISO8601::Time.new(moment.strftime(format), base)
     end
     ##
     # Backwards the date the given amount of seconds.
     #
-    # @param [Numeric] seconds The seconds to remove
+    # @param [Numeric] other The seconds to remove
     #
     # @return [ISO8601::Time] New time resulting of the substraction
-    def -(seconds)
-      moment = @time.to_time.localtime(zone) - seconds
+    def -(other)
+      moment = @time.to_time.localtime(zone) - other
       format = moment.subsec.zero? ? FORMAT : FORMAT_WITH_FRACTION
+      base = ::Date.parse(moment.strftime('%Y-%m-%d'))
 
-      ISO8601::Time.new(moment.strftime(format), ::Date.parse(moment.strftime('%Y-%m-%d')))
+      ISO8601::Time.new(moment.strftime(format), base)
     end
     ##
     # Converts self to a time component representation.
@@ -94,6 +98,7 @@ module ISO8601
     end
 
     private
+
     ##
     # Splits the time component into valid atoms.
     # Acceptable patterns: hh, hh:mm or hhmm and hh:mm:ss or hhmmss. Any form
@@ -111,7 +116,7 @@ module ISO8601
         (\d{2})
       )$/x.match(time).to_a.compact
 
-      raise ISO8601::Errors::UnknownPattern.new(@original) if hour.nil?
+      fail ISO8601::Errors::UnknownPattern, @original if hour.nil?
 
       @separator = separator
 
@@ -119,13 +124,14 @@ module ISO8601
       minute &&= minute.to_i
       second &&= second.to_f
 
-      raise ISO8601::Errors::UnknownPattern.new(@original) unless valid_zone?(zone)
+      fail ISO8601::Errors::UnknownPattern, @original unless valid_zone?(zone)
 
       [hour, minute, second, zone].compact
     end
 
     def valid_zone?(zone)
-      _, offset, separator = /^(Z|[+-]\d{2}(?:(:?)\d{2})?)$/.match(zone).to_a.compact
+      zone_regexp = /^(Z|[+-]\d{2}(?:(:?)\d{2})?)$/
+      _, offset, separator = zone_regexp.match(zone).to_a.compact
 
       wrong_pattern = !zone.nil? && offset.nil?
       invalid_separators = zone.to_s.match(/^[+-]\d{2}:?\d{2}$/) && (@separator != separator)

data/lib/iso8601/version.rb

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

data/spec/iso8601/duration_spec.rb

@@ -221,6 +221,7 @@ RSpec.describe ISO8601::Duration do
       it "should return the seconds of a -PT[n]H[n]M duration" do
         expect(ISO8601::Duration.new('-PT10S', ISO8601::DateTime.new('2012-01-01T00:00:00')).to_seconds).to eq(Time.utc(2011, 12, 31, 23, 59, 50) - Time.utc(2012, 1))
         expect(ISO8601::Duration.new('-PT10.4S', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(-10.4)
+        expect(ISO8601::Duration.new('-PT10,4S', ISO8601::DateTime.new('2012-01-01')).to_seconds).to eq(-10.4)
       end
     end
   end
@@ -250,7 +251,7 @@ RSpec.describe ISO8601::Duration do
       expect(subject).to respond_to(:eql?)
     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('PT1H')).to be_truthy
       expect(ISO8601::Duration.new('PT1H').eql? ISO8601::Duration.new('PT60M')).to be_falsy
     end
 

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-$:.unshift File.expand_path('..', __FILE__)
+$LOAD_PATH.unshift File.expand_path('..', __FILE__)
 require 'iso8601'
 
 RSpec.configure do |config|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iso8601
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Arnau Siches
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-06 00:00:00.000000000 Z
+date: 2014-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -25,28 +25,30 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.1'
 - !ruby/object:Gem::Dependency
-  name: rerun
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.26'
   type: :development
   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"
+        version: '0.26'
+description: |2
+      ISO8601 is a simple implementation in Ruby of the ISO 8601 (Data elements and
+      interchange formats - Information interchange - Representation of dates
+      and times) standard.
 email: arnau.siches@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".travis.yml"
 - CHANGELOG.md
 - Gemfile
@@ -80,7 +82,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="