Class: Time

Inherits:
Object show all
Includes:
Comparable
Defined in:
lib/time.rb,
lib/date.rb,
lib/dateME.rb,
lib/builtinME.rb

Overview

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

Constant Summary collapse

ZoneOffset = 
{
  'UTC' => 0,
  # ISO 8601
  'Z' => 0,
  # RFC 822
  'UT' => 0, 'GMT' => 0,
  'EST' => -5, 'EDT' => -4,
  'CST' => -6, 'CDT' => -5,
  'MST' => -7, 'MDT' => -6,
  'PST' => -8, 'PDT' => -7,
  # Following definition of military zones is original one.
  # See RFC 1123 and RFC 2822 for the error in RFC 822.
  'A' => +1, 'B' => +2, 'C' => +3, 'D' => +4,  'E' => +5,  'F' => +6,
  'G' => +7, 'H' => +8, 'I' => +9, 'K' => +10, 'L' => +11, 'M' => +12,
  'N' => -1, 'O' => -2, 'P' => -3, 'Q' => -4,  'R' => -5,  'S' => -6,
  'T' => -7, 'U' => -8, 'V' => -9, 'W' => -10, 'X' => -11, 'Y' => -12,
}
LeapYearMonthDays = 
[31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
CommonYearMonthDays = 
[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
MonthValue = 
{
  'JAN' => 1, 'FEB' => 2, 'MAR' => 3, 'APR' => 4, 'MAY' => 5, 'JUN' => 6,
  'JUL' => 7, 'AUG' => 8, 'SEP' => 9, 'OCT' =>10, 'NOV' =>11, 'DEC' =>12
}
RFC2822_DAY_NAME = 
[
  'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'
]
RFC2822_MONTH_NAME = 
[
  'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'
]

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Comparable

#<, #<=, #==, #>, #>=, #between?

Class Method Details

.apply_offset(year, mon, day, hour, min, sec, off) ⇒ Object 



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/time.rb', line 111

def apply_offset(year, mon, day, hour, min, sec, off)
  if off < 0
    off = -off
    off, o = off.divmod(60)
    if o != 0 then sec += o; o, sec = sec.divmod(60); off += o end
    off, o = off.divmod(60)
    if o != 0 then min += o; o, min = min.divmod(60); off += o end
    off, o = off.divmod(24)
    if o != 0 then hour += o; o, hour = hour.divmod(24); off += o end
    if off != 0
      day += off
      if month_days(year, mon) < day
        mon += 1
        if 12 < mon
          mon = 1
          year += 1
        end
        day = 1
      end
    end
  elsif 0 < off
    off, o = off.divmod(60)
    if o != 0 then sec -= o; o, sec = sec.divmod(60); off -= o end
    off, o = off.divmod(60)
    if o != 0 then min -= o; o, min = min.divmod(60); off -= o end
    off, o = off.divmod(24)
    if o != 0 then hour -= o; o, hour = hour.divmod(24); off -= o end
    if off != 0 then
      day -= off
      if day < 1
        mon -= 1
        if mon < 1
          year -= 1
          mon = 12
        end
        day = month_days(year, mon)
      end
    end
  end
  return year, mon, day, hour, min, sec
end

.httpdate(date) ⇒ Object

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.



328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
 
# File 'lib/time.rb', line 328

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 ⇒ Object

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.



405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
 
# File 'lib/time.rb', line 405

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

.make_time(year, mon, day, hour, min, sec, sec_fraction, zone, now) ⇒ Object 



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/time.rb', line 154

def make_time(year, mon, day, hour, min, sec, sec_fraction, zone, now)
  usec = nil
  usec = sec_fraction * 1000000 if sec_fraction
  if now
    begin
      break if year; year = now.year
      break if mon; mon = now.mon
      break if day; day = now.day
      break if hour; hour = now.hour
      break if min; min = now.min
      break if sec; sec = now.sec
      break if sec_fraction; usec = now.tv_usec
    end until true
  end

  year ||= 1970
  mon ||= 1
  day ||= 1
  hour ||= 0
  min ||= 0
  sec ||= 0
  usec ||= 0

  off = nil
  off = zone_offset(zone, year) if zone

  if off
    year, mon, day, hour, min, sec =
      apply_offset(year, mon, day, hour, min, sec, off)
    t = self.utc(year, mon, day, hour, min, sec, usec)
    t.localtime if !zone_utc?(zone)
    t
  else
    self.local(year, mon, day, hour, min, sec, usec)
  end
end

.month_days(y, m) ⇒ Object 



102
103
104
105
106
107
108
 
# File 'lib/time.rb', line 102

def month_days(y, m)
  if ((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0)
    LeapYearMonthDays[m-1]
  else
    CommonYearMonthDays[m-1]
  end
end

.parse(date, now = self.now) ⇒ Object

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| 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:
Time.parse("16:30")     #=> Thu Nov 29 16:30:00 GMT 2001
Time.parse("7/23")      #=> Mon Jul 23 00:00:00 GMT 2001
Time.parse("Aug 31")    #=> Fri Aug 31 00:00:00 GMT 2001

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 Time.parse should be checked, though.



242
243
244
245
246
247
 
# File 'lib/time.rb', line 242

def parse(date, now=self.now)
  d = Date._parse(date, false)
  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

.rfc2822(date) ⇒ Object

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.



279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
 
# File 'lib/time.rb', line 279

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

.rfc822 ⇒ Object

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.



317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
 
# File 'lib/time.rb', line 317

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

.strptime(date, format, now = self.now) ⇒ Object

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}

Raises:

  • (ArgumentError) 


256
257
258
259
260
261
262
 
# File 'lib/time.rb', line 256

def strptime(date, format, now=self.now)
  d = Date._strptime(date, format)
  raise ArgumentError, "invalid strptime format - `#{format}'" unless d
  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

.xmlschema(date) ⇒ Object

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.



375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
 
# File 'lib/time.rb', line 375

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

.zone_offset(zone, year = self.now.year) ⇒ Object 



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/time.rb', line 72

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

.zone_utc?(zone) ⇒ Boolean

Returns:

  • (Boolean) 


89
90
91
92
93
94
95
96
97
 
# File 'lib/time.rb', line 89

def zone_utc?(zone)
  # * +0000 means localtime. [RFC 2822]
  # * GMT is a localtime abbreviation in Europe/London, etc.
  if /\A(?:-00:00|-0000|-00|UTC|Z|UT)\z/i =~ zone
    true
  else
    false
  end
end

Instance Method Details

#httpdate ⇒ Object

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).



448
449
450
451
452
453
454
 
# File 'lib/time.rb', line 448

def httpdate
  t = dup.utc
  sprintf('%s, %02d %s %d %02d:%02d:%02d GMT',
    RFC2822_DAY_NAME[t.wday],
    t.day, RFC2822_MONTH_NAME[t.mon-1], t.year,
    t.hour, t.min, t.sec)
end

#rfc2822 ⇒ Object Also known as: rfc822

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.



417
418
419
420
421
422
423
424
425
426
427
428
429
 
# File 'lib/time.rb', line 417

def rfc2822
  sprintf('%s, %02d %s %d %02d:%02d:%02d ',
    RFC2822_DAY_NAME[wday()],
    day(), RFC2822_MONTH_NAME[mon()-1], 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

#strftime(fmt = '%F') ⇒ Object 



5
6
7
 
# File 'lib/dateME.rb', line 5

def strftime(fmt='%F')
  DateTimeME.new(self).strftime(fmt);
end

#to_date ⇒ Object 



1740
1741
1742
1743
 
# File 'lib/date.rb', line 1740

def to_date
  jd = Date.__send__(:civil_to_jd, year(), mon(), mday(), Date::ITALY)
  Date.new!(Date.__send__(:jd_to_ajd, jd, 0, 0), 0, Date::ITALY)
end

#to_datetime ⇒ Object 



1745
1746
1747
1748
1749
1750
1751
1752
 
# File 'lib/date.rb', line 1745

def to_datetime
  jd = DateTime.__send__(:civil_to_jd, year(), mon(), mday(), DateTime::ITALY)
  fr = DateTime.__send__(:time_to_day_fraction, hour(), min(), [sec, 59].min) +
    nsec.to_r/86400_000_000_000
  of = utc_offset.to_r/86400
  DateTime.new!(DateTime.__send__(:jd_to_ajd, jd, fr, of),
  of, DateTime::ITALY)
end

#to_time ⇒ Object 



1738
 
# File 'lib/date.rb', line 1738

def to_time() getlocal end

#xmlschema(fraction_digits = 0) ⇒ Object Also known as: iso8601

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.



470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
 
# File 'lib/time.rb', line 470

def xmlschema(fraction_digits=0)
  sprintf('%d-%02d-%02dT%02d:%02d:%02d',
    year, mon, day, hour, min, sec) +
  if fraction_digits == 0
    ''
  elsif fraction_digits <= 9
    '.' + sprintf('%09d', nsec)[0, fraction_digits]
  else
    '.' + sprintf('%09d', nsec) + '0' * (fraction_digits - 9)
  end +
  if utc?
    'Z'
  else
    off = utc_offset
    sign = off < 0 ? '-' : '+'
    sprintf('%s%02d:%02d', sign, *(off.abs / 60).divmod(60))
  end
end