iso8601 0.1.1

data/README.md

@@ -0,0 +1,28 @@
+# ISO8601
+
+ISO8601 is a simple implementation of the ISO 8601 (Data elements and 
+interchange formats — Information interchange — Representation of dates and 
+times) standard.
+
+## Comments
+
+Because Durations and DateTime has substract method, Durations has sign 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"`
+
+
+## TODO
+
+* Decimal fraction in dateTime and duration patterns
+* Recurring time intervals
+* Ordinal date pattern (YYYY-DDD)
+* Week date pattern (YYYY-Www-D)
+
+## Contributors
+
+* [Nick Lynch](https://github.com/njlynch)
+* [Pelle Braendgaard](https://github.com/pelle)
+
+## Credits
+Arnau Siches under [LGPL](http://www.gnu.org/licenses/lgpl.html) license. LICENSE file for details.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/iso8601.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "iso8601"
+
+Gem::Specification.new do |s|
+  s.name        = "iso8601"
+  s.version     = ISO8601::VERSION
+  s.authors     = ["Arnau Siches"]
+  s.email       = ["arnau.siches@gmail.com"]
+  s.homepage    = "https://github.com/arnau/ISO8601"
+  s.summary     = %q{Ruby parser to work with ISO8601 dateTimes and durations - http://en.wikipedia.org/wiki/ISO_8601}
+  s.description = %q{ISO8601 is a simple implementation of the ISO 8601 (Data elements and
+  interchange formats - Information interchange - Representation of dates and
+  times) standard.}
+
+  s.rubyforge_project = "iso8601"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/lib/iso8601.rb

@@ -0,0 +1,10 @@
+module ISO8601
+  VERSION = "0.1.1"
+end
+
+require "time"
+
+require "iso8601/errors"
+require "iso8601/atoms"
+require "iso8601/dateTime"
+require "iso8601/duration"

data/lib/iso8601/atoms.rb

@@ -0,0 +1,114 @@
+module ISO8601
+
+  # Represents a generic atom in a +ISO8601::Duration+.
+  class Atom
+    def initialize(atom, base=nil)
+      is_number?(atom, "First argument for #{self.inspect} must be an Integer or a Float.")
+      @atom = atom
+      @base = base
+    end
+
+    def to_i
+      @atom
+    end
+    def to_seconds
+      @atom * self.factor
+    end
+
+    private
+      def is_number?(arg, error_message=nil)
+        raise TypeError, error_message unless (arg.is_a? Integer or arg.is_a? Float)
+      end
+  end
+
+  # 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”.
+
+  #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 “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”.
+    def factor
+      if @base.nil?
+        ((365 * 303 + 366 * 97) / 400) * 86400
+      elsif @atom == 0
+        0
+      else
+        year = (@base.year + @atom).to_i
+        (Time.utc(year) - Time.utc(@base.year)) / @atom
+      end
+    end
+  end
+
+  # 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”
+  # depending on the start and/or the end of the corresponding time interval
+  # within the specific “calendar month”.
+  class Months < ISO8601::Atom
+
+    # 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?
+        (((365 * 303 + 366 * 97) / 400) * 86400) / 12
+      elsif @atom == 0
+        0
+      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
+      end
+    end
+  end
+
+  class Weeks < ISO8601::Atom
+
+    # A week is equal to 604800 seconds.
+    def factor
+      604800
+    end
+  end
+
+  # 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
+
+    # A day is equal to 86400 seconds.
+    def factor
+      86400
+    end
+  end
+
+  class Hours < ISO8601::Atom
+
+    # An hour is equal to 3600 seconds.
+    def factor
+      3600
+    end
+  end
+  class Minutes < ISO8601::Atom
+
+    # A minute is equal to 60 seconds.
+    def factor
+      60
+    end
+  end
+
+  # 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)
+  class Seconds < ISO8601::Atom
+    def factor
+      1
+    end
+  end
+end

data/lib/iso8601/dateTime.rb

@@ -0,0 +1,104 @@
+module ISO8601
+  class DateTime
+    attr_reader :date_time, :century, :year, :month, :day, :hour, :minute, :second, :timezone
+    def initialize(date_time)
+      @dt = /^(?:
+                (\d{2})(\d{2})?
+                (?:
+                  (-)?(\d{2})
+                )?
+                (?:
+                  (\3)?(\d{2})
+                )?
+              )?
+              (?:
+                T(\d{2})
+                (?:
+                  (:)?(\d{2})
+                )?
+                (?:
+                  (\8)?(\d{2})
+                )?
+                (
+                  Z|([+-])
+                    (\d{2})
+                    (?:
+                      (\8)?
+                      (\d{2})
+                    )?
+                )?
+              )?
+            $/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[14].to_i
+      }
+
+      valid_pattern?
+      valid_range?
+    end
+    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
+    end
+    def +(d)
+      raise TypeError unless (d.is_a? Float or d.is_a? Integer)
+      Time.utc(@year, @month, @day, @hour, @minute, @second) + d
+    end
+    def -(d)
+      raise TypeError unless (d.is_a? Float or d.is_a? Integer or d.is_a? ISO8601::DateTime)
+      if (d.is_a? ISO8601::DateTime)
+        Time.utc(@year, @month, @day, @hour, @minute, @second) - Time.utc(d.year, d.month, d.day, d.hour, d.minute, d.second)
+      else
+        Time.utc(@year, @month, @day, @hour, @minute, @second) - d
+      end
+    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 => e
+        raise RangeError
+      end
+  end
+end

data/lib/iso8601/duration.rb

@@ -0,0 +1,140 @@
+module ISO8601
+
+  # Represents a duration in ISO 8601 format
+  class Duration
+    attr_reader :base, :atoms
+    def initialize(duration, base = nil)
+      @duration = /^(\+|-)?P(((\d+Y)?(\d+M)?(\d+D)?(T(\d+H)?(\d+M)?(\d+S)?)?)|(\d+W))$/.match(duration)
+      @base = base #date base for duration calculations
+      valid_pattern?
+      valid_base?
+      @atoms = {
+        :years => @duration[4].nil? ? 0 : @duration[4].chop.to_f * sign,
+        :months => @duration[5].nil? ? 0 : @duration[5].chop.to_f * sign,
+        :weeks => @duration[11].nil? ? 0 : @duration[11].chop.to_f * sign,
+        :days => @duration[6].nil? ? 0 : @duration[6].chop.to_f * sign,
+        :hours => @duration[8].nil? ? 0 : @duration[8].chop.to_f * sign,
+        :minutes => @duration[9].nil? ? 0 : @duration[9].chop.to_f * sign,
+        :seconds => @duration[10].nil? ? 0 : @duration[10].chop.to_f * sign
+      }
+    end
+
+    def base=(value)
+      @base = value
+      return @base
+    end
+
+    # Returns the original string of the duration
+    def to_s
+      @duration[0]
+    end
+
+    # Returns the years of the duration
+    def years
+      ISO8601::Years.new(@atoms[:years], @base)
+    end
+
+    # Returns the months of the duration
+    def months
+      base = @base.nil? ? nil : @base + self.years.to_seconds # prevent computing duplicated time
+      ISO8601::Months.new(@atoms[:months], base)
+    end
+
+    # Returns the weeks of the duration
+    def weeks
+      ISO8601::Weeks.new(@atoms[:weeks], @base)
+    end
+
+    # Returns the days of the duration
+    def days
+      ISO8601::Days.new(@atoms[:days], @base)
+    end
+
+    # Returns the hours of the duration
+    def hours
+      ISO8601::Hours.new(@atoms[:hours], @base)
+    end
+
+    # Returns the minutes of the duration
+    def minutes
+      ISO8601::Minutes.new(@atoms[:minutes], @base)
+    end
+
+    # Returns the seconds of the duration
+    def seconds
+      ISO8601::Seconds.new(@atoms[:seconds], @base)
+    end
+
+    # Returns the duration in seconds
+    def to_seconds
+      years, months, weeks, days, hours, minutes, seconds = self.years.to_seconds, self.months.to_seconds, self.weeks.to_seconds, self.days.to_seconds, self.hours.to_seconds, self.minutes.to_seconds, self.seconds.to_seconds
+      return years + months + weeks + days + hours + minutes + seconds
+    end
+
+    # Returns the absolute value of duration
+    def abs
+      return self.to_s.sub!(/^[-+]/, "")
+    end
+
+    def +(duration)
+      raise ISO8601::Errors::DurationBaseError.new(duration) if self.base != duration.base
+      d1 = self.to_seconds
+      d2 = duration.to_seconds
+      return self.seconds_to_iso(d1 + d2)
+    end
+    def -(duration)
+      raise ISO8601::Errors::DurationBaseError.new(duration) if self.base != duration.base
+      d1 = self.to_seconds
+      d2 = duration.to_seconds
+      return self.seconds_to_iso(d1 - d2)
+      # return d1 - d2
+    end
+
+    # Convenience method to turn instance method (which can take into
+    # account a base time or duration) into a simple class method.
+    def self.seconds_to_iso(duration)
+      return ISO8601::Duration.new('P0Y').seconds_to_iso(duration)
+    end
+
+    def seconds_to_iso(duration)
+      sign = "-" if (duration < 0)
+      duration = duration.abs
+      years, y_mod = (duration / self.years.factor).to_i, (duration % self.years.factor)
+      months, m_mod = (y_mod / self.months.factor).to_i, (y_mod % self.months.factor)
+      days, d_mod = (m_mod / self.days.factor).to_i, (m_mod % self.days.factor)
+      hours, h_mod = (d_mod / self.hours.factor).to_i, (d_mod % self.hours.factor)
+      minutes, mi_mod = (h_mod / self.minutes.factor).to_i, (h_mod % self.minutes.factor)
+      seconds = mi_mod.to_i
+
+      seconds = (seconds != 0 or (years == 0 and months == 0 and days == 0 and hours == 0 and minutes == 0)) ? "#{seconds}S" : ""
+      minutes = (minutes != 0) ? "#{minutes}M" : ""
+      hours = (hours != 0) ? "#{hours}H" : ""
+      days = (days != 0) ? "#{days}D" : ""
+      months = (months != 0) ? "#{months}M" : ""
+      years = (years != 0) ? "#{years}Y" : ""
+
+      date = %[#{sign}P#{years}#{months}#{days}]
+      time = (hours != "" or minutes != "" or seconds != "") ? %[T#{hours}#{minutes}#{seconds}] : ""
+      date_time = date + time
+      return ISO8601::Duration.new(date_time)
+    end
+
+    private
+      def sign
+        (@duration[1].nil? or @duration[1] == "+") ? 1 : -1
+      end
+      def valid_base?
+        if !(@base.is_a? NilClass or @base.is_a? ISO8601::DateTime)
+          raise TypeError
+        end
+      end
+      def valid_pattern?
+        if @duration.nil? or
+           (@duration[4].nil? and @duration[5].nil? and @duration[6].nil? and @duration[7].nil? and @duration[11].nil?) or
+           (!@duration[7].nil? and @duration[8].nil? and @duration[9].nil? and @duration[10].nil? and @duration[11].nil?)
+
+          raise ISO8601::Errors::UnknownPattern.new(@duration)
+        end
+      end
+  end
+end

data/lib/iso8601/errors.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+module ISO8601
+
+  # Contains all ISO8601-specific errors.
+  module Errors
+
+    # Error that is raised when unknown pattern is parsed.
+    class UnknownPattern < ::StandardError
+      def initialize(pattern)
+        super("The pattern “#{pattern}” is not allowed in this implementation of ISO8601.")
+      end
+    end
+    class DurationError < ::StandardError
+      def initialize(duration)
+        super("Unexpected type of duration “#{duration}”.")
+      end
+    end
+    class DurationBaseError < ISO8601::Errors::DurationError
+      def initialize(duration)
+        super("Wrong base for #{duration} duration.")
+      end
+    end
+  end
+end