Class: Date

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
lib/project/date.rb,
lib/project/date.rb,
lib/project/format.rb

Overview

format.rb: Written by Tadayoshi Funaba 1999-2009 $Id: format.rb,v 2.43 2008-01-17 20:16:31+09 tadf Exp $

Direct Known Subclasses

DateTime

Defined Under Namespace

Modules: Format Classes: Infinity

Constant Summary collapse

MONTHNAMES =

Full month names, in English. Months count from 1 to 12; a month’s numerical representation indexed into this array gives the name of that month (hence the first element is nil).

[nil] + %w(January February March April May June July
August September October November December)
DAYNAMES =

Full names of days of the week, in English. Days of the week count from 0 to 6 (except in the commercial week); a day’s numerical representation indexed into this array gives the name of that day.

%w(Sunday Monday Tuesday Wednesday Thursday Friday Saturday)
ABBR_MONTHNAMES =

Abbreviated month names, in English.

[nil] + %w(Jan Feb Mar Apr May Jun
Jul Aug Sep Oct Nov Dec)
ABBR_DAYNAMES =

Abbreviated day names, in English.

%w(Sun Mon Tue Wed Thu Fri Sat)
ITALY =

The Julian Day Number of the Day of Calendar Reform for Italy and the Catholic countries.

2299161
ENGLAND =

The Julian Day Number of the Day of Calendar Reform for England and her Colonies.

2361222
JULIAN =

A constant used to indicate that a Date should always use the Julian calendar.

Infinity.new
GREGORIAN =

A constant used to indicate that a Date should always use the Gregorian calendar.

-Infinity.new
HALF_DAYS_IN_DAY =

:nodoc:

Rational(1, 2)
HOURS_IN_DAY =

:nodoc:

Rational(1, 24)
MINUTES_IN_DAY =

:nodoc:

Rational(1, 1440)
SECONDS_IN_DAY =

:nodoc:

Rational(1, 86400)
MILLISECONDS_IN_DAY =

:nodoc:

Rational(1, 86400*10**3)
NANOSECONDS_IN_DAY =

:nodoc:

Rational(1, 86400*10**9)
MILLISECONDS_IN_SECOND =

:nodoc:

Rational(1, 10**3)
NANOSECONDS_IN_SECOND =

:nodoc:

Rational(1, 10**9)
MJD_EPOCH_IN_AJD =

1858-11-17 # :nodoc:

Rational(4800001, 2)
UNIX_EPOCH_IN_AJD =

1970-01-01 # :nodoc:

Rational(4881175, 2)
MJD_EPOCH_IN_CJD =

:nodoc:

2400001
UNIX_EPOCH_IN_CJD =

:nodoc:

2440588
LD_EPOCH_IN_CJD =

:nodoc:

2299160

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(ajd = 0, of = 0, sg = ITALY) ⇒ Date

NOTE this is the documentation for the method new!(). If you are reading this as the documentation for new(), that is because rdoc doesn’t fully support the aliasing of the initialize() method. new() is in fact an alias for #civil(): read the documentation for that method instead.

Create a new Date object.

ajd is the Astronomical Julian Day Number. of is the offset from UTC as a fraction of a day. Both default to 0.

sg specifies the Day of Calendar Reform to use for this Date object.

Using one of the factory methods such as Date::civil is generally easier and safer.



1136
1137
1138
1139
 
# File 'lib/project/date.rb', line 1136

def initialize(ajd=0, of=0, sg=ITALY)
  @ajd, @of, @sg = ajd, of, sg
  @__ca__ = {}
end

Class Method Details

._httpdate(str) ⇒ Object

:nodoc:



1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
 
# File 'lib/project/format.rb', line 1198

