Class: Date
Direct Known Subclasses
Defined Under Namespace
Classes: Infinity
Constant Summary collapse
- MONTHNAMES =
An array of strings of full month names in English. The first element is nil.
mk_ary_of_str(13, monthnames)
- ABBR_MONTHNAMES =
An array of strings of abbreviated month names in English. The first element is nil.
mk_ary_of_str(13, abbr_monthnames)
- DAYNAMES =
An array of strings of the full names of days of the week in English. The first is “Sunday”.
mk_ary_of_str(7, daynames)
- ABBR_DAYNAMES =
An array of strings of abbreviated day names in English. The first is “Sun”.
mk_ary_of_str(7, abbr_daynames)
- ITALY =
The Julian day number of the day of calendar reform for Italy and some catholic countries.
INT2FIX(ITALY)
- ENGLAND =
The Julian day number of the day of calendar reform for England and her colonies.
INT2FIX(ENGLAND)
- JULIAN =
The Julian day number of the day of calendar reform for the proleptic Julian calendar
DBL2NUM(JULIAN)
- GREGORIAN =
The Julian day number of the day of calendar reform for the proleptic Gregorian calendar
DBL2NUM(GREGORIAN)
Class Method Summary collapse
-
._httpdate(string) ⇒ Hash
Returns a hash of parsed elements.
-
._iso8601(string) ⇒ Hash
Returns a hash of parsed elements.
-
._jisx0301(string) ⇒ Hash
Returns a hash of parsed elements.
-
._load ⇒ Object
:nodoc:.
-
._parse(string[, comp = true]) ⇒ Hash
Parses the given representation of date and time, and returns a hash of parsed elements.
-
._rfc2822 ⇒ Object
Returns a hash of parsed elements.
-
._rfc3339(string) ⇒ Hash
Returns a hash of parsed elements.
-
._rfc822 ⇒ Object
Returns a hash of parsed elements.
-
._strptime(string[, format = '%F']) ⇒ Hash
Parses the given representation of date and time with the given template, and returns a hash of parsed elements.
-
._xmlschema(string) ⇒ Hash
Returns a hash of parsed elements.
-
.civil ⇒ Object
Creates a date object denoting the given calendar date.
-
.commercial([cwyear = -4712[, cweek=1[, cwday=1[, start=Date::ITALY]]]]) ⇒ Object
Creates a date object denoting the given week date.
-
.gregorian_leap? ⇒ Boolean
Returns true if the given year is a leap year of the proleptic Gregorian calendar.
-
.httpdate(string = 'Mon, 01 Jan -4712 00:00:00 GMT'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some RFC 2616 format.
-
.iso8601(string = '-4712-01-01'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some typical ISO 8601 formats.
-
.jd([jd = 0[, start=Date::ITALY]]) ⇒ Object
Creates a date object denoting the given chronological Julian day number.
-
.jisx0301(string = '-4712-01-01'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some typical JIS X 0301 formats.
-
.julian_leap?(year) ⇒ Boolean
Returns true if the given year is a leap year of the proleptic Julian calendar.
-
.leap? ⇒ Boolean
Returns true if the given year is a leap year of the proleptic Gregorian calendar.
-
.new ⇒ Object
Creates a date object denoting the given calendar date.
-
.ordinal([year = -4712[, yday=1[, start=Date::ITALY]]]) ⇒ Object
Creates a date object denoting the given ordinal date.
-
.parse(string = '-4712-01-01'[, comp=true[, start=ITALY]]) ⇒ Object
Parses the given representation of date and time, and creates a date object.
-
.rfc2822 ⇒ Object
Creates a new Date object by parsing from a string according to some typical RFC 2822 formats.
-
.rfc3339(string = '-4712-01-01T00:00:00+00:00'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some typical RFC 3339 formats.
-
.rfc822 ⇒ Object
Creates a new Date object by parsing from a string according to some typical RFC 2822 formats.
-
.strptime([string = '-4712-01-01'[, format='%F'[, start=ITALY]]]) ⇒ Object
Parses the given representation of date and time with the given template, and creates a date object.
-
.today([start = Date::ITALY]) ⇒ Object
Date.today #=> #<Date: 2011-06-11 ..>.
-
.valid_civil? ⇒ Boolean
Returns true if the given calendar date is valid, and false if not.
-
.valid_commercial?(cwyear, cweek, cwday[, start = Date::ITALY]) ⇒ Boolean
Returns true if the given week date is valid, and false if not.
-
.valid_date? ⇒ Boolean
Returns true if the given calendar date is valid, and false if not.
-
.valid_jd?(jd[, start = Date::ITALY]) ⇒ Boolean
Just returns true.
-
.valid_ordinal?(year, yday[, start = Date::ITALY]) ⇒ Boolean
Returns true if the given ordinal date is valid, and false if not.
-
.xmlschema(string = '-4712-01-01'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some typical XML Schema formats.
Instance Method Summary collapse
-
#+(other) ⇒ Object
Returns a date object pointing other days after self.
-
#-(other) ⇒ Object
Returns the difference between the two dates if the other is a date object.
-
#<<(n) ⇒ Object
Returns a date object pointing n months before self.
-
#<=>(other) ⇒ -1, ...
Compares the two dates and returns -1, zero, 1 or nil.
-
#===(other) ⇒ Boolean
Returns true if they are the same day.
-
#>>(n) ⇒ Object
Returns a date object pointing n months after self.
-
#ajd ⇒ Object
Returns the astronomical Julian day number.
-
#amjd ⇒ Object
Returns the astronomical modified Julian day number.
-
#asctime ⇒ Object
Returns a string in asctime(3) format (but without “n0” at the end).
-
#ctime ⇒ Object
Returns a string in asctime(3) format (but without “n0” at the end).
-
#cwday ⇒ Fixnum
Returns the day of calendar week (1-7, Monday is 1).
-
#cweek ⇒ Fixnum
Returns the calendar week number (1-53).
-
#cwyear ⇒ Integer
Returns the calendar week based year.
-
#day ⇒ Object
Returns the day of the month (1-31).
-
#day_fraction ⇒ Object
Returns the fractional part of the day.
-
#downto ⇒ Object
This method is equivalent to step(min, -1){|date| …}.
-
#england ⇒ Object
This method is equivalent to new_start(Date::ENGLAND).
-
#eql? ⇒ Boolean
:nodoc:.
-
#friday? ⇒ Boolean
Returns true if the date is Friday.
-
#gregorian ⇒ Object
This method is equivalent to new_start(Date::GREGORIAN).
-
#gregorian? ⇒ Boolean
Retunrs true if the date is on or after the day of calendar reform.
-
#hash ⇒ Object
:nodoc:.
-
#httpdate ⇒ String
This method is equivalent to strftime(‘%a, %d %b %Y %T GMT’).
-
#initialize_copy ⇒ Object
:nodoc:.
-
#inspect ⇒ String
Returns the value as a string for inspection.
-
#iso8601 ⇒ Object
This method is equivalent to strftime(‘%F’).
-
#italy ⇒ Object
This method is equivalent to new_start(Date::ITALY).
-
#jd ⇒ Integer
Returns the Julian day number.
-
#jisx0301 ⇒ String
Returns a string in a JIS X 0301 format.
-
#julian ⇒ Object
This method is equivalent to new_start(Date::JULIAN).
-
#julian? ⇒ Boolean
Retruns true if the date is before the day of calendar reform.
-
#ld ⇒ Integer
Returns the Lilian day number.
-
#leap? ⇒ Boolean
Returns true if the year is a leap year.
-
#marshal_dump ⇒ Object
:nodoc:.
-
#marshal_load ⇒ Object
:nodoc:.
-
#mday ⇒ Object
Returns the day of the month (1-31).
-
#mjd ⇒ Integer
Returns the modified Julian day number.
-
#mon ⇒ Object
Returns the month (1-12).
-
#monday? ⇒ Boolean
Returns true if the date is Monday.
-
#month ⇒ Object
Returns the month (1-12).
-
#new_start([start = Date::ITALY]) ⇒ Object
Duplicates self and resets its the day of calendar reform.
-
#next ⇒ Object
Returns a date object denoting the following day.
-
#next_day([n = 1]) ⇒ Object
This method is equivalent to d + n.
-
#next_month([n = 1]) ⇒ Object
This method is equivalent to d >> n.
-
#next_year([n = 1]) ⇒ Object
This method is equivalent to d >> (n * 12).
-
#prev_day([n = 1]) ⇒ Object
This method is equivalent to d - n.
-
#prev_month([n = 1]) ⇒ Object
This method is equivalent to d << n.
-
#prev_year([n = 1]) ⇒ Object
This method is equivalent to d << (n * 12).
-
#rfc2822 ⇒ Object
This method is equivalent to strftime(‘%a, %-d %b %Y %T %z’).
-
#rfc3339 ⇒ String
This method is equivalent to strftime(‘%FT%T%:z’).
-
#rfc822 ⇒ Object
This method is equivalent to strftime(‘%a, %-d %b %Y %T %z’).
-
#saturday? ⇒ Boolean
Returns true if the date is Saturday.
-
#start ⇒ Float
Returns the Julian day number denoting the day of calendar reform.
-
#step ⇒ Object
Iterates evaluation of the given block, which takes a date object.
-
#strftime([format = '%F']) ⇒ String
Formats date according to the directives in the given format string.
-
#succ ⇒ Object
Returns a date object denoting the following day.
-
#sunday? ⇒ Boolean
Returns true if the date is Sunday.
-
#thursday? ⇒ Boolean
Returns true if the date is Thursday.
-
#to_date ⇒ self
Returns self;.
-
#to_datetime ⇒ Object
Returns a DateTime object which denotes self.
-
#to_s ⇒ String
Returns a string in an ISO 8601 format (This method doesn’t use the expanded representations).
-
#to_time ⇒ Time
Returns a Time object which denotes self.
-
#tuesday? ⇒ Boolean
Returns true if the date is Tuesday.
-
#upto ⇒ Object
This method is equivalent to step(max, 1){|date| …}.
-
#wday ⇒ Fixnum
Returns the day of week (0-6, Sunday is zero).
-
#wednesday? ⇒ Boolean
Returns true if the date is Wednesday.
-
#xmlschema ⇒ Object
This method is equivalent to strftime(‘%F’).
-
#yday ⇒ Fixnum
Returns the day of the year (1-366).
-
#year ⇒ Integer
Returns the year.
Class Method Details
._httpdate(string) ⇒ Hash
Returns a hash of parsed elements.
4560 4561 4562 4563 4564 |
# File 'date_core.c', line 4560 static VALUE date_s__httpdate(VALUE klass, VALUE str) { return date__httpdate(str); } |
._iso8601(string) ⇒ Hash
Returns a hash of parsed elements.
4391 4392 4393 4394 4395 |
# File 'date_core.c', line 4391 static VALUE date_s__iso8601(VALUE klass, VALUE str) { return date__iso8601(str); } |
._jisx0301(string) ⇒ Hash
Returns a hash of parsed elements.
4602 4603 4604 4605 4606 |
# File 'date_core.c', line 4602 static VALUE date_s__jisx0301(VALUE klass, VALUE str) { return date__jisx0301(str); } |
._load ⇒ Object
:nodoc:
7151 7152 7153 7154 7155 7156 7157 7158 7159 |
# File 'date_core.c', line 7151 static VALUE date_s__load(VALUE klass, VALUE s) { VALUE a, obj; a = rb_marshal_load(s); obj = d_lite_s_alloc(klass); return d_lite_marshal_load(obj, a); } |
._parse(string[, comp = true]) ⇒ Hash
Parses the given representation of date and time, and returns a hash of parsed elements. This method does not function as a validator.
If the optional second argument is true and the detected year is in the range “00” to “99”, considers the year a 2-digit form and makes it full.
Date._parse('2001-02-03') #=> {:year=>2001, :mon=>2, :mday=>3}
4331 4332 4333 4334 4335 |
# File 'date_core.c', line 4331 static VALUE date_s__parse(int argc, VALUE *argv, VALUE klass) { return date_s__parse_internal(argc, argv, klass); } |
._rfc2822(string) ⇒ Hash ._rfc822(string) ⇒ Hash
Returns a hash of parsed elements.
4517 4518 4519 4520 4521 |
# File 'date_core.c', line 4517 static VALUE date_s__rfc2822(VALUE klass, VALUE str) { return date__rfc2822(str); } |
._rfc3339(string) ⇒ Hash
Returns a hash of parsed elements.
4434 4435 4436 4437 4438 |
# File 'date_core.c', line 4434 static VALUE date_s__rfc3339(VALUE klass, VALUE str) { return date__rfc3339(str); } |
._rfc2822(string) ⇒ Hash ._rfc822(string) ⇒ Hash
Returns a hash of parsed elements.
4517 4518 4519 4520 4521 |
# File 'date_core.c', line 4517 static VALUE date_s__rfc2822(VALUE klass, VALUE str) { return date__rfc2822(str); } |
._strptime(string[, format = '%F']) ⇒ Hash
Parses the given representation of date and time with the given template, and returns a hash of parsed elements. _strptime does not support specification of flags and width unlike strftime.
Date._strptime('2001-02-03', '%Y-%m-%d')
#=> :mon=>2, :mday=>3
See also strptime(3) and strftime.
4237 4238 4239 4240 4241 |
# File 'date_core.c', line 4237 static VALUE date_s__strptime(int argc, VALUE *argv, VALUE klass) { return date_s__strptime_internal(argc, argv, klass, "%F"); } |
._xmlschema(string) ⇒ Hash
Returns a hash of parsed elements.
4475 4476 4477 4478 4479 |
# File 'date_core.c', line 4475 static VALUE date_s__xmlschema(VALUE klass, VALUE str) { return date__xmlschema(str); } |
.civil([year = -4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Object .new([year = -4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Object
Creates a date object denoting the given calendar date.
In this class, BCE years are counted astronomically. Thus, the year before the year 1 is the year zero, and the year preceding the year zero is the year -1. The month and the day of month should be a negative or a positive number (as a relative month/day from the end of year/month when negative). They should not be zero.
The last argument should be a Julian day number which denotes the day of calendar reform. Date::ITALY (2299161=1582-10-15), Date::ENGLAND (2361222=1752-09-14), Date::GREGORIAN (the proleptic Gregorian calendar) and Date::JULIAN (the proleptic Julian calendar) can be specified as a day of calendar reform.
Date.new(2001) #=> #<Date: 2001-01-01 ...>
Date.new(2001,2,3) #=> #<Date: 2001-02-03 ...>
Date.new(2001,2,-1) #=> #<Date: 2001-02-28 ...>
See also jd.
3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 |
# File 'date_core.c', line 3385 static VALUE date_s_civil(int argc, VALUE *argv, VALUE klass) { VALUE vy, vm, vd, vsg, y, fr, fr2, ret; int m, d; double sg; rb_scan_args(argc, argv, "04", &vy, &vm, &vd, &vsg); y = INT2FIX(-4712); m = 1; d = 1; fr2 = INT2FIX(0); sg = DEFAULT_SG; switch (argc) { case 4: val2sg(vsg, sg); case 3: num2int_with_frac(d, positive_inf); case 2: m = NUM2INT(vm); case 1: y = vy; } if (guess_style(y, sg) < 0) { VALUE nth; int ry, rm, rd; if (!valid_gregorian_p(y, m, d, &nth, &ry, &rm, &rd)) rb_raise(rb_eArgError, "invalid date"); ret = d_simple_new_internal(klass, nth, 0, sg, ry, rm, rd, HAVE_CIVIL); } else { VALUE nth; int ry, rm, rd, rjd, ns; if (!valid_civil_p(y, m, d, sg, &nth, &ry, &rm, &rd, &rjd, &ns)) rb_raise(rb_eArgError, "invalid date"); ret = d_simple_new_internal(klass, nth, rjd, sg, ry, rm, rd, HAVE_JD | HAVE_CIVIL); } add_frac(); return ret; } |
.commercial([cwyear = -4712[, cweek=1[, cwday=1[, start=Date::ITALY]]]]) ⇒ Object
Creates a date object denoting the given week date.
The week and the day of week should be a negative or a positive number (as a relative week/day from the end of year/week when negative). They should not be zero.
Date.commercial(2001) #=> #<Date: 2001-01-01 ...>
Date.commercial(2002) #=> #<Date: 2001-12-31 ...>
Date.commercial(2001,5,6) #=> #<Date: 2001-02-03 ...>
See also jd and new.
3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 |
# File 'date_core.c', line 3462 static VALUE date_s_commercial(int argc, VALUE *argv, VALUE klass) { VALUE vy, vw, vd, vsg, y, fr, fr2, ret; int w, d; double sg; rb_scan_args(argc, argv, "04", &vy, &vw, &vd, &vsg); y = INT2FIX(-4712); w = 1; d = 1; fr2 = INT2FIX(0); sg = DEFAULT_SG; switch (argc) { case 4: val2sg(vsg, sg); case 3: num2int_with_frac(d, positive_inf); case 2: w = NUM2INT(vw); case 1: y = vy; } { VALUE nth; int ry, rw, rd, rjd, ns; if (!valid_commercial_p(y, w, d, sg, &nth, &ry, &rw, &rd, &rjd, &ns)) rb_raise(rb_eArgError, "invalid date"); ret = d_simple_new_internal(klass, nth, rjd, sg, 0, 0, 0, HAVE_JD); } add_frac(); return ret; } |
.gregorian_leap?(year) ⇒ Boolean .leap?(year) ⇒ Boolean
Returns true if the given year is a leap year of the proleptic Gregorian calendar.
Date.gregorian_leap?(1900) #=> false
Date.gregorian_leap?(2000) #=> true
2937 2938 2939 2940 2941 2942 2943 2944 2945 |
# File 'date_core.c', line 2937 static VALUE date_s_gregorian_leap_p(VALUE klass, VALUE y) { VALUE nth; int ry; decode_year(y, -1, &nth, &ry); return f_boolcast(c_gregorian_leap_p(ry)); } |
.httpdate(string = 'Mon, 01 Jan -4712 00:00:00 GMT'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some RFC 2616 format.
Date.httpdate('Sat, 03 Feb 2001 00:00:00 GMT')
#=> #<Date: 2001-02-03 …>
4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 |
# File 'date_core.c', line 4576 static VALUE date_s_httpdate(int argc, VALUE *argv, VALUE klass) { VALUE str, sg; rb_scan_args(argc, argv, "02", &str, &sg); switch (argc) { case 0: str = rb_str_new2("Mon, 01 Jan -4712 00:00:00 GMT"); case 1: sg = INT2FIX(DEFAULT_SG); } { VALUE hash = date_s__httpdate(klass, str); return d_new_by_frags(klass, hash, sg); } } |
.iso8601(string = '-4712-01-01'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some typical ISO 8601 formats.
Date.iso8601('2001-02-03') #=> #<Date: 2001-02-03 ...>
Date.iso8601('20010203') #=> #<Date: 2001-02-03 ...>
Date.iso8601('2001-W05-6') #=> #<Date: 2001-02-03 ...>
4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 |
# File 'date_core.c', line 4408 static VALUE date_s_iso8601(int argc, VALUE *argv, VALUE klass) { VALUE str, sg; rb_scan_args(argc, argv, "02", &str, &sg); switch (argc) { case 0: str = rb_str_new2("-4712-01-01"); case 1: sg = INT2FIX(DEFAULT_SG); } { VALUE hash = date_s__iso8601(klass, str); return d_new_by_frags(klass, hash, sg); } } |
.jd([jd = 0[, start=Date::ITALY]]) ⇒ Object
Creates a date object denoting the given chronological Julian day number.
Date.jd(2451944) #=> #<Date: 2001-02-03 ...>
Date.jd(2451945) #=> #<Date: 2001-02-04 ...>
Date.jd(0) #=> #<Date: -4712-01-01 ...>
See also new.
3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 |
# File 'date_core.c', line 3267 static VALUE date_s_jd(int argc, VALUE *argv, VALUE klass) { VALUE vjd, vsg, jd, fr, fr2, ret; double sg; rb_scan_args(argc, argv, "02", &vjd, &vsg); jd = INT2FIX(0); fr2 = INT2FIX(0); sg = DEFAULT_SG; switch (argc) { case 2: val2sg(vsg, sg); case 1: num2num_with_frac(jd, positive_inf); } { VALUE nth; int rjd; decode_jd(jd, &nth, &rjd); ret = d_simple_new_internal(klass, nth, rjd, sg, 0, 0, 0, HAVE_JD); } add_frac(); return ret; } |
.jisx0301(string = '-4712-01-01'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some typical JIS X 0301 formats.
Date.jisx0301('H13.02.03') #=> #<Date: 2001-02-03 ...>
4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 |
# File 'date_core.c', line 4617 static VALUE date_s_jisx0301(int argc, VALUE *argv, VALUE klass) { VALUE str, sg; rb_scan_args(argc, argv, "02", &str, &sg); switch (argc) { case 0: str = rb_str_new2("-4712-01-01"); case 1: sg = INT2FIX(DEFAULT_SG); } { VALUE hash = date_s__jisx0301(klass, str); return d_new_by_frags(klass, hash, sg); } } |
.julian_leap?(year) ⇒ Boolean
Returns true if the given year is a leap year of the proleptic Julian calendar.
Date.julian_leap?(1900) #=> true
Date.julian_leap?(1901) #=> false
2916 2917 2918 2919 2920 2921 2922 2923 2924 |
# File 'date_core.c', line 2916 static VALUE date_s_julian_leap_p(VALUE klass, VALUE y) { VALUE nth; int ry; decode_year(y, +1, &nth, &ry); return f_boolcast(c_julian_leap_p(ry)); } |
.gregorian_leap?(year) ⇒ Boolean .leap?(year) ⇒ Boolean
Returns true if the given year is a leap year of the proleptic Gregorian calendar.
Date.gregorian_leap?(1900) #=> false
Date.gregorian_leap?(2000) #=> true
2937 2938 2939 2940 2941 2942 2943 2944 2945 |
# File 'date_core.c', line 2937 static VALUE date_s_gregorian_leap_p(VALUE klass, VALUE y) { VALUE nth; int ry; decode_year(y, -1, &nth, &ry); return f_boolcast(c_gregorian_leap_p(ry)); } |
.civil([year = -4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Object .new([year = -4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Object
Creates a date object denoting the given calendar date.
In this class, BCE years are counted astronomically. Thus, the year before the year 1 is the year zero, and the year preceding the year zero is the year -1. The month and the day of month should be a negative or a positive number (as a relative month/day from the end of year/month when negative). They should not be zero.
The last argument should be a Julian day number which denotes the day of calendar reform. Date::ITALY (2299161=1582-10-15), Date::ENGLAND (2361222=1752-09-14), Date::GREGORIAN (the proleptic Gregorian calendar) and Date::JULIAN (the proleptic Julian calendar) can be specified as a day of calendar reform.
Date.new(2001) #=> #<Date: 2001-01-01 ...>
Date.new(2001,2,3) #=> #<Date: 2001-02-03 ...>
Date.new(2001,2,-1) #=> #<Date: 2001-02-28 ...>
See also jd.
3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 |
# File 'date_core.c', line 3385 static VALUE date_s_civil(int argc, VALUE *argv, VALUE klass) { VALUE vy, vm, vd, vsg, y, fr, fr2, ret; int m, d; double sg; rb_scan_args(argc, argv, "04", &vy, &vm, &vd, &vsg); y = INT2FIX(-4712); m = 1; d = 1; fr2 = INT2FIX(0); sg = DEFAULT_SG; switch (argc) { case 4: val2sg(vsg, sg); case 3: num2int_with_frac(d, positive_inf); case 2: m = NUM2INT(vm); case 1: y = vy; } if (guess_style(y, sg) < 0) { VALUE nth; int ry, rm, rd; if (!valid_gregorian_p(y, m, d, &nth, &ry, &rm, &rd)) rb_raise(rb_eArgError, "invalid date"); ret = d_simple_new_internal(klass, nth, 0, sg, ry, rm, rd, HAVE_CIVIL); } else { VALUE nth; int ry, rm, rd, rjd, ns; if (!valid_civil_p(y, m, d, sg, &nth, &ry, &rm, &rd, &rjd, &ns)) rb_raise(rb_eArgError, "invalid date"); ret = d_simple_new_internal(klass, nth, rjd, sg, ry, rm, rd, HAVE_JD | HAVE_CIVIL); } add_frac(); return ret; } |
.ordinal([year = -4712[, yday=1[, start=Date::ITALY]]]) ⇒ Object
Creates a date object denoting the given ordinal date.
The day of year should be a negative or a positive number (as a relative day from the end of year when negative). It should not be zero.
Date.ordinal(2001) #=> #<Date: 2001-01-01 ...>
Date.ordinal(2001,34) #=> #<Date: 2001-02-03 ...>
Date.ordinal(2001,-1) #=> #<Date: 2001-12-31 ...>
See also jd and new.
3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 |
# File 'date_core.c', line 3317 static VALUE date_s_ordinal(int argc, VALUE *argv, VALUE klass) { VALUE vy, vd, vsg, y, fr, fr2, ret; int d; double sg; rb_scan_args(argc, argv, "03", &vy, &vd, &vsg); y = INT2FIX(-4712); d = 1; fr2 = INT2FIX(0); sg = DEFAULT_SG; switch (argc) { case 3: val2sg(vsg, sg); case 2: num2int_with_frac(d, positive_inf); case 1: y = vy; } { VALUE nth; int ry, rd, rjd, ns; if (!valid_ordinal_p(y, d, sg, &nth, &ry, &rd, &rjd, &ns)) rb_raise(rb_eArgError, "invalid date"); ret = d_simple_new_internal(klass, nth, rjd, sg, 0, 0, 0, HAVE_JD); } add_frac(); return ret; } |
.parse(string = '-4712-01-01'[, comp=true[, start=ITALY]]) ⇒ Object
Parses the given representation of date and time, and creates a date object. This method does not function as a validator.
If the optional second argument is true and the detected year is in the range “00” to “99”, considers the year a 2-digit form and makes it full.
Date.parse('2001-02-03') #=> #<Date: 2001-02-03 ...>
Date.parse('20010203') #=> #<Date: 2001-02-03 ...>
Date.parse('3rd Feb 2001') #=> #<Date: 2001-02-03 ...>
4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 |
# File 'date_core.c', line 4352 static VALUE date_s_parse(int argc, VALUE *argv, VALUE klass) { VALUE str, comp, sg; rb_scan_args(argc, argv, "03", &str, &comp, &sg); switch (argc) { case 0: str = rb_str_new2("-4712-01-01"); case 1: comp = Qtrue; case 2: sg = INT2FIX(DEFAULT_SG); } { VALUE argv2[2], hash; argv2[0] = str; argv2[1] = comp; hash = date_s__parse(2, argv2, klass); return d_new_by_frags(klass, hash, sg); } } |
.rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Object .rfc822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some typical RFC 2822 formats.
Date.rfc2822('Sat, 3 Feb 2001 00:00:00 +0000')
#=> #<Date: 2001-02-03 …>
4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 |
# File 'date_core.c', line 4534 static VALUE date_s_rfc2822(int argc, VALUE *argv, VALUE klass) { VALUE str, sg; rb_scan_args(argc, argv, "02", &str, &sg); switch (argc) { case 0: str = rb_str_new2("Mon, 1 Jan -4712 00:00:00 +0000"); case 1: sg = INT2FIX(DEFAULT_SG); } { VALUE hash = date_s__rfc2822(klass, str); return d_new_by_frags(klass, hash, sg); } } |
.rfc3339(string = '-4712-01-01T00:00:00+00:00'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some typical RFC 3339 formats.
Date.rfc3339('2001-02-03T04:05:06+07:00') #=> #<Date: 2001-02-03 ...>
4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 |
# File 'date_core.c', line 4449 static VALUE date_s_rfc3339(int argc, VALUE *argv, VALUE klass) { VALUE str, sg; rb_scan_args(argc, argv, "02", &str, &sg); switch (argc) { case 0: str = rb_str_new2("-4712-01-01T00:00:00+00:00"); case 1: sg = INT2FIX(DEFAULT_SG); } { VALUE hash = date_s__rfc3339(klass, str); return d_new_by_frags(klass, hash, sg); } } |
.rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Object .rfc822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some typical RFC 2822 formats.
Date.rfc2822('Sat, 3 Feb 2001 00:00:00 +0000')
#=> #<Date: 2001-02-03 …>
4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 |
# File 'date_core.c', line 4534 static VALUE date_s_rfc2822(int argc, VALUE *argv, VALUE klass) { VALUE str, sg; rb_scan_args(argc, argv, "02", &str, &sg); switch (argc) { case 0: str = rb_str_new2("Mon, 1 Jan -4712 00:00:00 +0000"); case 1: sg = INT2FIX(DEFAULT_SG); } { VALUE hash = date_s__rfc2822(klass, str); return d_new_by_frags(klass, hash, sg); } } |
.strptime([string = '-4712-01-01'[, format='%F'[, start=ITALY]]]) ⇒ Object
Parses the given representation of date and time with the given template, and creates a date object. strptime does not support specification of flags and width unlike strftime.
Date.strptime('2001-02-03', '%Y-%m-%d') #=> #<Date: 2001-02-03 ...>
Date.strptime('03-02-2001', '%d-%m-%Y') #=> #<Date: 2001-02-03 ...>
Date.strptime('2001-034', '%Y-%j') #=> #<Date: 2001-02-03 ...>
Date.strptime('2001-W05-6', '%G-W%V-%u') #=> #<Date: 2001-02-03 ...>
Date.strptime('2001 04 6', '%Y %U %w') #=> #<Date: 2001-02-03 ...>
Date.strptime('2001 05 6', '%Y %W %u') #=> #<Date: 2001-02-03 ...>
Date.strptime('sat3feb01', '%a%d%b%y') #=> #<Date: 2001-02-03 ...>
See also strptime(3) and strftime.
4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 |
# File 'date_core.c', line 4261 static VALUE date_s_strptime(int argc, VALUE *argv, VALUE klass) { VALUE str, fmt, sg; rb_scan_args(argc, argv, "03", &str, &fmt, &sg); switch (argc) { case 0: str = rb_str_new2("-4712-01-01"); case 1: fmt = rb_str_new2("%F"); case 2: sg = INT2FIX(DEFAULT_SG); } { VALUE argv2[2], hash; argv2[0] = str; argv2[1] = fmt; hash = date_s__strptime(2, argv2, klass); return d_new_by_frags(klass, hash, sg); } } |
.today([start = Date::ITALY]) ⇒ Object
Date.today #=> #<Date: 2011-06-11 ..>
Creates a date object denoting the present day.
3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 |
# File 'date_core.c', line 3638 static VALUE date_s_today(int argc, VALUE *argv, VALUE klass) { VALUE vsg, nth, ret; double sg; time_t t; struct tm tm; int y, ry, m, d; rb_scan_args(argc, argv, "01", &vsg); if (argc < 1) sg = DEFAULT_SG; else val2sg(vsg, sg); if (time(&t) == -1) rb_sys_fail("time"); tzset(); if (!localtime_r(&t, &tm)) rb_sys_fail("localtime"); y = tm.tm_year + 1900; m = tm.tm_mon + 1; d = tm.tm_mday; decode_year(INT2FIX(y), -1, &nth, &ry); ret = d_simple_new_internal(klass, nth, 0, GREGORIAN, ry, m, d, HAVE_CIVIL); { get_d1(ret); set_sg(dat, sg); } return ret; } |
.valid_civil?(year, month, mday[, start = Date::ITALY]) ⇒ Boolean .valid_date?(year, month, mday[, start = Date::ITALY]) ⇒ Boolean
Returns true if the given calendar date is valid, and false if not.
Date.valid_date?(2001,2,3) #=> true
Date.valid_date?(2001,2,29) #=> false
See also jd and civil.
2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 |
# File 'date_core.c', line 2570 static VALUE date_s_valid_civil_p(int argc, VALUE *argv, VALUE klass) { VALUE vy, vm, vd, vsg; VALUE argv2[4]; rb_scan_args(argc, argv, "31", &vy, &vm, &vd, &vsg); argv2[0] = vy; argv2[1] = vm; argv2[2] = vd; if (argc < 4) argv2[3] = INT2FIX(DEFAULT_SG); else argv2[3] = vsg; if (NIL_P(valid_civil_sub(4, argv2, klass, 0))) return Qfalse; return Qtrue; } |
.valid_commercial?(cwyear, cweek, cwday[, start = Date::ITALY]) ⇒ Boolean
Returns true if the given week date is valid, and false if not.
Date.valid_commercial?(2001,5,6) #=> true
Date.valid_commercial?(2001,5,8) #=> false
See also jd and commercial.
2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 |
# File 'date_core.c', line 2733 static VALUE date_s_valid_commercial_p(int argc, VALUE *argv, VALUE klass) { VALUE vy, vw, vd, vsg; VALUE argv2[4]; rb_scan_args(argc, argv, "31", &vy, &vw, &vd, &vsg); argv2[0] = vy; argv2[1] = vw; argv2[2] = vd; if (argc < 4) argv2[3] = INT2FIX(DEFAULT_SG); else argv2[3] = vsg; if (NIL_P(valid_commercial_sub(4, argv2, klass, 0))) return Qfalse; return Qtrue; } |
.valid_civil?(year, month, mday[, start = Date::ITALY]) ⇒ Boolean .valid_date?(year, month, mday[, start = Date::ITALY]) ⇒ Boolean
Returns true if the given calendar date is valid, and false if not.
Date.valid_date?(2001,2,3) #=> true
Date.valid_date?(2001,2,29) #=> false
See also jd and civil.
2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 |
# File 'date_core.c', line 2570 static VALUE date_s_valid_civil_p(int argc, VALUE *argv, VALUE klass) { VALUE vy, vm, vd, vsg; VALUE argv2[4]; rb_scan_args(argc, argv, "31", &vy, &vm, &vd, &vsg); argv2[0] = vy; argv2[1] = vm; argv2[2] = vd; if (argc < 4) argv2[3] = INT2FIX(DEFAULT_SG); else argv2[3] = vsg; if (NIL_P(valid_civil_sub(4, argv2, klass, 0))) return Qfalse; return Qtrue; } |
.valid_jd?(jd[, start = Date::ITALY]) ⇒ Boolean
Just returns true. It’s nonsense, but is for symmetry.
Date.valid_jd?(2451944) #=> true
See also jd.
2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 |
# File 'date_core.c', line 2481 static VALUE date_s_valid_jd_p(int argc, VALUE *argv, VALUE klass) { VALUE vjd, vsg; VALUE argv2[2]; rb_scan_args(argc, argv, "11", &vjd, &vsg); argv2[0] = vjd; if (argc < 2) argv2[1] = INT2FIX(DEFAULT_SG); else argv2[1] = vsg; if (NIL_P(valid_jd_sub(2, argv2, klass, 0))) return Qfalse; return Qtrue; } |
.valid_ordinal?(year, yday[, start = Date::ITALY]) ⇒ Boolean
Returns true if the given ordinal date is valid, and false if not.
Date.valid_ordinal?(2001,34) #=> true
Date.valid_ordinal?(2001,366) #=> false
See also jd and ordinal.
2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 |
# File 'date_core.c', line 2651 static VALUE date_s_valid_ordinal_p(int argc, VALUE *argv, VALUE klass) { VALUE vy, vd, vsg; VALUE argv2[3]; rb_scan_args(argc, argv, "21", &vy, &vd, &vsg); argv2[0] = vy; argv2[1] = vd; if (argc < 3) argv2[2] = INT2FIX(DEFAULT_SG); else argv2[2] = vsg; if (NIL_P(valid_ordinal_sub(3, argv2, klass, 0))) return Qfalse; return Qtrue; } |
.xmlschema(string = '-4712-01-01'[, start=ITALY]) ⇒ Object
Creates a new Date object by parsing from a string according to some typical XML Schema formats.
Date.xmlschema('2001-02-03') #=> #<Date: 2001-02-03 ...>
4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 |
# File 'date_core.c', line 4490 static VALUE date_s_xmlschema(int argc, VALUE *argv, VALUE klass) { VALUE str, sg; rb_scan_args(argc, argv, "02", &str, &sg); switch (argc) { case 0: str = rb_str_new2("-4712-01-01"); case 1: sg = INT2FIX(DEFAULT_SG); } { VALUE hash = date_s__xmlschema(klass, str); return d_new_by_frags(klass, hash, sg); } } |
Instance Method Details
#+(other) ⇒ Object
Returns a date object pointing other days after self. The other should be a numeric value. If the other is flonum, assumes its precision is at most nanosecond.
Date.new(2001,2,3) + 1 #=> #<Date: 2001-02-04 ...>
DateTime.new(2001,2,3) + Rational(1,2)
#=> #<DateTime: 2001-02-03T12:00:00+00:00 …>
DateTime.new(2001,2,3) + Rational(-1,2)
#=> #<DateTime: 2001-02-02T12:00:00+00:00 …>
DateTime.jd(0,12) + DateTime.new(2001,2,3).ajd
#=> #<DateTime: 2001-02-03T00:00:00+00:00 …>
5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770 5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815 5816 5817 5818 5819 |
# File 'date_core.c', line 5504 static VALUE d_lite_plus(VALUE self, VALUE other) { get_d1(self); switch (TYPE(other)) { case T_FIXNUM: { VALUE nth; long t; int jd; nth = m_nth(dat); t = FIX2LONG(other); if (DIV(t, CM_PERIOD)) { nth = f_add(nth, INT2FIX(DIV(t, CM_PERIOD))); t = MOD(t, CM_PERIOD); } if (!t) jd = m_jd(dat); else { jd = m_jd(dat) + (int)t; canonicalize_jd(nth, jd); } if (simple_dat_p(dat)) return d_simple_new_internal(rb_obj_class(self), nth, jd, dat->s.sg, 0, 0, 0, (dat->s.flags | HAVE_JD) & ~HAVE_CIVIL); else return d_complex_new_internal(rb_obj_class(self), nth, jd, dat->c.df, dat->c.sf, dat->c.of, dat->c.sg, 0, 0, 0, #ifndef USE_PACK dat->c.hour, dat->c.min, dat->c.sec, #else EX_HOUR(dat->c.pc), EX_MIN(dat->c.pc), EX_SEC(dat->c.pc), #endif (dat->c.flags | HAVE_JD) & ~HAVE_CIVIL); } break; case T_BIGNUM: { VALUE nth; int jd, s; if (f_positive_p(other)) s = +1; else { s = -1; other = f_negate(other); } nth = f_idiv(other, INT2FIX(CM_PERIOD)); jd = FIX2INT(f_mod(other, INT2FIX(CM_PERIOD))); if (s < 0) { nth = f_negate(nth); jd = -jd; } if (!jd) jd = m_jd(dat); else { jd = m_jd(dat) + jd; canonicalize_jd(nth, jd); } if (f_zero_p(nth)) nth = m_nth(dat); else nth = f_add(m_nth(dat), nth); if (simple_dat_p(dat)) return d_simple_new_internal(rb_obj_class(self), nth, jd, dat->s.sg, 0, 0, 0, (dat->s.flags | HAVE_JD) & ~HAVE_CIVIL); else return d_complex_new_internal(rb_obj_class(self), nth, jd, dat->c.df, dat->c.sf, dat->c.of, dat->c.sg, 0, 0, 0, #ifndef USE_PACK dat->c.hour, dat->c.min, dat->c.sec, #else EX_HOUR(dat->c.pc), EX_MIN(dat->c.pc), EX_SEC(dat->c.pc), #endif (dat->c.flags | HAVE_JD) & ~HAVE_CIVIL); } break; case T_FLOAT: { double jd, o, tmp; int s, df; VALUE nth, sf; o = RFLOAT_VALUE(other); if (o > 0) s = +1; else { s = -1; o = -o; } o = modf(o, &tmp); if (!floor(tmp / CM_PERIOD)) { nth = INT2FIX(0); jd = (int)tmp; } else { double i, f; f = modf(tmp / CM_PERIOD, &i); nth = f_floor(DBL2NUM(i)); jd = (int)(f * CM_PERIOD); } o *= DAY_IN_SECONDS; o = modf(o, &tmp); df = (int)tmp; o *= SECOND_IN_NANOSECONDS; sf = INT2FIX((int)round(o)); if (s < 0) { jd = -jd; df = -df; sf = f_negate(sf); } if (f_zero_p(sf)) sf = m_sf(dat); else { sf = f_add(m_sf(dat), sf); if (f_lt_p(sf, INT2FIX(0))) { df -= 1; sf = f_add(sf, INT2FIX(SECOND_IN_NANOSECONDS)); } else if (f_ge_p(sf, INT2FIX(SECOND_IN_NANOSECONDS))) { df += 1; sf = f_sub(sf, INT2FIX(SECOND_IN_NANOSECONDS)); } } if (!df) df = m_df(dat); else { df = m_df(dat) + df; if (df < 0) { jd -= 1; df += DAY_IN_SECONDS; } else if (df >= DAY_IN_SECONDS) { jd += 1; df -= DAY_IN_SECONDS; } } if (!jd) jd = m_jd(dat); else { jd = m_jd(dat) + jd; canonicalize_jd(nth, jd); } if (f_zero_p(nth)) nth = m_nth(dat); else nth = f_add(m_nth(dat), nth); if (!df && f_zero_p(sf) && !m_of(dat)) return d_simple_new_internal(rb_obj_class(self), nth, (int)jd, m_sg(dat), 0, 0, 0, (dat->s.flags | HAVE_JD) & ~(HAVE_CIVIL | HAVE_TIME | COMPLEX_DAT)); else return d_complex_new_internal(rb_obj_class(self), nth, (int)jd, df, sf, m_of(dat), m_sg(dat), 0, 0, 0, 0, 0, 0, (dat->c.flags | HAVE_JD | HAVE_DF) & ~(HAVE_CIVIL | HAVE_TIME)); } break; default: if (!k_numeric_p(other)) rb_raise(rb_eTypeError, "expected numeric"); other = f_to_r(other); #ifdef CANONICALIZATION_FOR_MATHN if (!k_rational_p(other)) return d_lite_plus(self, other); #endif /* fall through */ case T_RATIONAL: { VALUE nth, sf, t; int jd, df, s; if (wholenum_p(other)) return d_lite_plus(self, RRATIONAL(other)->num); if (f_positive_p(other)) s = +1; else { s = -1; other = f_negate(other); } nth = f_idiv(other, INT2FIX(CM_PERIOD)); t = f_mod(other, INT2FIX(CM_PERIOD)); jd = FIX2INT(f_idiv(t, INT2FIX(1))); t = f_mod(t, INT2FIX(1)); t = f_mul(t, INT2FIX(DAY_IN_SECONDS)); df = FIX2INT(f_idiv(t, INT2FIX(1))); t = f_mod(t, INT2FIX(1)); sf = f_mul(t, INT2FIX(SECOND_IN_NANOSECONDS)); if (s < 0) { nth = f_negate(nth); jd = -jd; df = -df; sf = f_negate(sf); } if (f_zero_p(sf)) sf = m_sf(dat); else { sf = f_add(m_sf(dat), sf); if (f_lt_p(sf, INT2FIX(0))) { df -= 1; sf = f_add(sf, INT2FIX(SECOND_IN_NANOSECONDS)); } else if (f_ge_p(sf, INT2FIX(SECOND_IN_NANOSECONDS))) { df += 1; sf = f_sub(sf, INT2FIX(SECOND_IN_NANOSECONDS)); } } if (!df) df = m_df(dat); else { df = m_df(dat) + df; if (df < 0) { jd -= 1; df += DAY_IN_SECONDS; } else if (df >= DAY_IN_SECONDS) { jd += 1; df -= DAY_IN_SECONDS; } } if (!jd) jd = m_jd(dat); else { jd = m_jd(dat) + jd; canonicalize_jd(nth, jd); } if (f_zero_p(nth)) nth = m_nth(dat); else nth = f_add(m_nth(dat), nth); if (!df && f_zero_p(sf) && !m_of(dat)) return d_simple_new_internal(rb_obj_class(self), nth, jd, m_sg(dat), 0, 0, 0, (dat->s.flags | HAVE_JD) & ~(HAVE_CIVIL | HAVE_TIME | COMPLEX_DAT)); else return d_complex_new_internal(rb_obj_class(self), nth, jd, df, sf, m_of(dat), m_sg(dat), 0, 0, 0, 0, 0, 0, (dat->c.flags | HAVE_JD | HAVE_DF) & ~(HAVE_CIVIL | HAVE_TIME)); } break; } } |
#-(other) ⇒ Object
Returns the difference between the two dates if the other is a date object. If the other is a numeric value, returns a date object pointing other days before self. If the other is flonum, assumes its precision is at most nanosecond.
Date.new(2001,2,3) - 1 #=> #<Date: 2001-02-02 ...>
DateTime.new(2001,2,3) - Rational(1,2)
#=> #<DateTime: 2001-02-02T12:00:00+00:00 …>
Date.new(2001,2,3) - Date.new(2001)
#=> (33/1)
DateTime.new(2001,2,3) - DateTime.new(2001,2,2,12)
#=> (1/2)
5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 |
# File 'date_core.c', line 5889 static VALUE d_lite_minus(VALUE self, VALUE other) { if (k_date_p(other)) return minus_dd(self, other); switch (TYPE(other)) { case T_FIXNUM: return d_lite_plus(self, LONG2NUM(-FIX2LONG(other))); case T_FLOAT: return d_lite_plus(self, DBL2NUM(-RFLOAT_VALUE(other))); default: if (!k_numeric_p(other)) rb_raise(rb_eTypeError, "expected numeric"); /* fall through */ case T_BIGNUM: case T_RATIONAL: return d_lite_plus(self, f_negate(other)); } } |
#<<(n) ⇒ Object
Returns a date object pointing n months before self. The n should be a numeric value.
Date.new(2001,2,3) << 1 #=> #<Date: 2001-01-03 ...>
Date.new(2001,1,31) << 11 #=> #<Date: 2000-02-29 ...>
Date.new(2001,2,3) << -1 #=> #<Date: 2001-03-03 ...>
6018 6019 6020 6021 6022 |
# File 'date_core.c', line 6018 static VALUE d_lite_lshift(VALUE self, VALUE other) { return d_lite_rshift(self, f_negate(other)); } |
#<=>(other) ⇒ -1, ...
Compares the two dates and returns -1, zero, 1 or nil. The other should be a date object or a numeric value as an astronomical Julian day number.
Date.new(2001,2,3) <=> Date.new(2001,2,4) #=> -1
Date.new(2001,2,3) <=> Date.new(2001,2,3) #=> 0
Date.new(2001,2,3) <=> Date.new(2001,2,2) #=> 1
Date.new(2001,2,3) <=> Object.new #=> nil
Date.new(2001,2,3) <=> Rational(4903887,2)#=> 0
See also Comparable.
6275 6276 6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306 6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 |
# File 'date_core.c', line 6275 static VALUE d_lite_cmp(VALUE self, VALUE other) { if (!k_date_p(other)) return cmp_gen(self, other); { get_d2(self, other); if (!(simple_dat_p(adat) && simple_dat_p(bdat) && m_gregorian_p(adat) == m_gregorian_p(bdat))) return cmp_dd(self, other); { VALUE a_nth, b_nth; int a_jd, b_jd; m_canonicalize_jd(adat); m_canonicalize_jd(bdat); a_nth = m_nth(adat); b_nth = m_nth(bdat); if (f_eqeq_p(a_nth, b_nth)) { a_jd = m_jd(adat); b_jd = m_jd(bdat); if (a_jd == b_jd) { return INT2FIX(0); } else if (a_jd < b_jd) { return INT2FIX(-1); } else { return INT2FIX(1); } } else if (a_nth < b_nth) { return INT2FIX(-1); } else { return INT2FIX(1); } } } } |
#===(other) ⇒ Boolean
Returns true if they are the same day.
Date.new(2001,2,3) === Date.new(2001,2,3)
#=> true
Date.new(2001,2,3) === Date.new(2001,2,4)
#=> false
DateTime.new(2001,2,3) === DateTime.new(2001,2,3,12)
#=> true
DateTime.new(2001,2,3) === DateTime.new(2001,2,3,0,0,0,'+24:00')
#=> true
DateTime.new(2001,2,3) === DateTime.new(2001,2,4,0,0,0,'+24:00')
#=> false
6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 |
# File 'date_core.c', line 6348 static VALUE d_lite_equal(VALUE self, VALUE other) { if (!k_date_p(other)) return equal_gen(self, other); { get_d2(self, other); if (!(m_gregorian_p(adat) == m_gregorian_p(bdat))) return equal_gen(self, other); { VALUE a_nth, b_nth; int a_jd, b_jd; m_canonicalize_jd(adat); m_canonicalize_jd(bdat); a_nth = m_nth(adat); b_nth = m_nth(bdat); a_jd = m_local_jd(adat); b_jd = m_local_jd(bdat); if (f_eqeq_p(a_nth, b_nth) && a_jd == b_jd) return Qtrue; return Qfalse; } } } |
#>>(n) ⇒ Object
Returns a date object pointing n months after self. The n should be a numeric value.
Date.new(2001,2,3) >> 1 #=> #<Date: 2001-03-03 ...>
Date.new(2001,1,31) >> 1 #=> #<Date: 2001-02-28 ...>
Date.new(2001,2,3) >> -2 #=> #<Date: 2000-12-03 ...>
5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980 5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 |
# File 'date_core.c', line 5968 static VALUE d_lite_rshift(VALUE self, VALUE other) { VALUE t, y, nth, rjd2; int m, d, rjd; double sg; get_d1(self); t = f_add3(f_mul(m_real_year(dat), INT2FIX(12)), INT2FIX(m_mon(dat) - 1), other); if (FIXNUM_P(t)) { long it = FIX2LONG(t); y = LONG2NUM(DIV(it, 12)); it = MOD(it, 12); m = (int)it + 1; } else { y = f_idiv(t, INT2FIX(12)); t = f_mod(t, INT2FIX(12)); m = FIX2INT(t) + 1; } d = m_mday(dat); sg = m_sg(dat); while (1) { int ry, rm, rd, ns; if (valid_civil_p(y, m, d, sg, &nth, &ry, &rm, &rd, &rjd, &ns)) break; if (--d < 1) rb_raise(rb_eArgError, "invalid date"); } encode_jd(nth, rjd, &rjd2); return d_lite_plus(self, f_sub(rjd2, m_real_local_jd(dat))); } |
#ajd ⇒ Object
Returns the astronomical Julian day number. This is a fractional number, which is not adjusted by the offset.
DateTime.new(2001,2,3,4,5,6,'+7').ajd #=> (11769328217/4800)
DateTime.new(2001,2,2,14,5,6,'-7').ajd #=> (11769328217/4800)
4809 4810 4811 4812 4813 4814 |
# File 'date_core.c', line 4809 static VALUE d_lite_ajd(VALUE self) { get_d1(self); return m_ajd(dat); } |
#amjd ⇒ Object
Returns the astronomical modified Julian day number. This is a fractional number, which is not adjusted by the offset.
DateTime.new(2001,2,3,4,5,6,'+7').amjd #=> (249325817/4800)
DateTime.new(2001,2,2,14,5,6,'-7').amjd #=> (249325817/4800)
4826 4827 4828 4829 4830 4831 |
# File 'date_core.c', line 4826 static VALUE d_lite_amjd(VALUE self) { get_d1(self); return m_amjd(dat); } |
#asctime ⇒ String #ctime ⇒ String
Returns a string in asctime(3) format (but without “n0” at the end). This method is equivalent to strftime(‘%c’).
See also asctime(3) or ctime(3).
6913 6914 6915 6916 6917 |
# File 'date_core.c', line 6913 static VALUE d_lite_asctime(VALUE self) { return strftimev("%a %b %e %H:%M:%S %Y", self, set_tmx); } |
#asctime ⇒ String #ctime ⇒ String
Returns a string in asctime(3) format (but without “n0” at the end). This method is equivalent to strftime(‘%c’).
See also asctime(3) or ctime(3).
6913 6914 6915 6916 6917 |
# File 'date_core.c', line 6913 static VALUE d_lite_asctime(VALUE self) { return strftimev("%a %b %e %H:%M:%S %Y", self, set_tmx); } |
#cwday ⇒ Fixnum
Returns the day of calendar week (1-7, Monday is 1).
Date.new(2001,2,3).cwday #=> 6
5002 5003 5004 5005 5006 5007 |
# File 'date_core.c', line 5002 static VALUE d_lite_cwday(VALUE self) { get_d1(self); return INT2FIX(m_cwday(dat)); } |
#cweek ⇒ Fixnum
Returns the calendar week number (1-53).
Date.new(2001,2,3).cweek #=> 5
4987 4988 4989 4990 4991 4992 |
# File 'date_core.c', line 4987 static VALUE d_lite_cweek(VALUE self) { get_d1(self); return INT2FIX(m_cweek(dat)); } |
#cwyear ⇒ Integer
Returns the calendar week based year.
Date.new(2001,2,3).cwyear #=> 2001
Date.new(2000,1,1).cwyear #=> 1999
4972 4973 4974 4975 4976 4977 |
# File 'date_core.c', line 4972 static VALUE d_lite_cwyear(VALUE self) { get_d1(self); return m_real_cwyear(dat); } |
#mday ⇒ Fixnum #day ⇒ Fixnum
Returns the day of the month (1-31).
Date.new(2001,2,3).mday #=> 3
4939 4940 4941 4942 4943 4944 |
# File 'date_core.c', line 4939 static VALUE d_lite_mday(VALUE self) { get_d1(self); return INT2FIX(m_mday(dat)); } |
#day_fraction ⇒ Object
Returns the fractional part of the day.
DateTime.new(2001,2,3,12).day_fraction #=> (1/2)
4954 4955 4956 4957 4958 4959 4960 4961 |
# File 'date_core.c', line 4954 static VALUE d_lite_day_fraction(VALUE self) { get_d1(self); if (simple_dat_p(dat)) return INT2FIX(0); return m_fr(dat); } |
#downto(min) ⇒ Object #downto(min) {|date| ... } ⇒ self
This method is equivalent to step(min, -1){|date| …}.
6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 |
# File 'date_core.c', line 6175 static VALUE d_lite_downto(VALUE self, VALUE min) { VALUE date; RETURN_ENUMERATOR(self, 1, &min); date = self; while (FIX2INT(d_lite_cmp(date, min)) >= 0) { rb_yield(date); date = d_lite_plus(date, INT2FIX(-1)); } return self; } |
#england ⇒ Object
This method is equivalent to new_start(Date::ENGLAND).
5412 5413 5414 5415 5416 |
# File 'date_core.c', line 5412 static VALUE d_lite_england(VALUE self) { return dup_obj_with_new_start(self, ENGLAND); } |
#eql? ⇒ Boolean
:nodoc:
6379 6380 6381 6382 6383 6384 6385 |
# File 'date_core.c', line 6379 static VALUE d_lite_eql_p(VALUE self, VALUE other) { if (!k_date_p(other)) return Qfalse; return f_zero_p(d_lite_cmp(self, other)); } |
#friday? ⇒ Boolean
Returns true if the date is Friday.
5111 5112 5113 5114 5115 5116 |
# File 'date_core.c', line 5111 static VALUE d_lite_friday_p(VALUE self) { get_d1(self); return f_boolcast(m_wday(dat) == 5); } |
#gregorian ⇒ Object
This method is equivalent to new_start(Date::GREGORIAN).
5436 5437 5438 5439 5440 |
# File 'date_core.c', line 5436 static VALUE d_lite_gregorian(VALUE self) { return dup_obj_with_new_start(self, GREGORIAN); } |
#gregorian? ⇒ Boolean
Retunrs true if the date is on or after the day of calendar reform.
Date.new(1582,10,15).gregorian? #=> true
(Date.new(1582,10,15) - 1).gregorian? #=> false
5269 5270 5271 5272 5273 5274 |
# File 'date_core.c', line 5269 static VALUE d_lite_gregorian_p(VALUE self) { get_d1(self); return f_boolcast(m_gregorian_p(dat)); } |
#hash ⇒ Object
:nodoc:
6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 |
# File 'date_core.c', line 6388 static VALUE d_lite_hash(VALUE self) { st_index_t v, h[4]; get_d1(self); h[0] = m_nth(dat); h[1] = m_jd(dat); h[2] = m_df(dat); h[3] = m_sf(dat); v = rb_memhash(h, sizeof(h)); return LONG2FIX(v); } |
#httpdate ⇒ String
This method is equivalent to strftime(‘%a, %d %b %Y %T GMT’). See also RFC 2616.
6964 6965 6966 6967 6968 6969 |
# File 'date_core.c', line 6964 static VALUE d_lite_httpdate(VALUE self) { volatile VALUE dup = dup_obj_with_new_offset(self, 0); return strftimev("%a, %d %b %Y %T GMT", dup, set_tmx); } |
#initialize_copy ⇒ Object
:nodoc:
4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 |
# File 'date_core.c', line 4753 static VALUE d_lite_initialize_copy(VALUE copy, VALUE date) { rb_check_frozen(copy); rb_check_trusted(copy); if (copy == date) return copy; { get_d2(copy, date); if (simple_dat_p(bdat)) { adat->s = bdat->s; adat->s.flags &= ~COMPLEX_DAT; } else { if (!complex_dat_p(adat)) rb_raise(rb_eArgError, "cannot load complex into simple"); adat->c = bdat->c; adat->c.flags |= COMPLEX_DAT; } } return copy; } |
#inspect ⇒ String
Returns the value as a string for inspection.
Date.new(2001,2,3).inspect
#=> “#<Date: 2001-02-03 ((2451944j,0s,0n),+0s,2299161j)>”
DateTime.new(2001,2,3,4,5,6,'-7').inspect
#=> “#<DateTime: 2001-02-03T04:05:06-07:00 ((2451944j,39906s,0n),-25200s,2299161j)>”
6521 6522 6523 6524 6525 6526 6527 6528 6529 6530 6531 |
# File 'date_core.c', line 6521 static VALUE d_lite_inspect(VALUE self) { get_d1(self); { VALUE to_s; RB_GC_GUARD(to_s) = f_to_s(self); return mk_inspect(dat, rb_obj_classname(self), RSTRING_PTR(to_s)); } } |
#iso8601 ⇒ String #xmlschema ⇒ String
This method is equivalent to strftime(‘%F’).
6926 6927 6928 6929 6930 |
# File 'date_core.c', line 6926 static VALUE d_lite_iso8601(VALUE self) { return strftimev("%Y-%m-%d", self, set_tmx); } |
#italy ⇒ Object
This method is equivalent to new_start(Date::ITALY).
5400 5401 5402 5403 5404 |
# File 'date_core.c', line 5400 static VALUE d_lite_italy(VALUE self) { return dup_obj_with_new_start(self, ITALY); } |
#jd ⇒ Integer
Returns the Julian day number. This is a whole number, which is adjusted by the offset as the local time.
DateTime.new(2001,2,3,4,5,6,'+7').jd #=> 2451944
DateTime.new(2001,2,3,4,5,6,'-7').jd #=> 2451944
4843 4844 4845 4846 4847 4848 |
# File 'date_core.c', line 4843 static VALUE d_lite_jd(VALUE self) { get_d1(self); return m_real_local_jd(dat); } |
#jisx0301 ⇒ String
Returns a string in a JIS X 0301 format.
Date.new(2001,2,3).jisx0301 #=> "H13.02.03"
7005 7006 7007 7008 7009 7010 7011 7012 7013 7014 |
# File 'date_core.c', line 7005 static VALUE d_lite_jisx0301(VALUE self) { VALUE s; get_d1(self); s = jisx0301_date(m_real_local_jd(dat), m_real_year(dat)); return strftimev(RSTRING_PTR(s), self, set_tmx); } |
#julian ⇒ Object
This method is equivalent to new_start(Date::JULIAN).
5424 5425 5426 5427 5428 |
# File 'date_core.c', line 5424 static VALUE d_lite_julian(VALUE self) { return dup_obj_with_new_start(self, JULIAN); } |
#julian? ⇒ Boolean
Retruns true if the date is before the day of calendar reform.
Date.new(1582,10,15).julian? #=> false
(Date.new(1582,10,15) - 1).julian? #=> true
5253 5254 5255 5256 5257 5258 |
# File 'date_core.c', line 5253 static VALUE d_lite_julian_p(VALUE self) { get_d1(self); return f_boolcast(m_julian_p(dat)); } |
#ld ⇒ Integer
Returns the Lilian day number. This is a whole number, which is adjusted by the offset as the local time.
Date.new(2001,2,3).ld #=> 152784
4876 4877 4878 4879 4880 4881 |
# File 'date_core.c', line 4876 static VALUE d_lite_ld(VALUE self) { get_d1(self); return f_sub(m_real_local_jd(dat), INT2FIX(2299160)); } |
#leap? ⇒ Boolean
Returns true if the year is a leap year.
Date.new(2000).leap? #=> true
Date.new(2001).leap? #=> false
5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 |
# File 'date_core.c', line 5285 static VALUE d_lite_leap_p(VALUE self) { int rjd, ns, ry, rm, rd; get_d1(self); if (m_gregorian_p(dat)) return f_boolcast(c_gregorian_leap_p(m_year(dat))); c_civil_to_jd(m_year(dat), 3, 1, m_virtual_sg(dat), &rjd, &ns); c_jd_to_civil(rjd - 1, m_virtual_sg(dat), &ry, &rm, &rd); return f_boolcast(rd == 29); } |
#marshal_dump ⇒ Object
:nodoc:
7039 7040 7041 7042 7043 7044 7045 7046 7047 7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 |
# File 'date_core.c', line 7039 static VALUE d_lite_marshal_dump(VALUE self) { VALUE a; get_d1(self); a = rb_ary_new3(6, m_nth(dat), INT2FIX(m_jd(dat)), INT2FIX(m_df(dat)), m_sf(dat), INT2FIX(m_of(dat)), DBL2NUM(m_sg(dat))); if (FL_TEST(self, FL_EXIVAR)) { rb_copy_generic_ivar(a, self); FL_SET(a, FL_EXIVAR); } return a; } |
#marshal_load ⇒ Object
:nodoc:
7063 7064 7065 7066 7067 7068 7069 7070 7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090 7091 7092 7093 7094 7095 7096 7097 7098 7099 7100 7101 7102 7103 7104 7105 7106 7107 7108 7109 7110 7111 7112 7113 7114 7115 7116 7117 7118 7119 7120 7121 7122 7123 7124 7125 7126 7127 7128 7129 7130 7131 7132 7133 7134 7135 7136 7137 7138 7139 7140 7141 7142 7143 7144 7145 7146 7147 7148 |
# File 'date_core.c', line 7063 static VALUE d_lite_marshal_load(VALUE self, VALUE a) { get_d1(self); rb_check_frozen(self); rb_check_trusted(self); if (TYPE(a) != T_ARRAY) rb_raise(rb_eTypeError, "expected an array"); switch (RARRAY_LEN(a)) { case 2: /* 1.6.x */ case 3: /* 1.8.x, 1.9.2 */ { VALUE ajd, of, sg, nth, sf; int jd, df, rof; double rsg; if (RARRAY_LEN(a) == 2) { ajd = f_sub(RARRAY_PTR(a)[0], half_days_in_day); of = INT2FIX(0); sg = RARRAY_PTR(a)[1]; if (!k_numeric_p(sg)) sg = DBL2NUM(RTEST(sg) ? GREGORIAN : JULIAN); } else { ajd = RARRAY_PTR(a)[0]; of = RARRAY_PTR(a)[1]; sg = RARRAY_PTR(a)[2]; } old_to_new(ajd, of, sg, &nth, &jd, &df, &sf, &rof, &rsg); if (!df && f_zero_p(sf) && !rof) { set_to_simple(&dat->s, nth, jd, rsg, 0, 0, 0, HAVE_JD); } else { if (!complex_dat_p(dat)) rb_raise(rb_eArgError, "cannot load complex into simple"); set_to_complex(&dat->c, nth, jd, df, sf, rof, rsg, 0, 0, 0, 0, 0, 0, HAVE_JD | HAVE_DF | COMPLEX_DAT); } } break; case 6: { VALUE nth, sf; int jd, df, of; double sg; nth = RARRAY_PTR(a)[0]; jd = NUM2INT(RARRAY_PTR(a)[1]); df = NUM2INT(RARRAY_PTR(a)[2]); sf = RARRAY_PTR(a)[3]; of = NUM2INT(RARRAY_PTR(a)[4]); sg = NUM2DBL(RARRAY_PTR(a)[5]); if (!df && f_zero_p(sf) && !of) { set_to_simple(&dat->s, nth, jd, sg, 0, 0, 0, HAVE_JD); } else { if (!complex_dat_p(dat)) rb_raise(rb_eArgError, "cannot load complex into simple"); set_to_complex(&dat->c, nth, jd, df, sf, of, sg, 0, 0, 0, 0, 0, 0, HAVE_JD | HAVE_DF | COMPLEX_DAT); } } break; default: rb_raise(rb_eTypeError, "invalid size"); break; } if (FL_TEST(a, FL_EXIVAR)) { rb_copy_generic_ivar(self, a); FL_SET(self, FL_EXIVAR); } return self; } |
#mday ⇒ Fixnum #day ⇒ Fixnum
Returns the day of the month (1-31).
Date.new(2001,2,3).mday #=> 3
4939 4940 4941 4942 4943 4944 |
# File 'date_core.c', line 4939 static VALUE d_lite_mday(VALUE self) { get_d1(self); return INT2FIX(m_mday(dat)); } |
#mjd ⇒ Integer
Returns the modified Julian day number. This is a whole number, which is adjusted by the offset as the local time.
DateTime.new(2001,2,3,4,5,6,'+7').mjd #=> 51943
DateTime.new(2001,2,3,4,5,6,'-7').mjd #=> 51943
4860 4861 4862 4863 4864 4865 |
# File 'date_core.c', line 4860 static VALUE d_lite_mjd(VALUE self) { get_d1(self); return f_sub(m_real_local_jd(dat), INT2FIX(2400001)); } |
#mon ⇒ Fixnum #month ⇒ Fixnum
Returns the month (1-12).
Date.new(2001,2,3).mon #=> 2
4923 4924 4925 4926 4927 4928 |
# File 'date_core.c', line 4923 static VALUE d_lite_mon(VALUE self) { get_d1(self); return INT2FIX(m_mon(dat)); } |
#monday? ⇒ Boolean
Returns true if the date is Monday.
5059 5060 5061 5062 5063 5064 |
# File 'date_core.c', line 5059 static VALUE d_lite_monday_p(VALUE self) { get_d1(self); return f_boolcast(m_wday(dat) == 1); } |
#mon ⇒ Fixnum #month ⇒ Fixnum
Returns the month (1-12).
Date.new(2001,2,3).mon #=> 2
4923 4924 4925 4926 4927 4928 |
# File 'date_core.c', line 4923 static VALUE d_lite_mon(VALUE self) { get_d1(self); return INT2FIX(m_mon(dat)); } |
#new_start([start = Date::ITALY]) ⇒ Object
Duplicates self and resets its the day of calendar reform.
d = Date.new(1582,10,15)
d.new_start(Date::JULIAN) #=> #<Date: 1582-10-05 ...>
5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 |
# File 'date_core.c', line 5379 static VALUE d_lite_new_start(int argc, VALUE *argv, VALUE self) { VALUE vsg; double sg; rb_scan_args(argc, argv, "01", &vsg); sg = DEFAULT_SG; if (argc >= 1) val2sg(vsg, sg); return dup_obj_with_new_start(self, sg); } |
#succ ⇒ Object #next ⇒ Object
Returns a date object denoting the following day.
5951 5952 5953 5954 5955 |
# File 'date_core.c', line 5951 static VALUE d_lite_next(VALUE self) { return d_lite_next_day(0, (VALUE *)NULL, self); } |
#next_day([n = 1]) ⇒ Object
This method is equivalent to d + n.
5916 5917 5918 5919 5920 5921 5922 5923 5924 5925 |
# File 'date_core.c', line 5916 static VALUE d_lite_next_day(int argc, VALUE *argv, VALUE self) { VALUE n; rb_scan_args(argc, argv, "01", &n); if (argc < 1) n = INT2FIX(1); return d_lite_plus(self, n); } |
#next_month([n = 1]) ⇒ Object
This method is equivalent to d >> n
6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 |
# File 'date_core.c', line 6030 static VALUE d_lite_next_month(int argc, VALUE *argv, VALUE self) { VALUE n; rb_scan_args(argc, argv, "01", &n); if (argc < 1) n = INT2FIX(1); return d_lite_rshift(self, n); } |
#next_year([n = 1]) ⇒ Object
This method is equivalent to d >> (n * 12)
6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 |
# File 'date_core.c', line 6064 static VALUE d_lite_next_year(int argc, VALUE *argv, VALUE self) { VALUE n; rb_scan_args(argc, argv, "01", &n); if (argc < 1) n = INT2FIX(1); return d_lite_rshift(self, f_mul(n, INT2FIX(12))); } |
#prev_day([n = 1]) ⇒ Object
This method is equivalent to d - n.
5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 |
# File 'date_core.c', line 5933 static VALUE d_lite_prev_day(int argc, VALUE *argv, VALUE self) { VALUE n; rb_scan_args(argc, argv, "01", &n); if (argc < 1) n = INT2FIX(1); return d_lite_minus(self, n); } |
#prev_month([n = 1]) ⇒ Object
This method is equivalent to d << n
6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 |
# File 'date_core.c', line 6047 static VALUE d_lite_prev_month(int argc, VALUE *argv, VALUE self) { VALUE n; rb_scan_args(argc, argv, "01", &n); if (argc < 1) n = INT2FIX(1); return d_lite_lshift(self, n); } |
#prev_year([n = 1]) ⇒ Object
This method is equivalent to d << (n * 12)
6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 |
# File 'date_core.c', line 6081 static VALUE d_lite_prev_year(int argc, VALUE *argv, VALUE self) { VALUE n; rb_scan_args(argc, argv, "01", &n); if (argc < 1) n = INT2FIX(1); return d_lite_lshift(self, f_mul(n, INT2FIX(12))); } |
#rfc2822 ⇒ String #rfc822 ⇒ String
This method is equivalent to strftime(‘%a, %-d %b %Y %T %z’).
6951 6952 6953 6954 6955 |
# File 'date_core.c', line 6951 static VALUE d_lite_rfc2822(VALUE self) { return strftimev("%a, %-d %b %Y %T %z", self, set_tmx); } |
#rfc3339 ⇒ String
This method is equivalent to strftime(‘%FT%T%:z’).
6938 6939 6940 6941 6942 |
# File 'date_core.c', line 6938 static VALUE d_lite_rfc3339(VALUE self) { return strftimev("%Y-%m-%dT%H:%M:%S%:z", self, set_tmx); } |
#rfc2822 ⇒ String #rfc822 ⇒ String
This method is equivalent to strftime(‘%a, %-d %b %Y %T %z’).
6951 6952 6953 6954 6955 |
# File 'date_core.c', line 6951 static VALUE d_lite_rfc2822(VALUE self) { return strftimev("%a, %-d %b %Y %T %z", self, set_tmx); } |
#saturday? ⇒ Boolean
Returns true if the date is Saturday.
5124 5125 5126 5127 5128 5129 |
# File 'date_core.c', line 5124 static VALUE d_lite_saturday_p(VALUE self) { get_d1(self); return f_boolcast(m_wday(dat) == 6); } |
#start ⇒ Float
Returns the Julian day number denoting the day of calendar reform.
Date.new(2001,2,3).start #=> 2299161.0
Date.new(2001,2,3,Date::GREGORIAN).start #=> -Infinity
5309 5310 5311 5312 5313 5314 |
# File 'date_core.c', line 5309 static VALUE d_lite_start(VALUE self) { get_d1(self); return DBL2NUM(m_sg(dat)); } |
#step(limit[, step = 1]) ⇒ Object #step(limit[, step = 1]) {|date| ... } ⇒ self
Iterates evaluation of the given block, which takes a date object. The limit should be a date object.
Date.new(2001).step(Date.new(2001,-1,-1)).select{|d| d.sunday?}.size
#=> 52
6105 6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 |
# File 'date_core.c', line 6105 static VALUE d_lite_step(int argc, VALUE *argv, VALUE self) { VALUE limit, step, date; rb_scan_args(argc, argv, "11", &limit, &step); if (argc < 2) step = INT2FIX(1); #if 0 if (f_zero_p(step)) rb_raise(rb_eArgError, "step can't be 0"); #endif RETURN_ENUMERATOR(self, argc, argv); date = self; switch (FIX2INT(f_cmp(step, INT2FIX(0)))) { case -1: while (FIX2INT(d_lite_cmp(date, limit)) >= 0) { rb_yield(date); date = d_lite_plus(date, step); } break; case 0: while (1) rb_yield(date); break; case 1: while (FIX2INT(d_lite_cmp(date, limit)) <= 0) { rb_yield(date); date = d_lite_plus(date, step); } break; default: abort(); } return self; } |
#strftime([format = '%F']) ⇒ String
Formats date according to the directives in the given format
string.
The directives begins with a percent (%) character.
Any text not listed as a directive will be passed through to the
output string.
The directive consists of a percent (%) character,
zero or more flags, optional minimum field width,
optional modifier and a conversion specifier
as follows.
%<flags><width><modifier><conversion>
Flags:
- don't pad a numerical output.
_ use spaces for padding.
0 use zeros for padding.
^ upcase the result string.
# change case.
The minimum field width specifies the minimum width.
The modifiers are "E", "O", ":", "::" and ":::".
"E" and "O" are ignored. No effect to result currently.
Format directives:
Date (Year, Month, Day):
%Y - Year with century (can be negative, 4 digits at least)
-0001, 0000, 1995, 2009, 14292, etc.
%C - year / 100 (round down. 20 in 2009)
%y - year % 100 (00..99)
%m - Month of the year, zero-padded (01..12)
%_m blank-padded ( 1..12)
%-m no-padded (1..12)
%B - The full month name (``January'')
%^B uppercased (``JANUARY'')
%b - The abbreviated month name (``Jan'')
%^b uppercased (``JAN'')
%h - Equivalent to %b
%d - Day of the month, zero-padded (01..31)
%-d no-padded (1..31)
%e - Day of the month, blank-padded ( 1..31)
%j - Day of the year (001..366)
Time (Hour, Minute, Second, Subsecond):
%H - Hour of the day, 24-hour clock, zero-padded (00..23)
%k - Hour of the day, 24-hour clock, blank-padded ( 0..23)
%I - Hour of the day, 12-hour clock, zero-padded (01..12)
%l - Hour of the day, 12-hour clock, blank-padded ( 1..12)
%P - Meridian indicator, lowercase (``am'' or ``pm'')
%p - Meridian indicator, uppercase (``AM'' or ``PM'')
%M - Minute of the hour (00..59)
%S - Second of the minute (00..59)
%L - Millisecond of the second (000..999)
%N - Fractional seconds digits, default is 9 digits (nanosecond)
%3N millisecond (3 digits) %15N femtosecond (15 digits)
%6N microsecond (6 digits) %18N attosecond (18 digits)
%9N nanosecond (9 digits) %21N zeptosecond (21 digits)
%12N picosecond (12 digits) %24N yoctosecond (24 digits)
Time zone:
%z - Time zone as hour and minute offset from UTC (e.g. +0900)
%:z - hour and minute offset from UTC with a colon (e.g. +09:00)
%::z - hour, minute and second offset from UTC (e.g. +09:00:00)
%:::z - hour, minute and second offset from UTC
(e.g. +09, +09:30, +09:30:30)
%Z - Time zone abbreviation name or something similar information.
Weekday:
%A - The full weekday name (``Sunday'')
%^A uppercased (``SUNDAY'')
%a - The abbreviated name (``Sun'')
%^a uppercased (``SUN'')
%u - Day of the week (Monday is 1, 1..7)
%w - Day of the week (Sunday is 0, 0..6)
ISO 8601 week-based year and week number:
The week 1 of YYYY starts with a Monday and includes YYYY-01-04.
The days in the year before the first week are in the last week of
the previous year.
%G - The week-based year
%g - The last 2 digits of the week-based year (00..99)
%V - Week number of the week-based year (01..53)
Week number:
The week 1 of YYYY starts with a Sunday or Monday (according to %U
or %W). The days in the year before the first week are in week 0.
%U - Week number of the year. The week starts with Sunday. (00..53)
%W - Week number of the year. The week starts with Monday. (00..53)
Seconds since the Unix Epoch:
%s - Number of seconds since 1970-01-01 00:00:00 UTC.
%Q - Number of milliseconds since 1970-01-01 00:00:00 UTC.
Literal string:
%n - Newline character (\n)
%t - Tab character (\t)
%% - Literal ``%'' character
Combination:
%c - date and time (%a %b %e %T %Y)
%D - Date (%m/%d/%y)
%F - The ISO 8601 date format (%Y-%m-%d)
%v - VMS date (%e-%b-%Y)
%x - Same as %D
%X - Same as %T
%r - 12-hour time (%I:%M:%S %p)
%R - 24-hour time (%H:%M)
%T - 24-hour time (%H:%M:%S)
%+ - date(1) (%a %b %e %H:%M:%S %Z %Y)
This method is similar to strftime() function defined in ISO C and POSIX.
Several directives (%a, %A, %b, %B, %c, %p, %r, %x, %X, %E*, %O* and %Z)
are locale dependent in the function.
However this method is locale independent.
So, the result may differ even if a same format string is used in other
systems such as C.
It is good practice to avoid %x and %X because there are corresponding
locale independent representations, %D and %T.
Examples:
d = DateTime.new(2007,11,19,8,37,48,"-06:00")
#=> #<DateTime: 2007-11-19T08:37:48-0600 …>
d.strftime("Printed on %m/%d/%Y") #=> "Printed on 11/19/2007"
d.strftime("at %I:%M%p") #=> "at 08:37AM"
Various ISO 8601 formats:
Y%m%d => 20071119 Calendar date (basic)
F => 2007-11-19 Calendar date (extended)
Y-m => 2007-11 Calendar date, reduced accuracy, specific month
Y => 2007 Calendar date, reduced accuracy, specific year
C => 20 Calendar date, reduced accuracy, specific century
Y%j => 2007323 Ordinal date (basic)
Y-j => 2007-323 Ordinal date (extended)
GW%V%u => 2007W471 Week date (basic)
G-W%V-u => 2007-W47-1 Week date (extended)
GW%V => 2007W47 Week date, reduced accuracy, specific week (basic)
G-W%V => 2007-W47 Week date, reduced accuracy, specific week (extended)
H%M%S => 083748 Local time (basic)
T => 08:37:48 Local time (extended)
H%M => 0837 Local time, reduced accuracy, specific minute (basic)
H:%M => 08:37 Local time, reduced accuracy, specific minute (extended)
H => 08 Local time, reduced accuracy, specific hour
H%M%S,L => 083748,000 Local time with decimal fraction, comma as decimal sign (basic)
T,L => 08:37:48,000 Local time with decimal fraction, comma as decimal sign (extended)
H%M%S.%L => 083748.000 Local time with decimal fraction, full stop as decimal sign (basic)
T.%L => 08:37:48.000 Local time with decimal fraction, full stop as decimal sign (extended)
H%M%S%z => 083748-0600 Local time and the difference from UTC (basic)
T%:z => 08:37:48-06:00 Local time and the difference from UTC (extended)
Y%m%dT%H%M%S%z => 20071119T083748-0600 Date and time of day for calendar date (basic)
FT%T%:z => 2007-11-19T08:37:48-06:00 Date and time of day for calendar date (extended)
Y%jT%H%M%S%z => 2007323T083748-0600 Date and time of day for ordinal date (basic)
Y-jT%T%:z => 2007-323T08:37:48-06:00 Date and time of day for ordinal date (extended)
GW%V%uT%H%M%S%z => 2007W471T083748-0600 Date and time of day for week date (basic)
G-W%V-uT%T%:z => 2007-W47-1T08:37:48-06:00 Date and time of day for week date (extended)
Y%m%dT%H%M => 20071119T0837 Calendar date and local time (basic)
FT%R => 2007-11-19T08:37 Calendar date and local time (extended)
Y%jT%H%MZ => 2007323T0837Z Ordinal date and UTC of day (basic)
Y-jT%RZ => 2007-323T08:37Z Ordinal date and UTC of day (extended)
GW%V%uT%H%M%z => 2007W471T0837-0600 Week date and local time and difference from UTC (basic)
G-W%V-uT%R%:z => 2007-W47-1T08:37-06:00 Week date and local time and difference from UTC (extended)
See also strftime(3) and strptime.
6880 6881 6882 6883 6884 6885 |
# File 'date_core.c', line 6880 static VALUE d_lite_strftime(int argc, VALUE *argv, VALUE self) { return date_strftime_internal(argc, argv, self, "%Y-%m-%d", set_tmx); } |
#succ ⇒ Object #next ⇒ Object
Returns a date object denoting the following day.
5951 5952 5953 5954 5955 |
# File 'date_core.c', line 5951 static VALUE d_lite_next(VALUE self) { return d_lite_next_day(0, (VALUE *)NULL, self); } |
#sunday? ⇒ Boolean
Returns true if the date is Sunday.
5046 5047 5048 5049 5050 5051 |
# File 'date_core.c', line 5046 static VALUE d_lite_sunday_p(VALUE self) { get_d1(self); return f_boolcast(m_wday(dat) == 0); } |
#thursday? ⇒ Boolean
Returns true if the date is Thursday.
5098 5099 5100 5101 5102 5103 |
# File 'date_core.c', line 5098 static VALUE d_lite_thursday_p(VALUE self) { get_d1(self); return f_boolcast(m_wday(dat) == 4); } |
#to_date ⇒ self
Returns self;
8526 8527 8528 8529 8530 |
# File 'date_core.c', line 8526 static VALUE date_to_date(VALUE self) { return self; } |
#to_datetime ⇒ Object
Returns a DateTime object which denotes self.
8538 8539 8540 8541 8542 8543 8544 8545 8546 8547 8548 8549 8550 8551 8552 8553 8554 8555 8556 8557 8558 8559 8560 8561 8562 8563 8564 8565 8566 8567 8568 8569 8570 |
# File 'date_core.c', line 8538 static VALUE date_to_datetime(VALUE self) { get_d1a(self); if (simple_dat_p(adat)) { VALUE new = d_lite_s_alloc_simple(cDateTime); { get_d1b(new); bdat->s = adat->s; return new; } } else { VALUE new = d_lite_s_alloc_complex(cDateTime); { get_d1b(new); bdat->c = adat->c; bdat->c.df = 0; bdat->c.sf = INT2FIX(0); #ifndef USE_PACK bdat->c.hour = 0; bdat->c.min = 0; bdat->c.sec = 0; #else bdat->c.pc = PACK5(EX_MON(adat->c.pc), EX_MDAY(adat->c.pc), 0, 0, 0); bdat->c.flags |= HAVE_DF | HAVE_TIME; #endif return new; } } } |
#to_s ⇒ String
Returns a string in an ISO 8601 format (This method doesn’t use the expanded representations).
Date.new(2001,2,3).to_s #=> "2001-02-03"
6416 6417 6418 6419 6420 |
# File 'date_core.c', line 6416 static VALUE d_lite_to_s(VALUE self) { return strftimev("%Y-%m-%d", self, set_tmx); } |
#to_time ⇒ Time
Returns a Time object which denotes self.
8509 8510 8511 8512 8513 8514 8515 8516 8517 8518 |
# File 'date_core.c', line 8509 static VALUE date_to_time(VALUE self) { get_d1(self); return f_local3(rb_cTime, m_real_year(dat), INT2FIX(m_mon(dat)), INT2FIX(m_mday(dat))); } |
#tuesday? ⇒ Boolean
Returns true if the date is Tuesday.
5072 5073 5074 5075 5076 5077 |
# File 'date_core.c', line 5072 static VALUE d_lite_tuesday_p(VALUE self) { get_d1(self); return f_boolcast(m_wday(dat) == 2); } |
#upto(max) ⇒ Object #upto(max) {|date| ... } ⇒ self
This method is equivalent to step(max, 1){|date| …}.
6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 |
# File 'date_core.c', line 6153 static VALUE d_lite_upto(VALUE self, VALUE max) { VALUE date; RETURN_ENUMERATOR(self, 1, &max); date = self; while (FIX2INT(d_lite_cmp(date, max)) <= 0) { rb_yield(date); date = d_lite_plus(date, INT2FIX(1)); } return self; } |
#wday ⇒ Fixnum
Returns the day of week (0-6, Sunday is zero).
Date.new(2001,2,3).wday #=> 6
5033 5034 5035 5036 5037 5038 |
# File 'date_core.c', line 5033 static VALUE d_lite_wday(VALUE self) { get_d1(self); return INT2FIX(m_wday(dat)); } |
#wednesday? ⇒ Boolean
Returns true if the date is Wednesday.
5085 5086 5087 5088 5089 5090 |
# File 'date_core.c', line 5085 static VALUE d_lite_wednesday_p(VALUE self) { get_d1(self); return f_boolcast(m_wday(dat) == 3); } |
#iso8601 ⇒ String #xmlschema ⇒ String
This method is equivalent to strftime(‘%F’).
6926 6927 6928 6929 6930 |
# File 'date_core.c', line 6926 static VALUE d_lite_iso8601(VALUE self) { return strftimev("%Y-%m-%d", self, set_tmx); } |
#yday ⇒ Fixnum
Returns the day of the year (1-366).
Date.new(2001,2,3).yday #=> 34
4907 4908 4909 4910 4911 4912 |
# File 'date_core.c', line 4907 static VALUE d_lite_yday(VALUE self) { get_d1(self); return INT2FIX(m_yday(dat)); } |
#year ⇒ Integer
Returns the year.
Date.new(2001,2,3).year #=> 2001
(Date.new(1,1,1) - 1).year #=> 0
4892 4893 4894 4895 4896 4897 |
# File 'date_core.c', line 4892 static VALUE d_lite_year(VALUE self) { get_d1(self); return m_real_year(dat); } |