Extended maintenance of Ruby 1.9.3 ended on February 23, 2015. Read more

In Files

  • time.rb

Class/Module Index [+]

Quicksearch

Time

Implements the extensions to the Time class that are described in the documentation for the time.rb library.

Public Class Methods

httpdate(date) click to toggle source

Parses date as HTTP-date defined by RFC 2616 and converts it to a Time object.

ArgumentError is raised if date is not compliant with RFC 2616 or Time class cannot represent specified date.

See httpdate for more information on this format.

time library should be required to use this method as follows.

require 'time'
 
               # File time.rb, line 369
def httpdate(date)
  if /\A\s*
      (?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),\x20
      (\d{2})\x20
      (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\x20
      (\d{4})\x20
      (\d{2}):(\d{2}):(\d{2})\x20
      GMT
      \s*\z/ix =~ date
    self.rfc2822(date)
  elsif /\A\s*
         (?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday),\x20
         (\d\d)-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d\d)\x20
         (\d\d):(\d\d):(\d\d)\x20
         GMT
         \s*\z/ix =~ date
    year = $3.to_i
    if year < 50
      year += 2000
    else
      year += 1900
    end
    self.utc(year, $2, $1.to_i, $4.to_i, $5.to_i, $6.to_i)
  elsif /\A\s*
         (?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\x20
         (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\x20
         (\d\d|\x20\d)\x20
         (\d\d):(\d\d):(\d\d)\x20
         (\d{4})
         \s*\z/ix =~ date
    self.utc($6.to_i, MonthValue[$1.upcase], $2.to_i,
             $3.to_i, $4.to_i, $5.to_i)
  else
    raise ArgumentError.new("not RFC 2616 compliant date: #{date.inspect}")
  end
end
            
iso8601(date) click to toggle source
Alias for: xmlschema
parse(date, now=self.now) click to toggle source

Parses date using Date._parse and converts it to a Time object.

If a block is given, the year described in date is converted by the block. For example:

Time.parse(...) {|y| 0 <= y && y < 100 ? (y >= 69 ? y + 1900 : y + 2000) : y}

If the upper components of the given time are broken or missing, they are supplied with those of now. For the lower components, the minimum values (1 or 0) are assumed if broken or missing. For example:

# Suppose it is "Thu Nov 29 14:33:20 GMT 2001" now and
# your timezone is GMT:
now = Time.parse("Thu Nov 29 14:33:20 GMT 2001")
Time.parse("16:30", now)     #=> 2001-11-29 16:30:00 +0900
Time.parse("7/23", now)      #=> 2001-07-23 00:00:00 +0900
Time.parse("Aug 31", now)    #=> 2001-08-31 00:00:00 +0900
Time.parse("Aug 2000", now)  #=> 2000-08-01 00:00:00 +0900

Since there are numerous conflicts among locally defined timezone abbreviations all over the world, this method is not made to understand all of them. For example, the abbreviation “CST” is used variously as:

-06:00 in America/Chicago,
-05:00 in America/Havana,
+08:00 in Asia/Harbin,
+09:30 in Australia/Darwin,
+10:30 in Australia/Adelaide,
etc.

Based on the fact, this method only understands the timezone abbreviations described in RFC 822 and the system timezone, in the order named. (i.e. a definition in RFC 822 overrides the system timezone definition.) The system timezone is taken from Time.local(year, 1, 1).zone and Time.local(year, 7, 1).zone. If the extracted timezone abbreviation does not match any of them, it is ignored and the given time is regarded as a local time.

ArgumentError is raised if Date._parse cannot extract information from date or Time class cannot represent specified date.

This method can be used as fail-safe for other parsing methods as:

Time.rfc2822(date) rescue Time.parse(date)
Time.httpdate(date) rescue Time.parse(date)
Time.xmlschema(date) rescue Time.parse(date)

A failure for ::parse should be checked, though.

time library should be required to use this method as follows.

require 'time'
 
               # File time.rb, line 263
def parse(date, now=self.now)
  comp = !block_given?
  d = Date._parse(date, comp)
  if !d[:year] && !d[:mon] && !d[:mday] && !d[:hour] && !d[:min] && !d[:sec] && !d[:sec_fraction]
    raise ArgumentError, "no time information in #{date.inspect}"
  end
  year = d[:year]
  year = yield(year) if year && !comp
  make_time(year, d[:mon], d[:mday], d[:hour], d[:min], d[:sec], d[:sec_fraction], d[:zone], now)
end
            
rfc2822(date) click to toggle source

Parses date as date-time defined by RFC 2822 and converts it to a Time object. The format is identical to the date format defined by RFC 822 and updated by RFC 1123.

ArgumentError is raised if date is not compliant with RFC 2822 or Time class cannot represent specified date.

See rfc2822 for more information on this format.

time library should be required to use this method as follows.

require 'time'
 
               # File time.rb, line 316
def rfc2822(date)
  if /\A\s*
      (?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s*,\s*)?
      (\d{1,2})\s+
      (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+
      (\d{2,})\s+
      (\d{2})\s*
      :\s*(\d{2})\s*
      (?::\s*(\d{2}))?\s+
      ([+-]\d{4}|
       UT|GMT|EST|EDT|CST|CDT|MST|MDT|PST|PDT|[A-IK-Z])/ix =~ date
    # Since RFC 2822 permit comments, the regexp has no right anchor.
    day = $1.to_i
    mon = MonthValue[$2.upcase]
    year = $3.to_i
    hour = $4.to_i
    min = $5.to_i
    sec = $6 ? $6.to_i : 0
    zone = $7

    # following year completion is compliant with RFC 2822.
    year = if year < 50
             2000 + year
           elsif year < 1000
             1900 + year
           else
             year
           end

    year, mon, day, hour, min, sec =
      apply_offset(year, mon, day, hour, min, sec, zone_offset(zone))
    t = self.utc(year, mon, day, hour, min, sec)
    t.localtime if !zone_utc?(zone)
    t
  else
    raise ArgumentError.new("not RFC 2822 compliant date: #{date.inspect}")
  end
end
            
Also aliased as: rfc822
rfc822(date) click to toggle source
Alias for: rfc2822
strptime(date, format, now=self.now) click to toggle source

Parses date using Date._strptime and converts it to a Time object.

If a block is given, the year described in date is converted by the block. For example:

Time.strptime(...) {|y| y < 100 ? (y >= 69 ? y + 1900 : y + 2000) : y}
 
               # File time.rb, line 281
def strptime(date, format, now=self.now)
  d = Date._strptime(date, format)
  raise ArgumentError, "invalid strptime format - `#{format}'" unless d
  if seconds = d[:seconds]
    if offset = d[:offset]
      Time.at(seconds).localtime(offset)
    else
      Time.at(seconds)
    end
  else
    year = d[:year]
    year = yield(year) if year && block_given?
    make_time(year, d[:mon], d[:mday], d[:hour], d[:min], d[:sec], d[:sec_fraction], d[:zone], now)
  end
end
            
xmlschema(date) click to toggle source

Parses date as dateTime defined by XML Schema and converts it to a Time object. The format is restricted version of the format defined by ISO 8601.

ArgumentError is raised if date is not compliant with the format or Time class cannot represent specified date.

See xmlschema for more information on this format.

time library should be required to use this method as follows.

require 'time'
 
               # File time.rb, line 420
def xmlschema(date)
  if /\A\s*
      (-?\d+)-(\d\d)-(\d\d)
      T
      (\d\d):(\d\d):(\d\d)
      (\.\d+)?
      (Z|[+-]\d\d:\d\d)?
      \s*\z/ix =~ date
    year = $1.to_i
    mon = $2.to_i
    day = $3.to_i
    hour = $4.to_i
    min = $5.to_i
    sec = $6.to_i
    usec = 0
    if $7
      usec = Rational($7) * 1000000
    end
    if $8
      zone = $8
      year, mon, day, hour, min, sec =
        apply_offset(year, mon, day, hour, min, sec, zone_offset(zone))
      self.utc(year, mon, day, hour, min, sec, usec)
    else
      self.local(year, mon, day, hour, min, sec, usec)
    end
  else
    raise ArgumentError.new("invalid date: #{date.inspect}")
  end
end
            
Also aliased as: iso8601
zone_offset(zone, year=self.now.year) click to toggle source
 
               # File time.rb, line 69
def zone_offset(zone, year=self.now.year)
  off = nil
  zone = zone.upcase
  if /\A([+-])(\d\d):?(\d\d)\z/ =~ zone
    off = ($1 == '-' ? -1 : 1) * ($2.to_i * 60 + $3.to_i) * 60
  elsif /\A[+-]\d\d\z/ =~ zone
    off = zone.to_i * 3600
  elsif ZoneOffset.include?(zone)
    off = ZoneOffset[zone] * 3600
  elsif ((t = self.local(year, 1, 1)).zone.upcase == zone rescue false)
    off = t.utc_offset
  elsif ((t = self.local(year, 7, 1)).zone.upcase == zone rescue false)
    off = t.utc_offset
  end
  off
end
            

Public Instance Methods

httpdate() click to toggle source

Returns a string which represents the time as rfc1123-date of HTTP-date defined by RFC 2616:

day-of-week, DD month-name CCYY hh:mm:ss GMT

Note that the result is always UTC (GMT).

time library should be required to use this method as follows.

require 'time'
 
               # File time.rb, line 501
def httpdate
  t = dup.utc
  sprintf('%s, %02d %s %0*d %02d:%02d:%02d GMT',
    RFC2822_DAY_NAME[t.wday],
    t.day, RFC2822_MONTH_NAME[t.mon-1], t.year < 0 ? 5 : 4, t.year,
    t.hour, t.min, t.sec)
end
            
iso8601(fraction_digits=0) click to toggle source
Alias for: xmlschema
rfc2822() click to toggle source

Returns a string which represents the time as date-time defined by RFC 2822:

day-of-week, DD month-name CCYY hh:mm:ss zone

where zone is [+-]hhmm.

If self is a UTC time, -0000 is used as zone.

time library should be required to use this method as follows.

require 'time'
 
               # File time.rb, line 466
def rfc2822
  sprintf('%s, %02d %s %0*d %02d:%02d:%02d ',
    RFC2822_DAY_NAME[wday],
    day, RFC2822_MONTH_NAME[mon-1], year < 0 ? 5 : 4, year,
    hour, min, sec) +
  if utc?
    '-0000'
  else
    off = utc_offset
    sign = off < 0 ? '-' : '+'
    sprintf('%s%02d%02d', sign, *(off.abs / 60).divmod(60))
  end
end
            
Also aliased as: rfc822
rfc822() click to toggle source
Alias for: rfc2822
xmlschema(fraction_digits=0) click to toggle source

Returns a string which represents the time as dateTime defined by XML Schema:

CCYY-MM-DDThh:mm:ssTZD
CCYY-MM-DDThh:mm:ss.sssTZD

where TZD is Z or [+-]hh:mm.

If self is a UTC time, Z is used as TZD. [+-]hh:mm is used otherwise.

fractional_seconds specifies a number of digits of fractional seconds. Its default value is 0.

time library should be required to use this method as follows.

require 'time'
 
               # File time.rb, line 527
def xmlschema(fraction_digits=0)
  sprintf('%0*d-%02d-%02dT%02d:%02d:%02d',
    year < 0 ? 5 : 4, year, mon, day, hour, min, sec) +
  if fraction_digits <= 0
    ''
  else
    '.' + sprintf('%0*d', fraction_digits, (subsec * 10**fraction_digits).floor)
  end +
  if utc?
    'Z'
  else
    off = utc_offset
    sign = off < 0 ? '-' : '+'
    sprintf('%s%02d:%02d', sign, *(off.abs / 60).divmod(60))
  end
end
            
Also aliased as: iso8601

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.