def self._httpdate(str) # :nodoc:
  if /\A\s*(#{Format::ABBR_DAYS.keys.join('|')})\s*,\s+
      \d{2}\s+
      (#{Format::ABBR_MONTHS.keys.join('|')})\s+
      -?\d{4}\s+ # allow minus, anyway
      \d{2}:\d{2}:\d{2}\s+
      gmt\s*\z/iox =~ str
    _rfc2822(str)
  elsif /\A\s*(#{Format::DAYS.keys.join('|')})\s*,\s+
      \d{2}\s*-\s*
      (#{Format::ABBR_MONTHS.keys.join('|')})\s*-\s*
      \d{2}\s+
      \d{2}:\d{2}:\d{2}\s+
      gmt\s*\z/iox =~ str
    _parse(str)
  elsif /\A\s*(#{Format::ABBR_DAYS.keys.join('|')})\s+
      (#{Format::ABBR_MONTHS.keys.join('|')})\s+
      \d{1,2}\s+
      \d{2}:\d{2}:\d{2}\s+
      \d{4}\s*\z/iox =~ str
    _parse(str)
  end
end

._iso8601(str) ⇒ Object

:nodoc:



1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
 
# File 'lib/project/format.rb', line 1099

def self._iso8601(str) # :nodoc:
  if /\A\s*(([-+]?\d{2,}|-)-\d{2}-\d{2}|
            ([-+]?\d{2,})?-\d{3}|
            (\d{2}|\d{4})?-w\d{2}-\d|
            -w-\d)
      (t
      \d{2}:\d{2}(:\d{2}([,.]\d+)?)?
      (z|[-+]\d{2}(:?\d{2})?)?)?\s*\z/ix =~ str
    _parse(str)
  elsif /\A\s*(([-+]?(\d{2}|\d{4})|--)\d{2}\d{2}|
            ([-+]?(\d{2}|\d{4}))?\d{3}|-\d{3}|
            (\d{2}|\d{4})?w\d{2}\d)
      (t?
      \d{2}\d{2}(\d{2}([,.]\d+)?)?
      (z|[-+]\d{2}(\d{2})?)?)?\s*\z/ix =~ str
    _parse(str)
  elsif /\A\s*(\d{2}:\d{2}(:\d{2}([,.]\d+)?)?
      (z|[-+]\d{2}(:?\d{2})?)?)?\s*\z/ix =~ str
    _parse(str)
  elsif /\A\s*(\d{2}\d{2}(\d{2}([,.]\d+)?)?
      (z|[-+]\d{2}(\d{2})?)?)?\s*\z/ix =~ str
    _parse(str)
  end
end

._jisx0301(str) ⇒ Object

:nodoc:



1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
 
# File 'lib/project/format.rb', line 1222

def self._jisx0301(str) # :nodoc:
  if /\A\s*[mtsh]?\d{2}\.\d{2}\.\d{2}
      (t
      (\d{2}:\d{2}(:\d{2}([,.]\d*)?)?
      (z|[-+]\d{2}(:?\d{2})?)?)?)?\s*\z/ix =~ str
    if /\A\s*\d/ =~ str
      _parse(str.sub(/\A\s*(\d)/, 'h\1'))
    else
      _parse(str)
    end
  else
    _iso8601(str)
  end
end

._parse(str, comp = true) ⇒ Object 



1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
 
# File 'lib/project/format.rb', line 1033

def self._parse(str, comp=true)
  str = str.dup

  e = Format::Bag.new

  e._comp = comp

  str.gsub!(/[^-+',.\/:@[:alnum:]\[\]]+/, ' ')

  _parse_time(str, e) # || _parse_beat(str, e)
  _parse_day(str, e)

  _parse_eu(str, e)     ||
  _parse_us(str, e)     ||
  _parse_iso(str, e)    ||
  _parse_jis(str, e)    ||
  _parse_vms(str, e)    ||
  _parse_sla(str, e)    ||
  _parse_dot(str, e)    ||
  _parse_iso2(str, e)   ||
  _parse_year(str, e)   ||
  _parse_mon(str, e)    ||
  _parse_mday(str, e)   ||
  _parse_ddd(str, e)

  if str.sub!(/\b(bc\b|bce\b|b\.c\.|b\.c\.e\.)/i, ' ')
    if e.year
      e.year = -e.year + 1
    end
  end

  if str.sub!(/\A\s*(\d{1,2})\s*\z/, ' ')
    if e.hour && !e.mday
      v = $1.to_i
      if (1..31) === v
        e.mday = v
      end
    end
    if e.mday && !e.hour
      v = $1.to_i
      if (0..24) === v
        e.hour = v
      end
    end
  end

  if e._comp
    if e.cwyear
      if e.cwyear >= 0 && e.cwyear <= 99
        e.cwyear += if e.cwyear >= 69
                    then 1900 else 2000 end
      end
    end
    if e.year
      if e.year >= 0 && e.year <= 99
        e.year += if e.year >= 69
                  then 1900 else 2000 end
      end
    end
  end

  e.offset ||= zone_to_diff(e.zone) if e.zone

  e.to_hash
end

._rfc2822(str) ⇒ Object Also known as: _rfc822

:nodoc:



1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
 
# File 'lib/project/format.rb', line 1177

def self._rfc2822(str) # :nodoc:
  if /\A\s*(?:(?:#{Format::ABBR_DAYS.keys.join('|')})\s*,\s+)?
      \d{1,2}\s+
      (?:#{Format::ABBR_MONTHS.keys.join('|')})\s+
      -?(\d{2,})\s+ # allow minus, anyway
      \d{2}:\d{2}(:\d{2})?\s*
      (?:[-+]\d{4}|ut|gmt|e[sd]t|c[sd]t|m[sd]t|p[sd]t|[a-ik-z])\s*\z/iox =~ str
    e = _parse(str, false)
    if (($1.nil?) || ($1.size < 4))
      if e[:year] < 50
        e[:year] += 2000
      elsif e[:year] < 1000
        e[:year] += 1900
      end
    end
    e
  end
end

._rfc3339(str) ⇒ Object

:nodoc:



1124
1125
1126
1127
1128
1129
1130
1131
 
# File 'lib/project/format.rb', line 1124

def self._rfc3339(str) # :nodoc:
  if /\A\s*-?\d{4}-\d{2}-\d{2} # allow minus, anyway
      (t|\s)
      \d{2}:\d{2}:\d{2}(\.\d+)?
      (z|[-+]\d{2}:\d{2})\s*\z/ix =~ str
    _parse(str)
  end
end

._strptime(str, fmt = '%F') ⇒ Object 



577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
 
# File 'lib/project/format.rb', line 577

def self._strptime(str, fmt='%F')
  str = str.dup
  e = Format::Bag.new
  return unless _strptime_i(str, fmt, e)

  if e._cent
    if e.cwyear
      e.cwyear += e._cent * 100
    end
    if e.year
      e.  year += e._cent * 100
    end
  end

  if e._merid
    if e.hour
      e.hour %= 12
      e.hour += e._merid
    end
  end

  unless str.empty?
    e.leftover = str
  end

  e.to_hash
end

._xmlschema(str) ⇒ Object

:nodoc:



1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
 
# File 'lib/project/format.rb', line 1133

def self._xmlschema(str) # :nodoc:
  if /\A\s*(-?\d{4,})(?:-(\d{2})(?:-(\d{2}))?)?
      (?:t
        (\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?
      (z|[-+]\d{2}:\d{2})?\s*\z/ix =~ str
    e = Format::Bag.new
    e.year = $1.to_i
    e.mon = $2.to_i if $2
    e.mday = $3.to_i if $3
    e.hour = $4.to_i if $4
    e.min = $5.to_i if $5
    e.sec = $6.to_i if $6
    e.sec_fraction = Rational($7.to_i, 10**$7.size) if $7
    if $8
      e.zone = $8
      e.offset = zone_to_diff($8)
    end
    e.to_hash
  elsif /\A\s*(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?
      (z|[-+]\d{2}:\d{2})?\s*\z/ix =~ str
    e = Format::Bag.new
    e.hour = $1.to_i if $1
    e.min = $2.to_i if $2
    e.sec = $3.to_i if $3
    e.sec_fraction = Rational($4.to_i, 10**$4.size) if $4
    if $5
      e.zone = $5
      e.offset = zone_to_diff($5)
    end
    e.to_hash
  elsif /\A\s*(?:--(\d{2})(?:-(\d{2}))?|---(\d{2}))
      (z|[-+]\d{2}:\d{2})?\s*\z/ix =~ str
    e = Format::Bag.new
    e.mon = $1.to_i if $1
    e.mday = $2.to_i if $2
    e.mday = $3.to_i if $3
    if $4
      e.zone = $4
      e.offset = zone_to_diff($4)
    end
    e.to_hash
  end
end

.civil(y = -4712,, m = 1, d = 1, sg = ITALY) ⇒ Object

Create a new Date object for the Civil Date specified by year y, month m, and day-of-month d.

m and d can be negative, in which case they count backwards from the end of the year and the end of the month respectively. No wraparound is performed, however, and invalid values cause an ArgumentError to be raised. can be negative

y defaults to -4712, m to 1, and d to 1; this is Julian Day Number day 0.

sg specifies the Day of Calendar Reform.



805
806
807
808
809
810
 
# File 'lib/project/date.rb', line 805

def self.civil(y=-4712, m=1, d=1, sg=ITALY)
  unless jd = _valid_civil?(y, m, d, sg)
    raise ArgumentError, 'invalid date'
  end
  new!(jd_to_ajd(jd, 0, 0), 0, sg)
end

.commercial(y = -4712,, w = 1, d = 1, sg = ITALY) ⇒ Object

Create a new Date object for the Commercial Date specified by year y, week-of-year w, and day-of-week d.

Monday is day-of-week 1; Sunday is day-of-week 7.

w and d can be negative, in which case they count backwards from the end of the year and the end of the week respectively. No wraparound is performed, however, and invalid values cause an ArgumentError to be raised.

y defaults to -4712, w to 1, and d to 1; this is Julian Day Number day 0.

sg specifies the Day of Calendar Reform.



828
829
830
831
832
833
 
# File 'lib/project/date.rb', line 828

def self.commercial(y=-4712, w=1, d=1, sg=ITALY)
  unless jd = _valid_commercial?(y, w, d, sg)
    raise ArgumentError, 'invalid date'
  end
  new!(jd_to_ajd(jd, 0, 0), 0, sg)
end

.gregorian_leap?(y) ⇒ Boolean Also known as: leap?

Is a year a leap year in the Gregorian calendar?

All years divisible by 4 are leap years in the Gregorian calendar, except for years divisible by 100 and not by 400.

Returns:

  • (Boolean) 


724
 
# File 'lib/project/date.rb', line 724

def self.gregorian_leap? (y) y % 4 == 0 && y % 100 != 0 || y % 400 == 0 end

.httpdate(str = 'Mon, 01 Jan -4712 00:00:00 GMT', sg = ITALY) ⇒ Object

:nodoc:



1089
1090
1091
1092
 
# File 'lib/project/date.rb', line 1089

def self.httpdate(str='Mon, 01 Jan -4712 00:00:00 GMT', sg=ITALY) # :nodoc:
  elem = _httpdate(str)
  new_by_frags(elem, sg)
end

.iso8601(str = '-4712-01-01', sg = ITALY) ⇒ Object

:nodoc:



1067
1068
1069
1070
 
# File 'lib/project/date.rb', line 1067

def self.iso8601(str='-4712-01-01', sg=ITALY) # :nodoc:
  elem = _iso8601(str)
  new_by_frags(elem, sg)
end

.jd(jd = 0, sg = ITALY) ⇒ Object

Create a new Date object from a Julian Day Number.

jd is the Julian Day Number; if not specified, it defaults to 0. sg specifies the Day of Calendar Reform.



770
771
772
773
 
# File 'lib/project/date.rb', line 770

def self.jd(jd=0, sg=ITALY)
  jd = _valid_jd?(jd, sg)
  new!(jd_to_ajd(jd, 0, 0), 0, sg)
end

.jisx0301(str = '-4712-01-01', sg = ITALY) ⇒ Object

:nodoc:



1094
1095
1096
1097
 
# File 'lib/project/date.rb', line 1094

def self.jisx0301(str='-4712-01-01', sg=ITALY) # :nodoc:
  elem = _jisx0301(str)
  new_by_frags(elem, sg)
end

.julian_leap?(y) ⇒ Boolean

Is a year a leap year in the Julian calendar?

All years divisible by 4 are leap years in the Julian calendar.

Returns:

  • (Boolean) 


718
 
# File 'lib/project/date.rb', line 718

def self.julian_leap? (y) y % 4 == 0 end

.new ⇒ Object Also known as: new!

Create a new Date object for the Civil Date specified by year y, month m, and day-of-month d.

m and d can be negative, in which case they count backwards from the end of the year and the end of the month respectively. No wraparound is performed, however, and invalid values cause an ArgumentError to be raised. can be negative

y defaults to -4712, m to 1, and d to 1; this is Julian Day Number day 0.

sg specifies the Day of Calendar Reform.



812
813
814
815
816
817
 
# File 'lib/project/date.rb', line 812

def self.civil(y=-4712, m=1, d=1, sg=ITALY)
  unless jd = _valid_civil?(y, m, d, sg)
    raise ArgumentError, 'invalid date'
  end
  new!(jd_to_ajd(jd, 0, 0), 0, sg)
end

.ordinal(y = -4712,, d = 1, sg = ITALY) ⇒ Object

Create a new Date object from an Ordinal Date, specified by year y and day-of-year d. d can be negative, in which it counts backwards from the end of the year. No year wraparound is performed, however. An invalid value for d results in an ArgumentError being raised.

y defaults to -4712, and d to 1; this is Julian Day Number day 0.

sg specifies the Day of Calendar Reform.



785
786
787
788
789
790
 
# File 'lib/project/date.rb', line 785

def self.ordinal(y=-4712, d=1, sg=ITALY)
  unless jd = _valid_ordinal?(y, d, sg)
    raise ArgumentError, 'invalid date'
  end
  new!(jd_to_ajd(jd, 0, 0), 0, sg)
end

.parse(str = '-4712-01-01', comp = true, sg = ITALY) ⇒ Object

Create a new Date object by parsing from a String, without specifying the format.

str is a String holding a date representation. comp specifies whether to interpret 2-digit years as 19XX (>= 69) or 20XX (< 69); the default is not to. The method will attempt to parse a date from the String using various heuristics; see #_parse in date/format.rb for more details. If parsing fails, an ArgumentError will be raised.

The default str is ‘-4712-01-01’; this is Julian Day Number day 0.

sg specifies the Day of Calendar Reform.



1062
1063
1064
1065
 
# File 'lib/project/date.rb', line 1062

def self.parse(str='-4712-01-01', comp=true, sg=ITALY)
  elem = _parse(str, comp)
  new_by_frags(elem, sg)
end

.rfc2822(str = 'Mon, 1 Jan -4712 00:00:00 +0000', sg = ITALY) ⇒ Object

:nodoc:



1082
1083
1084
1085
 
# File 'lib/project/date.rb', line 1082

def self.rfc2822(str='Mon, 1 Jan -4712 00:00:00 +0000', sg=ITALY) # :nodoc:
  elem = _rfc2822(str)
  new_by_frags(elem, sg)
end

.rfc3339(str = '-4712-01-01T00:00:00+00:00', sg = ITALY) ⇒ Object

:nodoc:



1072
1073
1074
1075
 
# File 'lib/project/date.rb', line 1072

def self.rfc3339(str='-4712-01-01T00:00:00+00:00', sg=ITALY) # :nodoc:
  elem = _rfc3339(str)
  new_by_frags(elem, sg)
end

.rfc822 ⇒ Object

:nodoc:



1087
1088
1089
1090
 
# File 'lib/project/date.rb', line 1087

def self.rfc2822(str='Mon, 1 Jan -4712 00:00:00 +0000', sg=ITALY) # :nodoc:
  elem = _rfc2822(str)
  new_by_frags(elem, sg)
end

.strptime(str = '-4712-01-01', fmt = '%F', sg = ITALY) ⇒ Object

Create a new Date object by parsing from a String according to a specified format.

str is a String holding a date representation. fmt is the format that the date is in. See date/format.rb for details on supported formats.

The default str is ‘-4712-01-01’, and the default fmt is ‘%F’, which means Year-Month-Day_of_Month. This gives Julian Day Number day 0.

sg specifies the Day of Calendar Reform.

An ArgumentError will be raised if str cannot be parsed.



1042
1043
1044
1045
 
# File 'lib/project/date.rb', line 1042

def self.strptime(str='-4712-01-01', fmt='%F', sg=ITALY)
  elem = _strptime(str, fmt)
  new_by_frags(elem, sg)
end

.today(sg = ITALY) ⇒ Object

Create a new Date object representing today.

sg specifies the Day of Calendar Reform.



1806
1807
1808
1809
1810
 
# File 'lib/project/date.rb', line 1806

def self.today(sg=ITALY)
  t = Time.now
  jd = civil_to_jd(t.year, t.mon, t.mday, sg)
  new!(jd_to_ajd(jd, 0, 0), 0, sg)
end

.valid_civil?(y, m, d, sg = ITALY) ⇒ Boolean Also known as: valid_date?

Returns:

  • (Boolean) 


737
738
739
 
# File 'lib/project/date.rb', line 737

def self.valid_civil? (y, m, d, sg=ITALY)
  !!_valid_civil?(y, m, d, sg)
end

.valid_commercial?(y, w, d, sg = ITALY) ⇒ Boolean

Returns:

  • (Boolean) 


743
744
745
 
# File 'lib/project/date.rb', line 743

def self.valid_commercial? (y, w, d, sg=ITALY)
  !!_valid_commercial?(y, w, d, sg)
end

.valid_jd?(jd, sg = ITALY) ⇒ Boolean

Returns:

  • (Boolean) 


729
730
731
 
# File 'lib/project/date.rb', line 729

def self.valid_jd? (jd, sg=ITALY)
  !!_valid_jd?(jd, sg)
end

.valid_ordinal?(y, d, sg = ITALY) ⇒ Boolean

Returns:

  • (Boolean) 


733
734
735
 
# File 'lib/project/date.rb', line 733

def self.valid_ordinal? (y, d, sg=ITALY)
  !!_valid_ordinal?(y, d, sg)
end

.xmlschema(str = '-4712-01-01', sg = ITALY) ⇒ Object

:nodoc:



1077
1078
1079
1080
 
# File 'lib/project/date.rb', line 1077

def self.xmlschema(str='-4712-01-01', sg=ITALY) # :nodoc:
  elem = _xmlschema(str)
  new_by_frags(elem, sg)
end

Instance Method Details

#+(n) ⇒ Object

Return a new Date object that is n days later than the current one.

n may be a negative value, in which case the new Date is earlier than the current one; however, #-() might be more intuitive.

If n is not a Numeric, a TypeError will be thrown. In particular, two Dates cannot be added to each other.

Raises:

  • (TypeError) 


1334
1335
1336
1337
1338
1339
 
# File 'lib/project/date.rb', line 1334

def + (n)
  case n
  when Numeric; return self.class.new!(@ajd + n, @of, @sg)
  end
  raise TypeError, 'expected numeric'
end

#-(x) ⇒ Object

If x is a Numeric value, create a new Date object that is x days earlier than the current one.

If x is a Date, return the number of days between the two dates; or, more precisely, how many days later the current date is than x.

If x is neither Numeric nor a Date, a TypeError is raised.

Raises:

  • (TypeError) 


1349
1350
1351
1352
1353
1354
1355
 
# File 'lib/project/date.rb', line 1349

def - (x)
  case x
  when Numeric; return self.class.new!(@ajd - x, @of, @sg)
  when Date;    return @ajd - x.ajd
  end
  raise TypeError, 'expected numeric or date'
end

#<<(n) ⇒ Object

Return a new Date object that is n months earlier than the current one.

If the day-of-the-month of the current Date is greater than the last day of the target month, the day-of-the-month of the returned Date will be the last day of the target month.



1433
 
# File 'lib/project/date.rb', line 1433

def << (n) self >> -n end

#<=>(other) ⇒ Object

Compare this date with another date.

other can also be a Numeric value, in which case it is interpreted as an Astronomical Julian Day Number.

Comparison is by Astronomical Julian Day Number, including fractional days. This means that both the time and the timezone offset are taken into account when comparing two DateTime instances. When comparing a DateTime instance with a Date instance, the time of the latter will be considered as falling on midnight UTC.



1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
 
# File 'lib/project/date.rb', line 1368

def <=> (other)
  case other
  when Numeric; return @ajd <=> other
  when Date;    return @ajd <=> other.ajd
  else
    begin
      l, r = other.coerce(self)
      return l <=> r
    rescue NoMethodError
    end
  end
  nil
end

#===(other) ⇒ Object

The relationship operator for Date.

Compares dates by Julian Day Number. When comparing two DateTime instances, or a DateTime with a Date, the instances will be regarded as equivalent if they fall on the same date in local time.



1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
 
# File 'lib/project/date.rb', line 1388

def === (other)
  case other
  when Numeric; return jd == other
  when Date;    return jd == other.jd
  else
    begin
      l, r = other.coerce(self)
      return l === r
    rescue NoMethodError
    end
  end
  false
end

#>>(n) ⇒ Object

Return a new Date object that is n months later than the current one.

If the day-of-the-month of the current Date is greater than the last day of the target month, the day-of-the-month of the returned Date will be the last day of the target month.



1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
 
# File 'lib/project/date.rb', line 1416

def >> (n)
  y, m = (year * 12 + (mon - 1) + n).divmod(12)
  m,   = (m + 1)                    .divmod(1)
  d = mday
  until jd2 = _valid_civil?(y, m, d, @sg)
    d -= 1
    raise ArgumentError, 'invalid date' unless d > 0
  end
  self + (jd2 - jd)
end

#ajd ⇒ Object

Get the date as an Astronomical Julian Day Number.



1142
 
# File 'lib/project/date.rb', line 1142

def ajd() @ajd end

#amjd ⇒ Object

Get the date as an Astronomical Modified Julian Day Number.



1145
 
# File 'lib/project/date.rb', line 1145

def amjd() ajd_to_amjd(@ajd) end

#asctime ⇒ Object Also known as: ctime

alias_method :format, :strftime



344
 
# File 'lib/project/format.rb', line 344

def asctime() strftime('%c') end

#civil ⇒ Object

Get the date as a Civil Date, [year, month, day_of_month]



1165
 
# File 'lib/project/date.rb', line 1165

def civil() jd_to_civil(jd, @sg) end

#commercial ⇒ Object

Get the date as a Commercial Date, [year, week_of_year, day_of_week]



1171
 
# File 'lib/project/date.rb', line 1171

def commercial() jd_to_commercial(jd, @sg) end

#cwday ⇒ Object

Get the commercial day of the week of this date. Monday is commercial day-of-week 1; Sunday is commercial day-of-week 7.



1242
 
# File 'lib/project/date.rb', line 1242

def cwday() commercial[2] end

#cweek ⇒ Object

Get the commercial week of the year of this date.



1238
 
# File 'lib/project/date.rb', line 1238

def cweek() commercial[1] end

#cwyear ⇒ Object

Get the commercial year of this date. See Commercial Date in the introduction for how this differs from the normal year.



1235
 
# File 'lib/project/date.rb', line 1235

def cwyear() commercial[0] end

#day_fraction ⇒ Object

Get any fractional day part of the date.



1153
 
# File 'lib/project/date.rb', line 1153

def day_fraction() ajd_to_jd(@ajd, @of)[1] end

#downto(min, &block) ⇒ Object

Step backward one day at a time until we reach min (inclusive), yielding each date as we go.



1471
1472
1473
 
# File 'lib/project/date.rb', line 1471

def downto(min, &block) # :yield: date
  step(min, -1, &block)
end

#england ⇒ Object

Create a copy of this Date object that uses the English/Colonial Day of Calendar Reform.



1304
 
# File 'lib/project/date.rb', line 1304

def england() new_start(self.class::ENGLAND) end

#eql?(other) ⇒ Boolean

Is this Date equal to other?

other must both be a Date object, and represent the same date.

Returns:

  • (Boolean) 


1478
 
# File 'lib/project/date.rb', line 1478

def eql? (other) Date === other && self == other end

#gregorian ⇒ Object

Create a copy of this Date object that always uses the Gregorian Calendar.



1312
 
# File 'lib/project/date.rb', line 1312

def gregorian() new_start(self.class::GREGORIAN) end

#gregorian? ⇒ Boolean

Is the current date new-style (Gregorian Calendar)?

Returns:

  • (Boolean) 


1272
 
# File 'lib/project/date.rb', line 1272

def gregorian? () !julian? end

#hash ⇒ Object

Calculate a hash value for this date.



1481
 
# File 'lib/project/date.rb', line 1481

def hash() @ajd.hash end

#httpdate ⇒ Object

:nodoc:



358
 
# File 'lib/project/format.rb', line 358

def httpdate() new_offset(0).strftime('%a, %d %b %Y %T GMT') end

#inspect ⇒ Object

Return internal object state as a programmer-readable string.



1484
1485
1486
 
# File 'lib/project/date.rb', line 1484

def inspect
  format('#<%s: %s (%s,%s,%s)>', self.class, to_s, @ajd, @of, @sg)
end

#iso8601 ⇒ Object 



348
 
# File 'lib/project/format.rb', line 348

def iso8601() strftime('%F') end

#italy ⇒ Object

Create a copy of this Date object that uses the Italian/Catholic Day of Calendar Reform.



1300
 
# File 'lib/project/date.rb', line 1300

def italy() new_start(self.class::ITALY) end

#jd ⇒ Object

Get the date as a Julian Day Number.



1150
 
# File 'lib/project/date.rb', line 1150

def jd() ajd_to_jd(@ajd, @of)[0] end

#jisx0301 ⇒ Object 



360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
 
# File 'lib/project/format.rb', line 360

def jisx0301
  if jd < 2405160
    iso8601
  else
    case jd
    when 2405160...2419614
      g = 'M%02d' % (year - 1867)
    when 2419614...2424875
      g = 'T%02d' % (year - 1911)
    when 2424875...2447535
      g = 'S%02d' % (year - 1925)
    else
      g = 'H%02d' % (year - 1988)
    end
    g + strftime('.%m.%d')
  end
end

#julian ⇒ Object

Create a copy of this Date object that always uses the Julian Calendar.



1308
 
# File 'lib/project/date.rb', line 1308

def julian() new_start(self.class::JULIAN) end

#julian? ⇒ Boolean

Is the current date old-style (Julian Calendar)?

Returns:

  • (Boolean) 


1269
 
# File 'lib/project/date.rb', line 1269

def julian? () jd < @sg end

#ld ⇒ Object

Get the date as the number of days since the Day of Calendar Reform (in Italy and the Catholic countries).



1160
 
# File 'lib/project/date.rb', line 1160

def ld() jd_to_ld(jd) end

#leap? ⇒ Boolean

Is this a leap year?

Returns:

  • (Boolean) 


1285
1286
1287
1288
 
# File 'lib/project/date.rb', line 1285

def leap?
  jd_to_civil(civil_to_jd(year, 3, 1, fix_style) - 1,
              fix_style)[-1] == 29
end

#marshal_dump ⇒ Object

Dump to Marshal format.



1494
 
# File 'lib/project/date.rb', line 1494

def marshal_dump() [@ajd, @of, @sg] end

#marshal_load(a) ⇒ Object

Load from Marshal format.



1497
1498
1499
1500
 
# File 'lib/project/date.rb', line 1497

def marshal_load(a)
  @ajd, @of, @sg, = a
  @__ca__ = {}
end

#mday ⇒ Object Also known as: day

Get the day-of-the-month of this date.



1193
 
# File 'lib/project/date.rb', line 1193

def mday() civil[2] end

#mjd ⇒ Object

Get the date as a Modified Julian Day Number.



1156
 
# File 'lib/project/date.rb', line 1156

def mjd() jd_to_mjd(jd) end

#mon ⇒ Object Also known as: month

Get the month of this date.

January is month 1.



1190
 
# File 'lib/project/date.rb', line 1190

def mon() civil[1] end

#new_start(sg = self.class::ITALY) ⇒ Object

Create a copy of this Date object using a new Day of Calendar Reform.



1296
 
# File 'lib/project/date.rb', line 1296

def new_start(sg=self.class::ITALY) self.class.new!(@ajd, @of, sg) end

#next ⇒ Object Also known as: succ

Return a new Date one day after this one.



1406
 
# File 'lib/project/date.rb', line 1406

def next() next_day end

#next_day(n = 1) ⇒ Object 



1402
 
# File 'lib/project/date.rb', line 1402

def next_day(n=1) self + n end

#next_month(n = 1) ⇒ Object 



1435
 
# File 'lib/project/date.rb', line 1435

def next_month(n=1) self >> n end

#next_year(n = 1) ⇒ Object 



1438
 
# File 'lib/project/date.rb', line 1438

def next_year(n=1) self >> n * 12 end

#ordinal ⇒ Object

Get the date as an Ordinal Date, [year, day_of_year]



1168
 
# File 'lib/project/date.rb', line 1168

def ordinal() jd_to_ordinal(jd, @sg) end

#prev_day(n = 1) ⇒ Object 



1403
 
# File 'lib/project/date.rb', line 1403

def prev_day(n=1) self - n end

#prev_month(n = 1) ⇒ Object 



1436
 
# File 'lib/project/date.rb', line 1436

def prev_month(n=1) self << n end

#prev_year(n = 1) ⇒ Object 



1439
 
# File 'lib/project/date.rb', line 1439

def prev_year(n=1) self << n * 12 end

#rfc2822 ⇒ Object Also known as: rfc822 



354
 
# File 'lib/project/format.rb', line 354

def rfc2822() strftime('%a, %-d %b %Y %T %z') end

#rfc3339 ⇒ Object 



350
 
# File 'lib/project/format.rb', line 350

def rfc3339() iso8601 end

#start ⇒ Object

When is the Day of Calendar Reform for this Date object?



1293
 
# File 'lib/project/date.rb', line 1293

def start() @sg end

#step(limit, step = 1) ⇒ Object

Step the current date forward step days at a time (or backward, if step is negative) until we reach limit (inclusive), yielding the resultant date at each step.



1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
 
# File 'lib/project/date.rb', line 1445

def step(limit, step=1) # :yield: date
=begin
  if step.zero?
    raise ArgumentError, "step can't be 0"
  end
=end
  unless block_given?
    return to_enum(:step, limit, step)
  end
  da = self
  op = %w(- <= >=)[step <=> 0]
  while da.__send__(op, limit)
    yield da
    da += step
  end
  self
end

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



218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
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
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
 
# File 'lib/project/format.rb', line 218

def strftime(fmt='%F')
  fmt.gsub(/%([-_0^#]+)?(\d+)?([EO]?(?::{1,3}z|.))/m) do
    f = {}
    m = $&
    s, w, c = $1, $2, $3
    if s
      s.scan(/./) do |k|
        case k
        when '-'; f[:p] = '-'
        when '_'; f[:p] = "\s"
        when '0'; f[:p] = '0'
        when '^'; f[:u] = true
        when '#'; f[:x] = true
        end
      end
    end
    if w
      f[:w] = w.to_i
    end
    case c
    when 'A'; emit_ad(DAYNAMES[wday], 0, f)
    when 'a'; emit_ad(ABBR_DAYNAMES[wday], 0, f)
    when 'B'; emit_ad(MONTHNAMES[mon], 0, f)
    when 'b'; emit_ad(ABBR_MONTHNAMES[mon], 0, f)
    when 'C', 'EC'; emit_sn((year / 100).floor, 2, f)
    when 'c', 'Ec'; emit_a(strftime('%a %b %e %H:%M:%S %Y'), 0, f)
    when 'D'; emit_a(strftime('%m/%d/%y'), 0, f)
    when 'd', 'Od'; emit_n(mday, 2, f)
    when 'e', 'Oe'; emit_a(mday, 2, f)
    when 'F'
      if m == '%F'
        format('%.4d-%02d-%02d', year, mon, mday) # 4p
      else
        emit_a(strftime('%Y-%m-%d'), 0, f)
      end
    when 'G'; emit_sn(cwyear, 4, f)
    when 'g'; emit_n(cwyear % 100, 2, f)
    when 'H', 'OH'; emit_n(hour, 2, f)
    when 'h'; emit_ad(strftime('%b'), 0, f)
    when 'I', 'OI'; emit_n((hour % 12).nonzero? || 12, 2, f)
    when 'j'; emit_n(yday, 3, f)
    when 'k'; emit_a(hour, 2, f)
    when 'L'
      f[:p] = nil
      w = f[:w] || 3
      u = 10**w
      emit_n((sec_fraction * u).floor, w, f)
    when 'l'; emit_a((hour % 12).nonzero? || 12, 2, f)
    when 'M', 'OM'; emit_n(min, 2, f)
    when 'm', 'Om'; emit_n(mon, 2, f)
    when 'N'
      f[:p] = nil
      w = f[:w] || 9
      u = 10**w
      emit_n((sec_fraction * u).floor, w, f)
    when 'n'; emit_a("\n", 0, f)
    when 'P'; emit_ad(strftime('%p').downcase, 0, f)
    when 'p'; emit_au(if hour < 12 then 'AM' else 'PM' end, 0, f)
    when 'Q'
      s = ((ajd - UNIX_EPOCH_IN_AJD) / MILLISECONDS_IN_DAY).round
      emit_sn(s, 1, f)
    when 'R'; emit_a(strftime('%H:%M'), 0, f)
    when 'r'; emit_a(strftime('%I:%M:%S %p'), 0, f)
    when 'S', 'OS'; emit_n(sec, 2, f)
    when 's'
      s = ((ajd - UNIX_EPOCH_IN_AJD) / SECONDS_IN_DAY).round
      emit_sn(s, 1, f)
    when 'T'
      if m == '%T'
        format('%02d:%02d:%02d', hour, min, sec) # 4p
      else
        emit_a(strftime('%H:%M:%S'), 0, f)
      end
    when 't'; emit_a("\t", 0, f)
    when 'U', 'W', 'OU', 'OW'
      emit_n(if c[-1,1] == 'U' then wnum0 else wnum1 end, 2, f)
    when 'u', 'Ou'; emit_n(cwday, 1, f)
    when 'V', 'OV'; emit_n(cweek, 2, f)
    when 'v'; emit_a(strftime('%e-%b-%Y'), 0, f)
    when 'w', 'Ow'; emit_n(wday, 1, f)
    when 'X', 'EX'; emit_a(strftime('%H:%M:%S'), 0, f)
    when 'x', 'Ex'; emit_a(strftime('%m/%d/%y'), 0, f)
    when 'Y', 'EY'; emit_sn(year, 4, f)
    when 'y', 'Ey', 'Oy'; emit_n(year % 100, 2, f)
    when 'Z'; emit_au(strftime('%:z'), 0, f)
    when /\A(:{0,3})z/
      t = $1.size
      sign = if offset < 0 then -1 else +1 end
      fr = offset.abs
      ss = fr.div(SECONDS_IN_DAY) # 4p
      hh, ss = ss.divmod(3600)
      mm, ss = ss.divmod(60)
      if t == 3
        if    ss.nonzero? then t =  2
        elsif mm.nonzero? then t =  1
        else                   t = -1
        end
      end
      case t
      when -1
        tail = []
        sep = ''
      when 0
        f[:w] -= 2 if f[:w]
        tail = ['%02d' % mm]
        sep = ''
      when 1
        f[:w] -= 3 if f[:w]
        tail = ['%02d' % mm]
        sep = ':'
      when 2
        f[:w] -= 6 if f[:w]
        tail = ['%02d' % mm, '%02d' % ss]
        sep = ':'
      end
      ([emit_z(sign * hh, 2, f)] + tail).join(sep)
    when '%'; emit_a('%', 0, f)
    when '+'; emit_a(strftime('%a %b %e %H:%M:%S %Z %Y'), 0, f)
    else
      m
    end
  end
end

#time ⇒ Object

Get the time of this date as [hours, minutes, seconds, fraction_of_a_second]



1205
 
# File 'lib/project/date.rb', line 1205

def time() day_fraction_to_time(day_fraction) end

#to_date ⇒ Object 



1800
 
# File 'lib/project/date.rb', line 1800

def to_date() self end

#to_datetime ⇒ Object 



1801
 
# File 'lib/project/date.rb', line 1801

def to_datetime() DateTime.new!(jd_to_ajd(jd, 0, 0), @of, @sg) end

#to_s ⇒ Object

Return the date as a human-readable string.

The format used is YYYY-MM-DD.



1491
 
# File 'lib/project/date.rb', line 1491

def to_s() format('%.4d-%02d-%02d', year, mon, mday) end

#to_time ⇒ Object 



1799
 
# File 'lib/project/date.rb', line 1799

def to_time() Time.local(year, mon, mday) end

#upto(max, &block) ⇒ Object

Step forward one day at a time until we reach max (inclusive), yielding each date as we go.



1465
1466
1467
 
# File 'lib/project/date.rb', line 1465

def upto(max, &block) # :yield: date
  step(max, +1, &block)
end

#wday ⇒ Object

Get the week day of this date. Sunday is day-of-week 0; Saturday is day-of-week 6.



1246
 
# File 'lib/project/date.rb', line 1246

def wday() jd_to_wday(jd) end

#weeknum0 ⇒ Object

:nodoc:



1173
 
# File 'lib/project/date.rb', line 1173

def weeknum0() jd_to_weeknum(jd, 0, @sg) end

#weeknum1 ⇒ Object

:nodoc:



1174
 
# File 'lib/project/date.rb', line 1174

def weeknum1() jd_to_weeknum(jd, 1, @sg) end

#xmlschema ⇒ Object

:nodoc:



352
 
# File 'lib/project/format.rb', line 352

def xmlschema() iso8601 end

#yday ⇒ Object

Get the day-of-the-year of this date.

January 1 is day-of-the-year 1



1185
 
# File 'lib/project/date.rb', line 1185

def yday() ordinal[1] end

#year ⇒ Object

Get the year of this date.



1180
 
# File 'lib/project/date.rb', line 1180

def year() civil[0] end