iso8601 0.4.1 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7f9e6e9d7f640ea9bb6d3393080c7fe50f4a1b68
+  data.tar.gz: 45717b674acf7e8eb1a5193f398d52320d4fce89
+SHA512:
+  metadata.gz: 40249de2e3e817cb21e7c441ab3ffd1e18a852ebaf76241e913f9275924dc710dd0d9acad440778c5241ff0d6a8be7f430bab6ae9ebc66aaf03ff5373c16f9d2
+  data.tar.gz: 3733a36fb5764007920b519bed2cc938d76382416ab6592140b74dbd32ca014c8804d8ce973efe7aea9c55ca28db3cdadefcf051469b4659d8d3d670c0aa3fac

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 rvm:
-  - 1.8.7
-  - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1.2
+  - rbx-2
 script: bundle exec rspec spec

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Arnau Siches
+Copyright (c) 2012-2014 Arnau Siches
 
 MIT License
 

data/README.md

@@ -1,46 +1,107 @@
 # ISO8601
 
-ISO8601 is a simple implementation of the ISO 8601 (Data elements and 
-interchange formats — Information interchange — Representation of dates and 
+ISO8601 is a simple implementation of the ISO 8601 (Data elements and
+interchange formats — Information interchange — Representation of dates and
 times) standard.
 
 ## Build status
 
 [![Build Status](https://secure.travis-ci.org/arnau/ISO8601.png?branch=master)](http://travis-ci.org/arnau/ISO8601/)
 
+## Supported versions
+
+* MRI 1.9.3
+* MRI 2.0
+* MRI 2.1
+* RBX 2
+
 
 ## Comments
 
 ### 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 has a substraction method, Durations has
+sign to be able to represent a negative value:
 
-    (ISO8601::Duration.new('PT10S') - ISO8601::Duration.new('PT12S')).to_s #=> '-PT2S'
+    (ISO8601::Duration.new('PT10S') - ISO8601::Duration.new('PT12S')).to_s  #=> '-PT2S'
     (ISO8601::Duration.new('-PT10S') + ISO8601::Duration.new('PT12S')).to_s #=> 'PT2S'
 
-### Separators
 
-Although, the spec allows three separator types: period (.), comma (,), and raised period (·) by now I keep just the period option.
+## Differences with core Date, Time and DateTime
+
+Core `Date.parse` and `DateTime.parse` doesn't allow reduced precision. For
+example:
+
+    DateTime.parse('2014-05') # => ArgumentError: invalid date
+
+But the standard covers this situation assuming any missing piece as its lower
+value:
+
+    ISO8601::DateTime.new('2014-05').to_s # => "2014-05-01T00:00:00+00:00"
+    ISO8601::DateTime.new('2014').to_s # => "2014-01-01T00:00:00+00:00"
+
+The same assumption happens in core classes with `.new`:
+
+    DateTime.new(2014,5) # => #<DateTime: 2014-05-01T00:00:00+00:00 ((2456779j,0s,0n),+0s,2299161j)>
+    DateTime.new(2014) # => #<DateTime: 2014-01-01T00:00:00+00:00 ((2456659j,0s,0n),+0s,2299161j)>
+
+
+The value of second in core classes are handled by two methods: `#second` and
+`#second_fraction`:
+
+    dt = DateTime.parse('2014-05-06T10:11:12.5')
+    dt.second # => 12
+    dt.second_fraction # => (1/2)
+
+This gem approaches second fraction using floats:
 
-### Century treatment
+    dt = ISO8601::DateTime.new('2014-05-06T10:11:12.5')
+    dt.second # => 12.5
 
-The specification says that you can express a reduced precision year
-just giving the century (i.e. '20' to refer the inclusive range 2000-2999).
+Unmatching precison is handled strongly. Notice the time fragment is lost in
+`DateTime.parse` without warning only if the loose precision is in the time
+component.
 
-This implementation expands the century to the first value for its range
-so:
+    ISO8601::DateTime.new('2014-05-06T101112')  # => ISO8601::Errors::UnknownPattern
+    DateTime.parse('2014-05-06T101112')  # => #<DateTime: 2014-05-06T00:00:00+00:00 ((2456784j,0s,0n),+0s,2299161j)>
 
-    ISO8601::DateTime.new('20').century # => 20
-    ISO8601::DateTime.new('20').year # => 2000
+    ISO8601::DateTime.new('20140506T10:11:12')  # => ISO8601::Errors::UnknownPattern
+    DateTime.parse('20140506T10:11:12')  # => #<DateTime: 2014-05-06T10:11:12+00:00 ((2456784j,0s,0n),+0s,2299161j)>
+
+
+`DateTime#to_a` allow decomposing to an array of atoms:
+
+    atoms = ISO8601::DateTime.new('2014-05-31T10:11:12Z').to_a # => [2014, 5, 31, 10, 11, 12, '+00:00']
+    dt = DateTime.new(*atoms)
+
+Ordinal dates keep the sign. `2014-001` is not the same as `-2014-001`.
+
+Week dates raise an error when two digit days provied instead of return monday:
+
+    ISO8601::DateTime.new('2014-W15-02') # => ISO8601::Errors::UnknownPattern
+    DateTime.new('2014-W15-02')  # => #<Date: 2014-04-07 ((2456755j,0s,0n),+0s,2299161j)>
+
+
+## Changes since 0.5
+
+* Drop support for Ruby 1.8.7
+* Add support for Rubinius 2
+* `ISO8601::DateTime#century` no longer exists. Truncated representations were
+removed in ISO 8601:2004.
+* `ISO8601::DateTime#zone` delegates to core `DateTime#zone`.
+* `ISO8601::DateTime#timezone` no longer exists. Now it delegates to
+`DateTime#zone`.
+* A date can have sign: `-1000-01-01`, `+2014-05-06T10:11:12Z`.
+* A date time can be converted to an array of atoms with `#to_a`.
+* Ordinal dates supported.
+* A date component is represented by `ISO8601::Date`.
+* Week date pattern (YYYY-Wdww, YYYY-Www-D).
 
 
 ## TODO
 
-* Decimal fraction in dateTime patterns
 * Recurring time intervals
-* Ordinal date pattern (YYYY-DDD)
-* Week date pattern (YYYY-Www-D)
-* Treat the `201005` as `2000-10-05` instead of `2010-05`
+
 
 ## Contributors
 
@@ -53,4 +114,3 @@ so:
 ## License
 
 Arnau Siches under the [MIT License](https://github.com/arnau/ISO8601/blob/master/LICENSE)
-

data/iso8601.gemspec

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 $:.push File.expand_path('../lib', __FILE__)
-require 'iso8601'
+require 'iso8601/version'
 
 Gem::Specification.new do |s|
   s.name = 'iso8601'
@@ -25,6 +25,6 @@ Gem::Specification.new do |s|
 
   s.has_rdoc = 'yard'
 
-  s.add_development_dependency 'rspec', '~> 2.0'
-  s.add_development_dependency 'ZenTest', '~> 4.8'
+  s.add_development_dependency 'rspec', '~> 2.14'
+  s.add_development_dependency 'rerun'
 end

data/lib/iso8601.rb

@@ -1,12 +1,12 @@
 # encoding: utf-8
 
-module ISO8601
-  VERSION = '0.4.1'
-end
-
 require 'time'
+require 'forwardable'
 
+require 'iso8601/version'
 require 'iso8601/errors'
 require 'iso8601/atoms'
+require 'iso8601/date'
+require 'iso8601/time'
 require 'iso8601/dateTime'
 require 'iso8601/duration'

data/lib/iso8601/atoms.rb

@@ -54,10 +54,10 @@ module ISO8601
         ((365 * 303 + 366 * 97) / 400) * 86400
       elsif @atom == 0
         year = (@base.year).to_i
-        (Time.utc(year) - Time.utc(@base.year))
+        (::Time.utc(year) - ::Time.utc(@base.year))
       else
         year = (@base.year + @atom).to_i
-        (Time.utc(year) - Time.utc(@base.year)) / @atom
+        (::Time.utc(year) - ::Time.utc(@base.year)) / @atom
       end
     end
   end
@@ -83,11 +83,11 @@ module ISO8601
       elsif @atom == 0
         month = (@base.month <= 12) ? (@base.month) : ((@base.month) % 12)
         year = @base.year + ((@base.month) / 12).to_i
-        (Time.utc(year, month) - Time.utc(@base.year, @base.month))
+        (::Time.utc(year, month) - ::Time.utc(@base.year, @base.month))
       else
         month = (@base.month + @atom <= 12) ? (@base.month + @atom) : ((@base.month + @atom) % 12)
         year = @base.year + ((@base.month + @atom) / 12).to_i
-        (Time.utc(year, month) - Time.utc(@base.year, @base.month)) / @atom
+        (::Time.utc(year, month) - ::Time.utc(@base.year, @base.month)) / @atom
       end
     end
   end

data/lib/iso8601/date.rb

@@ -0,0 +1,125 @@
+module ISO8601
+  ##
+  # A Date representation
+  #
+  # @example
+  #     d = Date.new('2014-05-28')
+  #     d.year  # => 2014
+  #     d.month # => 5
+  #
+  # @example Week dates
+  #     d = Date.new('2014-W15-2')
+  #     d.day   # => 27
+  #     d.wday  # => 2
+  #     d.week # => 15
+  class Date
+    extend Forwardable
+
+    def_delegators(:@date,
+      :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)
+      @original = input
+
+      @atoms = atomize(input)
+      @date = ::Date.new(*@atoms)
+    rescue ArgumentError => error
+      raise ISO8601::Errors::RangeError, input
+    end
+    ##
+    # The calendar week number (1-53)
+    def week
+      @date.cweek
+    end
+    ##
+    # Forwards the date the given amount of days.
+    #
+    # @param [Numeric] days The days to add
+    #
+    # @return [ISO8601::Date] New date resulting of the addition
+    def +(days)
+      ISO8601::Date.new((@date + days).iso8601)
+    end
+    ##
+    # Backwards the date the given amount of days.
+    #
+    # @param [Numeric] days The days to remove
+    #
+    # @return [ISO8601::Date] New date resulting of the substraction
+    def -(days)
+      ISO8601::Date.new((@date - days).iso8601)
+    end
+    ##
+    # Converts self to an array of atoms.
+    def to_a
+      [year, month, day]
+    end
+
+    private
+    ##
+    # Splits the date component into valid atoms.
+    #
+    # Acceptable patterns:
+    #
+    # * YYYY
+    # * YYYY-MM but not YYYYMM
+    # * YYYY-MM-DD, YYYYMMDD
+    # * YYYY-Www, YYYYWdd
+    # * YYYY-Www-D, YYYYWddD
+    #
+    # @param [String] input
+    #
+    # @return [Array<Integer>]
+    def atomize(input)
+      _, year, separator, month, day = /^(?:
+        ([+-]?\d{4})(-?)(\d{2})\2(\d{2}) | # YYYY-MM-DD
+        ([+-]?\d{4})(-?)(\d{3}) |          # YYYY-DDD
+        ([+-]?\d{4})(-)(\d{2}) |           # YYYY-MM
+        ([+-]?\d{4})                       # YYYY
+      )$/x.match(input).to_a.compact
+
+      if year.nil?
+        # Check if it's a Week date
+        _, year, separator, week, wday = /^(?:
+          ([+-]?\d{4})(-?)(W\d{2})\2(\d) | # YYYY-Www-D
+          ([+-]?\d{4})(-?)(W\d{2})         # YYYY-Www
+        )$/x.match(input).to_a.compact
+
+        unless week.nil?
+          d = ::Date.parse(input)
+          year = d.year
+          month = d.month
+          day = d.day
+        end
+      end
+
+      raise ISO8601::Errors::UnknownPattern.new(@original) if year.nil?
+
+      @separator = separator
+
+      return atomize_ordinal(year, month) if month && month.to_s.length == 3
+
+      [year, month, day].compact.map(&:to_i)
+    end
+    ##
+    # Parses an ordinal date (YYYY-DDD) and returns its atoms.
+    #
+    # @param [String] year in YYYY form.
+    # @param [String] day in DDD form.
+    #
+    # @return [Array<Integer>] date atoms
+    def atomize_ordinal(year, day)
+      date = ::Date.parse([year, day].join('-'))
+
+      [date.year, date.month, date.day]
+    end
+  end
+end

data/lib/iso8601/dateTime.rb

@@ -4,124 +4,120 @@ module ISO8601
   ##
   # A DateTime representation
   #
-  # @todo Review the pattern `201005`. It has to be `20-10-05` instead of `2010-05`.
-  #   The specification doesn't allow a YYYYMM. It should be always
-  #   YYYY-MM.
+  # @example
+  #     dt = DateTime.new('2014-05-28T19:53Z')
+  #     dt.year #=> 2014
   class DateTime
-    attr_reader :century, :year, :month, :day, :hour, :minute, :second, :timezone
+    extend Forwardable
+
+    def_delegators(:@date_time,
+      :strftime, :to_time, :to_date, :to_datetime,
+      :year, :month, :day, :hour, :minute, :zone)
+
+    attr_reader :second
+
     ##
     # @param [String] date_time The datetime pattern
     def initialize(date_time)
-      @dt = /^(?:
-                (\d{2})(\d{2})? # Year. It can be either two digits (the century) or four digits (the full year)
-                (?:
-                  (-)?(\d{2})
-                )? # Month with an optional separator
-                (?:
-                  (\3)?(\d{2}) # Day with an optional separator which is the same for the Month
-                )?
-              )? # Date
-              (?:
-                T(\d{2}) # Hour
-                (?:
-                  (:)?(\d{2}) # Minute with an optional separator
-                )?
-                (?:
-                  (\8)?(\d{2}) # Second with an optional separator which is the same that for the Minute
-                )? # Time
-                (
-                  Z|([+-])
-                    (\d{2}) # Timezone hour
-                    (?:
-                      (\8)? # Separator which should be the same that for the Minute
-                      (\d{2}) # Timezone minute
-                    )?
-                )? # Timezone
-              )?
-            $/x.match(date_time) or raise ISO8601::Errors::UnknownPattern.new(date_time)
-
-      @date_time = date_time
-      @time = @dt[7]
-      @date_separator = @dt[3] == @dt[5] ? @dt[3] : nil
-      @time_separator = 
-      if (!@dt[8].nil? and (!@dt[10].nil? and !@dt[11].nil?) and (!@dt[15].nil? and !@dt[16].nil?)) or
-         (!@dt[8].nil? and (!@dt[10].nil? and !@dt[11].nil?) and @dt[16].nil?) or
-         (!@dt[8].nil? and @dt[11].nil? and @dt[16].nil?)
-        @dt[8]
-      else
-        nil
-      end
-      @century = @dt[1].to_i
-      @year = @dt[2].nil? ? nil : (@dt[1] + @dt[2]).to_i
-      @month = @dt[4].nil? ? nil : @dt[4].to_i
-      @day = @dt[6].nil? ? nil : @dt[6].to_i
-      @hour = @dt[7].nil? ? nil : @dt[7].to_i
-      @minute = @dt[9].nil? ? nil : @dt[9].to_i
-      @second = @dt[11].nil? ? nil : @dt[11].to_i
-      @timezone = {
-        :full => @dt[12].nil? ? (Time.now.gmt_offset / 3600) : (@dt[12] == "Z" ? 0 : @dt[12]),
-        :sign => @dt[13],
-        :hour => @dt[12].nil? ? (Time.now.gmt_offset / 3600) : (@dt[12] == "Z" ? 0 : @dt[14].to_i),
-        :minute => (@dt[12].nil? or @dt[12] == "Z") ? 0 : @dt[13].to_i
-      }
-
-      valid_pattern?
-      valid_range?
+      @original = date_time
+      @date_time = parse(date_time)
+      @second = @date_time.second + @date_time.second_fraction.to_f
     end
     ##
-    # Returns the datetime string representation
-    def to_s
-      @date_time
+    # Addition
+    #
+    # @param [Numeric] seconds The seconds to add
+    def +(seconds)
+      moment = @date_time.to_time.localtime(zone) + seconds
+      format = moment.subsec.zero? ? "%Y-%m-%dT%H:%M:%S%:z" : "%Y-%m-%dT%H:%M:%S.%16N%:z"
+
+      ISO8601::DateTime.new(moment.strftime(format))
     end
     ##
-    # Converts the object to a Time instance
+    # Substraction
     #
-    # @return [Time] The object converted
-    def to_time
-      raise RangeError if @year.nil?
-      if @month.nil?
-        Time.utc(@year)
-      elsif @day.nil?
-        date = [@year, @month, '01'].join('-')
-        Time.parse(date).getutc
-      else
-        Time.parse(@date_time).getutc
-      end
+    # @param [Numeric] seconds The seconds to substract
+    def -(seconds)
+      moment = @date_time.to_time.localtime(zone) - seconds.round(1)
+      format = moment.subsec.zero? ? "%Y-%m-%dT%H:%M:%S%:z" : "%Y-%m-%dT%H:%M:%S.%2N%:z"
+
+      ISO8601::DateTime.new(moment.strftime(format))
     end
     ##
-    # Addition
+    # Converts DateTime to a formated string
+    def to_s
+      format = @date_time.second_fraction.zero? ? "%Y-%m-%dT%H:%M:%S%:z" : "%Y-%m-%dT%H:%M:%S.%2N%:z"
+      @date_time.strftime(format)
+    end
+    ##
+    # Converts DateTime to an array of atoms.
+    def to_a
+      [year, month, day, hour, minute, second, zone]
+    end
+
+    private
+    ##
+    # Parses an ISO date time, where the date and the time components are
+    # optional.
     #
-    # @param [ISO8601::DateTime] d The seconds to add
-    def +(d)
-      raise TypeError unless d.kind_of? Numeric
-      ISO8601::DateTime.new((Time.utc(@year, @month, @day, @hour, @minute, @second) + d).iso8601)
+    # It enhances the parsing capabilities of the native DateTime.
+    #
+    # @param [String] date_time The ISO representation
+    def parse(date_time)
+      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]
+
+      raise ISO8601::Errors::UnknownPattern, @original unless valid_representation?(date_components, time_components)
+      raise ISO8601::Errors::UnknownPattern, @original unless valid_separators?(separators)
+
+      components = date_components + time_components
+
+      ::DateTime.new(*components.compact)
     end
     ##
-    # Substraction
+    # Validates the date has the right pattern.
+    #
+    # Acceptable patterns: YYYY, YYYY-MM-DD, YYYYMMDD or YYYY-MM but not YYYYMM
     #
-    # @param [ISO8601::DateTime] d The seconds to substract
-    def -(d)
-      raise TypeError unless d.kind_of? Numeric
-      ISO8601::DateTime.new((Time.utc(@year, @month, @day, @hour, @minute, @second) - d).iso8601)
+    # @param [String] input A date component
+    #
+    # @return [Array<String, nil>]
+    def parse_date(input)
+      today = ::Date.today
+      return [today.year, today.month, today.day, :ignore] if input.empty?
+
+      date = ISO8601::Date.new(input)
+
+      date.atoms << date.separator
     end
-    private
-      def valid_pattern?
-        if (@date_separator.nil? and !@time_separator.nil?) or
-           (!@date_separator.nil? and !@time.nil? and @time_separator.nil? and !@minute.nil?) or
-           (@year.nil? and !@month.nil?)
-          raise ISO8601::Errors::UnknownPattern.new(@date_time)
-        elsif (@year.nil? and @month.nil?)
-          @year = (@century.to_s + "00").to_i
-        end
-      end
-      def valid_range?
-        if !month.nil? and (month < 1 or month > 12)
-          raise RangeError
-        elsif !day.nil? and (Time.parse(@date_time).month != month)
-          raise RangeError
-        end
-      rescue ArgumentError
-        raise RangeError
+    ##
+    # @return [Array<String, nil>]
+    def parse_time(input)
+      time = ISO8601::Time.new(input)
+
+      time.atoms << time.separator
+    end
+
+    def valid_separators?(separators)
+      separators = separators.compact
+
+      return true if separators.length == 1 || separators[0] == :ignore
+
+      unless separators.all?(&:empty?)
+        return false if (separators.first.length != separators.last.length)
       end
+      return 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
+
+      date.nil? || !(!year.nil? && (month.nil? || day.nil?) && !hour.nil?)
+    end
   end
 end