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(s) ⇒ Object
:nodoc:.
-
._parse(string[, comp = true]) ⇒ Hash
Parses the given representation of date and time, and returns a hash of parsed elements.
-
._rfc2822(str) ⇒ Object
Returns a hash of parsed elements.
-
._rfc3339(string) ⇒ Hash
Returns a hash of parsed elements.
-
._rfc822(str) ⇒ 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(*args) ⇒ 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?(y) ⇒ 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?(y) ⇒ Boolean
Returns true if the given year is a leap year of the proleptic Gregorian calendar.
-
.new(*args) ⇒ 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(*args) ⇒ 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(*args) ⇒ 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?(*args) ⇒ 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?(*args) ⇒ 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(min) ⇒ Object
This method is equivalent to step(min, -1){|date| …}.
-
#england ⇒ Object
This method is equivalent to new_start(Date::ENGLAND).
-
#eql?(other) ⇒ 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(date) ⇒ 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(a) ⇒ 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(*args) ⇒ 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(max) ⇒ 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.
4565 4566 4567 4568 4569 |
# File 'date_core.c', line 4565
static VALUE
date_s__httpdate(VALUE klass, VALUE str)
{
return date__httpdate(str);
}
|
._iso8601(string) ⇒ Hash
Returns a hash of parsed elements.
4396 4397 4398 4399 4400 |
# File 'date_core.c', line 4396
static VALUE
date_s__iso8601(VALUE klass, VALUE str)
{
return date__iso8601(str);
}
|
._jisx0301(string) ⇒ Hash
Returns a hash of parsed elements.
4607 4608 4609 4610 4611 |
# File 'date_core.c', line 4607
static VALUE
date_s__jisx0301(VALUE klass, VALUE str)
{
return date__jisx0301(str);
}
|
._load(s) ⇒ Object
:nodoc:
7160 7161 7162 7163 7164 7165 7166 7167 7168 |
# File 'date_core.c', line 7160
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}
4336 4337 4338 4339 4340 |
# File 'date_core.c', line 4336
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.
4522 4523 4524 4525 4526 |
# File 'date_core.c', line 4522
static VALUE
date_s__rfc2822(VALUE klass, VALUE str)
{
return date__rfc2822(str);
}
|
._rfc3339(string) ⇒ Hash
Returns a hash of parsed elements.
4439 4440 4441 4442 4443 |
# File 'date_core.c', line 4439
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.
4522 4523 4524 4525 4526 |
# File 'date_core.c', line 4522
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.
4242 4243 4244 4245 4246 |
# File 'date_core.c', line 4242
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.
4480 4481 4482 4483 4484 |
# File 'date_core.c', line 4480
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.
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 3445 |
# File 'date_core.c', line 3386
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.
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 3507 |
# File 'date_core.c', line 3463
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
2924 2925 2926 2927 2928 2929 2930 2931 2932 |
# File 'date_core.c', line 2924
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 …>
4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 |
# File 'date_core.c', line 4581
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
4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 |
# File 'date_core.c', line 4413
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
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 3300 |
# File 'date_core.c', line 3268
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 ...>
4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 |
# File 'date_core.c', line 4622
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
2903 2904 2905 2906 2907 2908 2909 2910 2911 |
# File 'date_core.c', line 2903
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
2924 2925 2926 2927 2928 2929 2930 2931 2932 |
# File 'date_core.c', line 2924
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.
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 3445 |
# File 'date_core.c', line 3386
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.
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 3359 |
# File 'date_core.c', line 3318
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 ...>
4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 |
# File 'date_core.c', line 4357
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 …>
4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 |
# File 'date_core.c', line 4539
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 ...>
4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 |
# File 'date_core.c', line 4454
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
4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 |
# File 'date_core.c', line 4539
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.
4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 |
# File 'date_core.c', line 4266
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.
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 3677 |
# File 'date_core.c', line 3639
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.
2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 |
# File 'date_core.c', line 2557
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
2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 |
# File 'date_core.c', line 2720
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
2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 |
# File 'date_core.c', line 2557
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.
2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 |
# File 'date_core.c', line 2468
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
2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 |
# File 'date_core.c', line 2638
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 ...>
4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 |
# File 'date_core.c', line 4495
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 …>
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 5820 5821 5822 5823 5824 5825 5826 5827 5828 |
# File 'date_core.c', line 5514
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:
expect_numeric(other);
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, rb_rational_num(other));
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)
5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 |
# File 'date_core.c', line 5898
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:
expect_numeric(other);
/* fall through */
case T_BIGNUM:
case T_RATIONAL:
return d_lite_plus(self, f_negate(other));
}
}
|
#<<(n) ⇒ Object
6026 6027 6028 6029 6030 6031 |
# File 'date_core.c', line 6026
static VALUE
d_lite_lshift(VALUE self, VALUE other)
{
expect_numeric(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.
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 6318 6319 6320 6321 6322 6323 6324 6325 6326 |
# File 'date_core.c', line 6284
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(self, adat);
m_canonicalize_jd(other, 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 (f_lt_p(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
6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 6384 6385 |
# File 'date_core.c', line 6357
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(self, adat);
m_canonicalize_jd(other, 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
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 6006 6007 6008 6009 6010 6011 6012 6013 |
# File 'date_core.c', line 5976
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
4819 4820 4821 4822 4823 4824 |
# File 'date_core.c', line 4819
static VALUE
d_lite_ajd(VALUE self)
{
get_d1(self);
return m_ajd(dat);
}
|
#amjd ⇒ Object
4836 4837 4838 4839 4840 4841 |
# File 'date_core.c', line 4836
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).
6922 6923 6924 6925 6926 |
# File 'date_core.c', line 6922
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).
6922 6923 6924 6925 6926 |
# File 'date_core.c', line 6922
static VALUE
d_lite_asctime(VALUE self)
{
return strftimev("%a %b %e %H:%M:%S %Y", self, set_tmx);
}
|
#cwday ⇒ Fixnum
5012 5013 5014 5015 5016 5017 |
# File 'date_core.c', line 5012
static VALUE
d_lite_cwday(VALUE self)
{
get_d1(self);
return INT2FIX(m_cwday(dat));
}
|
#cweek ⇒ Fixnum
4997 4998 4999 5000 5001 5002 |
# File 'date_core.c', line 4997
static VALUE
d_lite_cweek(VALUE self)
{
get_d1(self);
return INT2FIX(m_cweek(dat));
}
|
#cwyear ⇒ Integer
4982 4983 4984 4985 4986 4987 |
# File 'date_core.c', line 4982
static VALUE
d_lite_cwyear(VALUE self)
{
get_d1(self);
return m_real_cwyear(dat);
}
|
#mday ⇒ Fixnum #day ⇒ Fixnum
4949 4950 4951 4952 4953 4954 |
# File 'date_core.c', line 4949
static VALUE
d_lite_mday(VALUE self)
{
get_d1(self);
return INT2FIX(m_mday(dat));
}
|
#day_fraction ⇒ Object
4964 4965 4966 4967 4968 4969 4970 4971 |
# File 'date_core.c', line 4964
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| …}.
6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 |
# File 'date_core.c', line 6184
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).
5422 5423 5424 5425 5426 |
# File 'date_core.c', line 5422
static VALUE
d_lite_england(VALUE self)
{
return dup_obj_with_new_start(self, ENGLAND);
}
|
#eql?(other) ⇒ Boolean
:nodoc:
6388 6389 6390 6391 6392 6393 6394 |
# File 'date_core.c', line 6388
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.
5121 5122 5123 5124 5125 5126 |
# File 'date_core.c', line 5121
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).
5446 5447 5448 5449 5450 |
# File 'date_core.c', line 5446
static VALUE
d_lite_gregorian(VALUE self)
{
return dup_obj_with_new_start(self, GREGORIAN);
}
|
#gregorian? ⇒ Boolean
5279 5280 5281 5282 5283 5284 |
# File 'date_core.c', line 5279
static VALUE
d_lite_gregorian_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_gregorian_p(dat));
}
|
#hash ⇒ Object
:nodoc:
6397 6398 6399 6400 6401 6402 6403 6404 6405 6406 6407 6408 6409 |
# File 'date_core.c', line 6397
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.
6973 6974 6975 6976 6977 6978 |
# File 'date_core.c', line 6973
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(date) ⇒ Object
:nodoc:
4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 |
# File 'date_core.c', line 4763
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
6530 6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 |
# File 'date_core.c', line 6530
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’).
6935 6936 6937 6938 6939 |
# File 'date_core.c', line 6935
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).
5410 5411 5412 5413 5414 |
# File 'date_core.c', line 5410
static VALUE
d_lite_italy(VALUE self)
{
return dup_obj_with_new_start(self, ITALY);
}
|
#jd ⇒ Integer
4853 4854 4855 4856 4857 4858 |
# File 'date_core.c', line 4853
static VALUE
d_lite_jd(VALUE self)
{
get_d1(self);
return m_real_local_jd(dat);
}
|
#jisx0301 ⇒ String
7014 7015 7016 7017 7018 7019 7020 7021 7022 7023 |
# File 'date_core.c', line 7014
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).
5434 5435 5436 5437 5438 |
# File 'date_core.c', line 5434
static VALUE
d_lite_julian(VALUE self)
{
return dup_obj_with_new_start(self, JULIAN);
}
|
#julian? ⇒ Boolean
5263 5264 5265 5266 5267 5268 |
# File 'date_core.c', line 5263
static VALUE
d_lite_julian_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_julian_p(dat));
}
|
#ld ⇒ Integer
4886 4887 4888 4889 4890 4891 |
# File 'date_core.c', line 4886
static VALUE
d_lite_ld(VALUE self)
{
get_d1(self);
return f_sub(m_real_local_jd(dat), INT2FIX(2299160));
}
|
#leap? ⇒ Boolean
5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 |
# File 'date_core.c', line 5295
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:
7048 7049 7050 7051 7052 7053 7054 7055 7056 7057 7058 7059 7060 7061 7062 7063 7064 7065 7066 7067 7068 7069 |
# File 'date_core.c', line 7048
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(a) ⇒ Object
:nodoc:
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 7149 7150 7151 7152 7153 7154 7155 7156 7157 |
# File 'date_core.c', line 7072
static VALUE
d_lite_marshal_load(VALUE self, VALUE a)
{
get_d1(self);
rb_check_frozen(self);
rb_check_trusted(self);
if (!RB_TYPE_P(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_AREF(a, 0), half_days_in_day);
of = INT2FIX(0);
sg = RARRAY_AREF(a, 1);
if (!k_numeric_p(sg))
sg = DBL2NUM(RTEST(sg) ? GREGORIAN : JULIAN);
}
else {
ajd = RARRAY_AREF(a, 0);
of = RARRAY_AREF(a, 1);
sg = RARRAY_AREF(a, 2);
}
old_to_new(ajd, of, sg,
&nth, &jd, &df, &sf, &rof, &rsg);
if (!df && f_zero_p(sf) && !rof) {
set_to_simple(self, &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(self, &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_AREF(a, 0);
jd = NUM2INT(RARRAY_AREF(a, 1));
df = NUM2INT(RARRAY_AREF(a, 2));
sf = RARRAY_AREF(a, 3);
of = NUM2INT(RARRAY_AREF(a, 4));
sg = NUM2DBL(RARRAY_AREF(a, 5));
if (!df && f_zero_p(sf) && !of) {
set_to_simple(self, &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(self, &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
4949 4950 4951 4952 4953 4954 |
# File 'date_core.c', line 4949
static VALUE
d_lite_mday(VALUE self)
{
get_d1(self);
return INT2FIX(m_mday(dat));
}
|
#mjd ⇒ Integer
4870 4871 4872 4873 4874 4875 |
# File 'date_core.c', line 4870
static VALUE
d_lite_mjd(VALUE self)
{
get_d1(self);
return f_sub(m_real_local_jd(dat), INT2FIX(2400001));
}
|
#mon ⇒ Fixnum #month ⇒ Fixnum
4933 4934 4935 4936 4937 4938 |
# File 'date_core.c', line 4933
static VALUE
d_lite_mon(VALUE self)
{
get_d1(self);
return INT2FIX(m_mon(dat));
}
|
#monday? ⇒ Boolean
Returns true if the date is Monday.
5069 5070 5071 5072 5073 5074 |
# File 'date_core.c', line 5069
static VALUE
d_lite_monday_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_wday(dat) == 1);
}
|
#mon ⇒ Fixnum #month ⇒ Fixnum
4933 4934 4935 4936 4937 4938 |
# File 'date_core.c', line 4933
static VALUE
d_lite_mon(VALUE self)
{
get_d1(self);
return INT2FIX(m_mon(dat));
}
|
#new_start([start = Date::ITALY]) ⇒ Object
5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 |
# File 'date_core.c', line 5389
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.
5959 5960 5961 5962 5963 |
# File 'date_core.c', line 5959
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.
5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 |
# File 'date_core.c', line 5924
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
6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 |
# File 'date_core.c', line 6039
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)
6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 |
# File 'date_core.c', line 6073
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.
5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 |
# File 'date_core.c', line 5941
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
6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 |
# File 'date_core.c', line 6056
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)
6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 |
# File 'date_core.c', line 6090
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’).
6960 6961 6962 6963 6964 |
# File 'date_core.c', line 6960
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’).
6947 6948 6949 6950 6951 |
# File 'date_core.c', line 6947
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’).
6960 6961 6962 6963 6964 |
# File 'date_core.c', line 6960
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.
5134 5135 5136 5137 5138 5139 |
# File 'date_core.c', line 5134
static VALUE
d_lite_saturday_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_wday(dat) == 6);
}
|
#start ⇒ Float
5319 5320 5321 5322 5323 5324 |
# File 'date_core.c', line 5319
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
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 6145 6146 6147 6148 6149 6150 6151 6152 6153 |
# File 'date_core.c', line 6114
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.
6889 6890 6891 6892 6893 6894 |
# File 'date_core.c', line 6889
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.
5959 5960 5961 5962 5963 |
# File 'date_core.c', line 5959
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.
5056 5057 5058 5059 5060 5061 |
# File 'date_core.c', line 5056
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.
5108 5109 5110 5111 5112 5113 |
# File 'date_core.c', line 5108
static VALUE
d_lite_thursday_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_wday(dat) == 4);
}
|
#to_date ⇒ self
Returns self;
8535 8536 8537 8538 8539 |
# File 'date_core.c', line 8535
static VALUE
date_to_date(VALUE self)
{
return self;
}
|
#to_datetime ⇒ Object
Returns a DateTime object which denotes self.
8547 8548 8549 8550 8551 8552 8553 8554 8555 8556 8557 8558 8559 8560 8561 8562 8563 8564 8565 8566 8567 8568 8569 8570 8571 8572 8573 8574 8575 8576 8577 8578 8579 |
# File 'date_core.c', line 8547
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;
RB_OBJ_WRITE(new, &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
6425 6426 6427 6428 6429 |
# File 'date_core.c', line 6425
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.
8518 8519 8520 8521 8522 8523 8524 8525 8526 8527 |
# File 'date_core.c', line 8518
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.
5082 5083 5084 5085 5086 5087 |
# File 'date_core.c', line 5082
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| …}.
6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 |
# File 'date_core.c', line 6162
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
5043 5044 5045 5046 5047 5048 |
# File 'date_core.c', line 5043
static VALUE
d_lite_wday(VALUE self)
{
get_d1(self);
return INT2FIX(m_wday(dat));
}
|
#wednesday? ⇒ Boolean
Returns true if the date is Wednesday.
5095 5096 5097 5098 5099 5100 |
# File 'date_core.c', line 5095
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’).
6935 6936 6937 6938 6939 |
# File 'date_core.c', line 6935
static VALUE
d_lite_iso8601(VALUE self)
{
return strftimev("%Y-%m-%d", self, set_tmx);
}
|
#yday ⇒ Fixnum
4917 4918 4919 4920 4921 4922 |
# File 'date_core.c', line 4917
static VALUE
d_lite_yday(VALUE self)
{
get_d1(self);
return INT2FIX(m_yday(dat));
}
|