Class: Date
- Inherits:
-
Object
- Object
- Date
- Includes:
- Comparable
- Defined in:
- lib/date.rb,
ext/date/date_core.c
Direct Known Subclasses
Defined Under Namespace
Constant Summary collapse
- VERSION =
:nodoc:
"3.3.4"
- 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, limit: 128) ⇒ Hash
Returns a hash of values parsed from
string
, which should be a valid HTTP date format:. -
._iso8601(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from
string
, which should contain an ISO 8601 formatted date:. -
._jisx0301(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from
string
, which should be a valid JIS X 0301 date format:. -
._load(s) ⇒ Object
:nodoc:.
-
._parse(string, comp = true, limit: 128) ⇒ Hash
Note: This method recognizes many forms in
string
, but it is not a validator. -
._rfc2822(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from
string
, which should be a valid RFC 2822 date format:. -
._rfc3339(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from
string
, which should be a valid RFC 3339 format:. -
._rfc2822(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from
string
, which should be a valid RFC 2822 date format:. -
._strptime(string, format = '%F') ⇒ Hash
Returns a hash of values parsed from
string
according to the givenformat
:. -
._xmlschema(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from
string
, which should be a valid XML date format:. -
.civil(*args) ⇒ Object
Same as Date.new.
-
.commercial(cwyear = -4712, cweek = 1, cwday = 1, start = Date::ITALY) ⇒ Object
Returns a new Date object constructed from the arguments.
-
.gregorian_leap?(year) ⇒ Boolean
Returns
true
if the given year is a leap year in the proleptic Gregorian calendar,false
otherwise:. -
.httpdate(string = 'Mon, 01 Jan -4712 00:00:00 GMT', start = Date::ITALY, limit: 128) ⇒ Object
Returns a new Date object with values parsed from
string
, which should be a valid HTTP date format:. -
.iso8601(string = '-4712-01-01', start = Date::ITALY, limit: 128) ⇒ Object
Returns a new Date object with values parsed from
string
, which should contain an ISO 8601 formatted date:. -
.jd(jd = 0, start = Date::ITALY) ⇒ Object
Returns a new Date object formed from the arguments:.
-
.jisx0301(string = '-4712-01-01', start = Date::ITALY, limit: 128) ⇒ Object
Returns a new Date object with values parsed from
string
, which should be a valid JIS X 0301 format:. -
.julian_leap?(year) ⇒ Boolean
Returns
true
if the given year is a leap year in the proleptic Julian calendar,false
otherwise:. -
.gregorian_leap?(year) ⇒ Boolean
Returns
true
if the given year is a leap year in the proleptic Gregorian calendar,false
otherwise:. -
.new!(*args) ⇒ Object
:nodoc:.
-
.nth_kday(*args) ⇒ Object
:nodoc:.
-
.ordinal(year = -4712, yday = 1, start = Date::ITALY) ⇒ Object
Returns a new Date object formed fom the arguments.
-
.parse(string = '-4712-01-01', comp = true, start = Date::ITALY, limit: 128) ⇒ Object
Note: This method recognizes many forms in
string
, but it is not a validator. -
.rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000', start = Date::ITALY, limit: 128) ⇒ Object
Returns a new Date object with values parsed from
string
, which should be a valid RFC 2822 date format:. -
.rfc3339(string = '-4712-01-01T00:00:00+00:00', start = Date::ITALY, limit: 128) ⇒ Object
Returns a new Date object with values parsed from
string
, which should be a valid RFC 3339 format:. -
.rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000', start = Date::ITALY, limit: 128) ⇒ Object
Returns a new Date object with values parsed from
string
, which should be a valid RFC 2822 date format:. -
.strptime(string = '-4712-01-01', format = '%F', start = Date::ITALY) ⇒ Object
Returns a new Date object with values parsed from
string
, according to the givenformat
:. -
.test_all ⇒ Object
:nodoc:.
-
.test_civil ⇒ Object
:nodoc:.
-
.test_commercial ⇒ Object
:nodoc:.
-
.test_nth_kday ⇒ Object
:nodoc:.
-
.test_ordinal ⇒ Object
:nodoc:.
-
.test_unit_conv ⇒ Object
:nodoc:.
-
.test_weeknum ⇒ Object
:nodoc:.
-
.today(start = Date::ITALY) ⇒ Object
Returns a new Date object constructed from the present date:.
-
.valid_civil?(year, month, mday, start = Date::ITALY) ⇒ Boolean
Returns
true
if the arguments define a valid ordinal date,false
otherwise:. -
.valid_commercial?(cwyear, cweek, cwday, start = Date::ITALY) ⇒ Boolean
Returns
true
if the arguments define a valid commercial date,false
otherwise:. -
.valid_civil?(year, month, mday, start = Date::ITALY) ⇒ Boolean
Returns
true
if the arguments define a valid ordinal date,false
otherwise:. -
.valid_jd?(jd, start = Date::ITALY) ⇒ true
Implemented for compatibility; returns
true
unlessjd
is invalid (i.e., not a Numeric). -
.valid_ordinal?(year, yday, start = Date::ITALY) ⇒ Boolean
Returns
true
if the arguments define a valid ordinal date,false
otherwise:. -
.weeknum(*args) ⇒ Object
:nodoc:.
-
.xmlschema(string = '-4712-01-01', start = Date::ITALY, limit: 128) ⇒ Object
Returns a new Date object with values parsed from
string
, which should be a valid XML date format:.
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 new Date object representing the date
n
months earlier;n
should be a numeric:. -
#<=>(other) ⇒ -1, ...
Compares
self
andother
, returning:. -
#===(other) ⇒ true, false
Returns
true
ifself
andother
represent the same date,false
if not,nil
if the two are not comparable. -
#>>(n) ⇒ Object
Returns a new Date object representing the date
n
months later;n
should be a numeric:. -
#ajd ⇒ Object
Returns the astronomical Julian day number.
-
#amjd ⇒ Object
Returns the astronomical modified Julian day number.
-
#asctime ⇒ String
Equivalent to #strftime with argument
'%a %b %e %T %Y'
(or its shorthand form'%c'
):. -
#asctime ⇒ String
Equivalent to #strftime with argument
'%a %b %e %T %Y'
(or its shorthand form'%c'
):. -
#cwday ⇒ Integer
Returns the commercial-date weekday index for
self
(see Date.commercial); 1 is Monday:. -
#cweek ⇒ Integer
Returns commercial-date week index for
self
(see Date.commercial):. -
#cwyear ⇒ Integer
Returns commercial-date year for
self
(see Date.commercial):. -
#mday ⇒ Integer
Returns the day of the month in range (1..31):.
-
#day_fraction ⇒ Object
Returns the fractional part of the day in range (Rational(0, 1)…Rational(1, 1)):.
-
#deconstruct_keys(array_of_names_or_nil) ⇒ Hash
Returns a hash of the name/value pairs, to use in pattern matching.
-
#downto(min) {|date| ... } ⇒ self
Equivalent to #step with arguments
min
and-1
. -
#england ⇒ Object
Equivalent to Date#new_start with argument Date::ENGLAND.
-
#eql?(other) ⇒ Boolean
:nodoc:.
-
#fill ⇒ Object
:nodoc:.
-
#friday? ⇒ Boolean
Returns
true
ifself
is a Friday,false
otherwise. -
#gregorian ⇒ Object
Equivalent to Date#new_start with argument Date::GREGORIAN.
-
#gregorian? ⇒ Boolean
Returns
true
if the date is on or after the date of calendar reform,false
otherwise:. -
#hash ⇒ Object
:nodoc:.
-
#httpdate ⇒ String
Equivalent to #strftime with argument
'%a, %d %b %Y %T GMT'
; see Formats for Dates and Times:. -
#infinite? ⇒ Boolean
call-seq: infinite? -> false.
-
#new(year = -4712, month = 1, mday = 1, start = Date::ITALY) ⇒ Object
constructor
Returns a new Date object constructed from the given arguments:.
-
#initialize_copy(date) ⇒ Object
:nodoc:.
-
#inspect ⇒ String
Returns a string representation of
self
:. -
#inspect_raw ⇒ Object
:nodoc:.
-
#iso8601 ⇒ String
Equivalent to #strftime with argument
'%Y-%m-%d'
(or its shorthand form'%F'
);. -
#italy ⇒ Object
Equivalent to Date#new_start with argument Date::ITALY.
-
#jd ⇒ Integer
Returns the Julian day number.
-
#jisx0301 ⇒ String
Returns a string representation of the date in
self
in JIS X 0301 format. -
#julian ⇒ Object
Equivalent to Date#new_start with argument Date::JULIAN.
-
#julian? ⇒ Boolean
Returns
true
if the date is before the date of calendar reform,false
otherwise:. -
#ld ⇒ Integer
Returns the Lilian day number, which is the number of days since the beginning of the Gregorian calendar, October 15, 1582.
-
#leap? ⇒ Boolean
Returns
true
if the year is a leap year,false
otherwise:. -
#marshal_dump ⇒ Object
:nodoc:.
-
#marshal_dump_old ⇒ Object
:nodoc:.
-
#marshal_load(a) ⇒ Object
:nodoc:.
-
#mday ⇒ Integer
Returns the day of the month in range (1..31):.
-
#mjd ⇒ Integer
Returns the modified Julian day number.
-
#mon ⇒ Integer
Returns the month in range (1..12):.
-
#monday? ⇒ Boolean
Returns
true
ifself
is a Monday,false
otherwise. -
#mon ⇒ Integer
Returns the month in range (1..12):.
-
#new_start(start = Date::ITALY]) ⇒ Object
Returns a copy of
self
with the givenstart
value:. -
#next ⇒ Object
Returns a new Date object representing the following day:.
-
#next_day(n = 1) ⇒ Object
Equivalent to Date#+ with argument
n
. -
#next_month(n = 1) ⇒ Object
Equivalent to #>> with argument
n
. -
#next_year(n = 1) ⇒ Object
Equivalent to #>> with argument
n * 12
. -
#nth_kday?(n, k) ⇒ Boolean
:nodoc:.
-
#prev_day(n = 1) ⇒ Object
Equivalent to Date#- with argument
n
. -
#prev_month(n = 1) ⇒ Object
Equivalent to #<< with argument
n
. -
#prev_year(n = 1) ⇒ Object
Equivalent to #<< with argument
n * 12
. -
#rfc2822 ⇒ String
Equivalent to #strftime with argument
'%a, %-d %b %Y %T %z'
; see Formats for Dates and Times:. -
#rfc3339 ⇒ String
Equivalent to #strftime with argument
'%FT%T%:z'
; see Formats for Dates and Times:. -
#rfc2822 ⇒ String
Equivalent to #strftime with argument
'%a, %-d %b %Y %T %z'
; see Formats for Dates and Times:. -
#saturday? ⇒ Boolean
Returns
true
ifself
is a Saturday,false
otherwise. -
#start ⇒ Float
Returns the Julian start date for calendar reform; if not an infinity, the returned value is suitable for passing to Date#jd:.
-
#step(limit, step = 1) {|date| ... } ⇒ self
Calls the block with specified dates; returns
self
. -
#strftime(format = '%F') ⇒ String
Returns a string representation of the date in
self
, formatted according the givenformat
:. -
#next ⇒ Object
Returns a new Date object representing the following day:.
-
#sunday? ⇒ Boolean
Returns
true
ifself
is a Sunday,false
otherwise. -
#thursday? ⇒ Boolean
Returns
true
ifself
is a Thursday,false
otherwise. -
#to_date ⇒ self
Returns
self
. -
#to_datetime ⇒ Object
Returns a DateTime whose value is the same as
self
:. -
#to_s ⇒ String
Returns a string representation of the date in
self
in ISO 8601 extended date format ('%Y-%m-%d'
):. -
#to_time ⇒ Time
Returns a new Time object with the same value as
self
; ifself
is a Julian date, derives its Gregorian date for conversion to the Time object:. -
#tuesday? ⇒ Boolean
Returns
true
ifself
is a Tuesday,false
otherwise. -
#upto(max) {|date| ... } ⇒ self
Equivalent to #step with arguments
max
and1
. -
#wday ⇒ Integer
Returns the day of week in range (0..6); Sunday is 0:.
-
#wednesday? ⇒ Boolean
Returns
true
ifself
is a Wednesday,false
otherwise. -
#iso8601 ⇒ String
Equivalent to #strftime with argument
'%Y-%m-%d'
(or its shorthand form'%F'
);. -
#yday ⇒ Integer
Returns the day of the year, in range (1..366):.
-
#year ⇒ Integer
Returns the year:.
Constructor Details
#new(year = -4712, month = 1, mday = 1, start = Date::ITALY) ⇒ Object
Returns a new Date object constructed from the given arguments:
Date.new(2022).to_s # => "2022-01-01"
Date.new(2022, 2).to_s # => "2022-02-01"
Date.new(2022, 2, 4).to_s # => "2022-02-04"
Argument month
should be in range (1..12) or range (-12..-1); when the argument is negative, counts backward from the end of the year:
Date.new(2022, -11, 4).to_s # => "2022-02-04"
Argument mday
should be in range (1..n) or range (-n..-1) where n
is the number of days in the month; when the argument is negative, counts backward from the end of the month.
See argument start.
Related: Date.jd.
3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 |
# File 'ext/date/date_core.c', line 3494
static VALUE
date_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE vy, vm, vd, vsg, y, fr, fr2, ret;
int m, d;
double sg;
struct SimpleDateData *dat = rb_check_typeddata(self, &d_lite_type);
if (!simple_dat_p(dat)) {
rb_raise(rb_eTypeError, "Date expected");
}
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:
check_numeric(vd, "day");
num2int_with_frac(d, positive_inf);
case 2:
check_numeric(vm, "month");
m = NUM2INT(vm);
case 1:
check_numeric(vy, "year");
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(eDateError, "invalid date");
set_to_simple(self, dat, 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(eDateError, "invalid date");
set_to_simple(self, dat, nth, rjd, sg, ry, rm, rd, HAVE_JD | HAVE_CIVIL);
}
ret = self;
add_frac();
return ret;
}
|
Class Method Details
._httpdate(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from string
, which should be a valid HTTP date format:
d = Date.new(2001, 2, 3)
s = d.httpdate # => "Sat, 03 Feb 2001 00:00:00 GMT"
Date._httpdate(s)
# => {:wday=>6, :mday=>3, :mon=>2, :year=>2001, :hour=>0, :min=>0, :sec=>0, :zone=>"GMT", :offset=>0}
Related: Date.httpdate (returns a Date object).
4899 4900 4901 4902 4903 4904 4905 4906 4907 4908 |
# File 'ext/date/date_core.c', line 4899
static VALUE
date_s__httpdate(int argc, VALUE *argv, VALUE klass)
{
VALUE str, opt;
rb_scan_args(argc, argv, "1:", &str, &opt);
check_limit(str, opt);
return date__httpdate(str);
}
|
._iso8601(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from string
, which should contain an ISO 8601 formatted date:
d = Date.new(2001, 2, 3)
s = d.iso8601 # => "2001-02-03"
Date._iso8601(s) # => {:mday=>3, :year=>2001, :mon=>2}
See argument limit.
Related: Date.iso8601 (returns a Date object).
4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 |
# File 'ext/date/date_core.c', line 4620
static VALUE
date_s__iso8601(int argc, VALUE *argv, VALUE klass)
{
VALUE str, opt;
rb_scan_args(argc, argv, "1:", &str, &opt);
check_limit(str, opt);
return date__iso8601(str);
}
|
._jisx0301(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from string
, which should be a valid JIS X 0301 date format:
d = Date.new(2001, 2, 3)
s = d.jisx0301 # => "H13.02.03"
Date._jisx0301(s) # => {:year=>2001, :mon=>2, :mday=>3}
See argument limit.
Related: Date.jisx0301 (returns a Date object).
4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 |
# File 'ext/date/date_core.c', line 4968
static VALUE
date_s__jisx0301(int argc, VALUE *argv, VALUE klass)
{
VALUE str, opt;
rb_scan_args(argc, argv, "1:", &str, &opt);
check_limit(str, opt);
return date__jisx0301(str);
}
|
._load(s) ⇒ Object
:nodoc:
7635 7636 7637 7638 7639 7640 7641 7642 7643 |
# File 'ext/date/date_core.c', line 7635
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, limit: 128) ⇒ Hash
Note: This method recognizes many forms in string
, but it is not a validator. For formats, see “Specialized Format Strings” in Formats for Dates and Times
If string
does not specify a valid date, the result is unpredictable; consider using Date._strptime instead.
Returns a hash of values parsed from string
:
Date._parse('2001-02-03') # => {:year=>2001, :mon=>2, :mday=>3}
If comp
is true
and the given year is in the range (0..99)
, the current century is supplied; otherwise, the year is taken as given:
Date._parse('01-02-03', true) # => {:year=>2001, :mon=>2, :mday=>3}
Date._parse('01-02-03', false) # => {:year=>1, :mon=>2, :mday=>3}
See argument limit.
Related: Date.parse(returns a Date object).
4531 4532 4533 4534 4535 |
# File 'ext/date/date_core.c', line 4531
static VALUE
date_s__parse(int argc, VALUE *argv, VALUE klass)
{
return date_s__parse_internal(argc, argv, klass);
}
|
._rfc2822(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from string
, which should be a valid RFC 2822 date format:
d = Date.new(2001, 2, 3)
s = d.rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000"
Date._rfc2822(s)
# => {:wday=>6, :mday=>3, :mon=>2, :year=>2001, :hour=>0, :min=>0, :sec=>0, :zone=>"+0000", :offset=>0}
See argument limit.
Related: Date.rfc2822 (returns a Date object).
4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 |
# File 'ext/date/date_core.c', line 4831
static VALUE
date_s__rfc2822(int argc, VALUE *argv, VALUE klass)
{
VALUE str, opt;
rb_scan_args(argc, argv, "1:", &str, &opt);
check_limit(str, opt);
return date__rfc2822(str);
}
|
._rfc3339(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from string
, which should be a valid RFC 3339 format:
d = Date.new(2001, 2, 3)
s = d.rfc3339 # => "2001-02-03T00:00:00+00:00"
Date._rfc3339(s)
# => {:year=>2001, :mon=>2, :mday=>3, :hour=>0, :min=>0, :sec=>0, :zone=>"+00:00", :offset=>0}
See argument limit.
Related: Date.rfc3339 (returns a Date object).
4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 |
# File 'ext/date/date_core.c', line 4691
static VALUE
date_s__rfc3339(int argc, VALUE *argv, VALUE klass)
{
VALUE str, opt;
rb_scan_args(argc, argv, "1:", &str, &opt);
check_limit(str, opt);
return date__rfc3339(str);
}
|
._rfc2822(string, limit: 128) ⇒ Hash
Returns a hash of values parsed from string
, which should be a valid RFC 2822 date format:
d = Date.new(2001, 2, 3)
s = d.rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000"
Date._rfc2822(s)
# => {:wday=>6, :mday=>3, :mon=>2, :year=>2001, :hour=>0, :min=>0, :sec=>0, :zone=>"+0000", :offset=>0}
See argument limit.
Related: Date.rfc2822 (returns a Date object).
4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 |
# File 'ext/date/date_core.c', line 4831
static VALUE
date_s__rfc2822(int argc, VALUE *argv, VALUE klass)
{
VALUE str, opt;
rb_scan_args(argc, argv, "1:", &str, &opt);
check_limit(str, opt);
return date__rfc2822(str);
}
|
._strptime(string, format = '%F') ⇒ Hash
Returns a hash of values parsed from string
according to the given format
:
Date._strptime('2001-02-03', '%Y-%m-%d') # => {:year=>2001, :mon=>2, :mday=>3}
For other formats, see Formats for Dates and Times. (Unlike Date.strftime, does not support flags and width.)
See also strptime(3).
Related: Date.strptime (returns a Date object).
4388 4389 4390 4391 4392 |
# File 'ext/date/date_core.c', line 4388
static VALUE
date_s__strptime(int argc, VALUE *argv, VALUE klass)
{
return date_s__strptime_internal(argc, argv, klass, "%F");
}
|
._xmlschema(string, limit: 128) ⇒ Hash
4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 |
# File 'ext/date/date_core.c', line 4761
static VALUE
date_s__xmlschema(int argc, VALUE *argv, VALUE klass)
{
VALUE str, opt;
rb_scan_args(argc, argv, "1:", &str, &opt);
check_limit(str, opt);
return date__xmlschema(str);
}
|
.civil(*args) ⇒ Object
Same as Date.new.
3465 3466 3467 3468 3469 |
# File 'ext/date/date_core.c', line 3465
static VALUE
date_s_civil(int argc, VALUE *argv, VALUE klass)
{
return date_initialize(argc, argv, d_lite_s_alloc_simple(klass));
}
|
.commercial(cwyear = -4712, cweek = 1, cwday = 1, start = Date::ITALY) ⇒ Object
Returns a new Date object constructed from the arguments.
Argument cwyear
gives the year, and should be an integer.
Argument cweek
gives the index of the week within the year, and should be in range (1..53) or (-53..-1); in some years, 53 or -53 will be out-of-range; if negative, counts backward from the end of the year:
Date.commercial(2022, 1, 1).to_s # => "2022-01-03"
Date.commercial(2022, 52, 1).to_s # => "2022-12-26"
Argument cwday
gives the indes of the weekday within the week, and should be in range (1..7) or (-7..-1); 1 or -7 is Monday; if negative, counts backward from the end of the week:
Date.commercial(2022, 1, 1).to_s # => "2022-01-03"
Date.commercial(2022, 1, -7).to_s # => "2022-01-03"
When cweek
is 1:
-
If January 1 is a Friday, Saturday, or Sunday, the first week begins in the week after:
Date::ABBR_DAYNAMES[Date.new(2023, 1, 1).wday] # => "Sun" Date.commercial(2023, 1, 1).to_s # => "2023-01-02" Date.commercial(2023, 1, 7).to_s # => "2023-01-08"
-
Otherwise, the first week is the week of January 1, which may mean some of the days fall on the year before:
Date::ABBR_DAYNAMES[Date.new(2020, 1, 1).wday] # => "Wed" Date.commercial(2020, 1, 1).to_s # => "2019-12-30" Date.commercial(2020, 1, 7).to_s # => "2020-01-05"
See argument start.
Related: Date.jd, Date.new, Date.ordinal.
3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 |
# File 'ext/date/date_core.c', line 3600
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:
check_numeric(vd, "cwday");
num2int_with_frac(d, positive_inf);
case 2:
check_numeric(vw, "cweek");
w = NUM2INT(vw);
case 1:
check_numeric(vy, "year");
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(eDateError, "invalid date");
ret = d_simple_new_internal(klass,
nth, rjd,
sg,
0, 0, 0,
HAVE_JD);
}
add_frac();
return ret;
}
|
.gregorian_leap?(year) ⇒ Boolean
Returns true
if the given year is a leap year in the proleptic Gregorian calendar, false
otherwise:
Date.gregorian_leap?(2000) # => true
Date.gregorian_leap?(2001) # => false
Related: Date.julian_leap?.
2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 |
# File 'ext/date/date_core.c', line 2989
static VALUE
date_s_gregorian_leap_p(VALUE klass, VALUE y)
{
VALUE nth;
int ry;
check_numeric(y, "year");
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 = Date::ITALY, limit: 128) ⇒ Object
4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 |
# File 'ext/date/date_core.c', line 4929
static VALUE
date_s_httpdate(int argc, VALUE *argv, VALUE klass)
{
VALUE str, sg, opt;
rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
switch (argc) {
case 0:
str = rb_str_new2("Mon, 01 Jan -4712 00:00:00 GMT");
case 1:
sg = INT2FIX(DEFAULT_SG);
}
{
int argc2 = 1;
VALUE argv2[2], hash;
argv2[0] = str;
if (!NIL_P(opt)) argv2[argc2++] = opt;
hash = date_s__httpdate(argc2, argv2, klass);
return d_new_by_frags(klass, hash, sg);
}
}
|
.iso8601(string = '-4712-01-01', start = Date::ITALY, limit: 128) ⇒ Object
4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 |
# File 'ext/date/date_core.c', line 4650
static VALUE
date_s_iso8601(int argc, VALUE *argv, VALUE klass)
{
VALUE str, sg, opt;
rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
if (!NIL_P(opt)) argc--;
switch (argc) {
case 0:
str = rb_str_new2("-4712-01-01");
case 1:
sg = INT2FIX(DEFAULT_SG);
}
{
int argc2 = 1;
VALUE argv2[2], hash;
argv2[0] = str;
if (!NIL_P(opt)) argv2[argc2++] = opt;
hash = date_s__iso8601(argc2, argv2, klass);
return d_new_by_frags(klass, hash, sg);
}
}
|
.jd(jd = 0, start = Date::ITALY) ⇒ Object
Returns a new Date object formed from the arguments:
Date.jd(2451944).to_s # => "2001-02-03"
Date.jd(2451945).to_s # => "2001-02-04"
Date.jd(0).to_s # => "-4712-01-01"
The returned date is:
-
Gregorian, if the argument is greater than or equal to
start
:Date::ITALY # => 2299161 Date.jd(Date::ITALY).gregorian? # => true Date.jd(Date::ITALY + 1).gregorian? # => true
-
Julian, otherwise
Date.jd(Date::ITALY - 1).julian? # => true
See argument start.
Related: Date.new.
3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 |
# File 'ext/date/date_core.c', line 3352
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:
check_numeric(vjd, "jd");
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 = Date::ITALY, limit: 128) ⇒ Object
Returns a new Date object with values parsed from string
, which should be a valid JIS X 0301 format:
d = Date.new(2001, 2, 3)
s = d.jisx0301 # => "H13.02.03"
Date.jisx0301(s) # => #<Date: 2001-02-03>
For no-era year, legacy format, Heisei is assumed.
Date.jisx0301('13.02.03') # => #<Date: 2001-02-03>
See:
Related: Date._jisx0301 (returns a hash).
5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 |
# File 'ext/date/date_core.c', line 5001
static VALUE
date_s_jisx0301(int argc, VALUE *argv, VALUE klass)
{
VALUE str, sg, opt;
rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
if (!NIL_P(opt)) argc--;
switch (argc) {
case 0:
str = rb_str_new2("-4712-01-01");
case 1:
sg = INT2FIX(DEFAULT_SG);
}
{
int argc2 = 1;
VALUE argv2[2], hash;
argv2[0] = str;
if (!NIL_P(opt)) argv2[argc2++] = opt;
hash = date_s__jisx0301(argc2, argv2, klass);
return d_new_by_frags(klass, hash, sg);
}
}
|
.julian_leap?(year) ⇒ Boolean
Returns true
if the given year is a leap year in the proleptic Julian calendar, false
otherwise:
Date.julian_leap?(1900) # => true
Date.julian_leap?(1901) # => false
Related: Date.gregorian_leap?.
2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 |
# File 'ext/date/date_core.c', line 2966
static VALUE
date_s_julian_leap_p(VALUE klass, VALUE y)
{
VALUE nth;
int ry;
check_numeric(y, "year");
decode_year(y, +1, &nth, &ry);
return f_boolcast(c_julian_leap_p(ry));
}
|
.gregorian_leap?(year) ⇒ Boolean
Returns true
if the given year is a leap year in the proleptic Gregorian calendar, false
otherwise:
Date.gregorian_leap?(2000) # => true
Date.gregorian_leap?(2001) # => false
Related: Date.julian_leap?.
2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 |
# File 'ext/date/date_core.c', line 2989
static VALUE
date_s_gregorian_leap_p(VALUE klass, VALUE y)
{
VALUE nth;
int ry;
check_numeric(y, "year");
decode_year(y, -1, &nth, &ry);
return f_boolcast(c_gregorian_leap_p(ry));
}
|
.new!(*args) ⇒ Object
:nodoc:
3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 |
# File 'ext/date/date_core.c', line 3141
static VALUE
date_s_new_bang(int argc, VALUE *argv, VALUE klass)
{
VALUE ajd, of, sg, nth, sf;
int jd, df, rof;
double rsg;
rb_scan_args(argc, argv, "03", &ajd, &of, &sg);
switch (argc) {
case 0:
ajd = INT2FIX(0);
case 1:
of = INT2FIX(0);
case 2:
sg = INT2FIX(DEFAULT_SG);
}
old_to_new(ajd, of, sg,
&nth, &jd, &df, &sf, &rof, &rsg);
if (!df && f_zero_p(sf) && !rof)
return d_simple_new_internal(klass,
nth, jd,
rsg,
0, 0, 0,
HAVE_JD);
else
return d_complex_new_internal(klass,
nth, jd,
df, sf,
rof, rsg,
0, 0, 0,
0, 0, 0,
HAVE_JD | HAVE_DF);
}
|
.nth_kday(*args) ⇒ Object
:nodoc:
3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 |
# File 'ext/date/date_core.c', line 3701
static VALUE
date_s_nth_kday(int argc, VALUE *argv, VALUE klass)
{
VALUE vy, vm, vn, vk, vsg, y, fr, fr2, ret;
int m, n, k;
double sg;
rb_scan_args(argc, argv, "05", &vy, &vm, &vn, &vk, &vsg);
y = INT2FIX(-4712);
m = 1;
n = 1;
k = 1;
fr2 = INT2FIX(0);
sg = DEFAULT_SG;
switch (argc) {
case 5:
val2sg(vsg, sg);
case 4:
num2int_with_frac(k, positive_inf);
case 3:
n = NUM2INT(vn);
case 2:
m = NUM2INT(vm);
case 1:
y = vy;
}
{
VALUE nth;
int ry, rm, rn, rk, rjd, ns;
if (!valid_nth_kday_p(y, m, n, k, sg,
&nth, &ry,
&rm, &rn, &rk, &rjd,
&ns))
rb_raise(eDateError, "invalid date");
ret = d_simple_new_internal(klass,
nth, rjd,
sg,
0, 0, 0,
HAVE_JD);
}
add_frac();
return ret;
}
|
.ordinal(year = -4712, yday = 1, start = Date::ITALY) ⇒ Object
Returns a new Date object formed fom the arguments.
With no arguments, returns the date for January 1, -4712:
Date.ordinal.to_s # => "-4712-01-01"
With argument year
, returns the date for January 1 of that year:
Date.ordinal(2001).to_s # => "2001-01-01"
Date.ordinal(-2001).to_s # => "-2001-01-01"
With positive argument yday
== n
, returns the date for the nth
day of the given year:
Date.ordinal(2001, 14).to_s # => "2001-01-14"
With negative argument yday
, counts backward from the end of the year:
Date.ordinal(2001, -14).to_s # => "2001-12-18"
Raises an exception if yday
is zero or out of range.
See argument start.
Related: Date.jd, Date.new.
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 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 |
# File 'ext/date/date_core.c', line 3417
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:
check_numeric(vd, "yday");
num2int_with_frac(d, positive_inf);
case 1:
check_numeric(vy, "year");
y = vy;
}
{
VALUE nth;
int ry, rd, rjd, ns;
if (!valid_ordinal_p(y, d, sg,
&nth, &ry,
&rd, &rjd,
&ns))
rb_raise(eDateError, "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 = Date::ITALY, limit: 128) ⇒ Object
Note: This method recognizes many forms in string
, but it is not a validator. For formats, see “Specialized Format Strings” in Formats for Dates and Times If string
does not specify a valid date, the result is unpredictable; consider using Date._strptime instead.
Returns a new Date object with values parsed from string
:
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>
If comp
is true
and the given year is in the range (0..99)
, the current century is supplied; otherwise, the year is taken as given:
Date.parse('01-02-03', true) # => #<Date: 2001-02-03>
Date.parse('01-02-03', false) # => #<Date: 0001-02-03>
See:
Related: Date._parse (returns a hash).
4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 |
# File 'ext/date/date_core.c', line 4570
static VALUE
date_s_parse(int argc, VALUE *argv, VALUE klass)
{
VALUE str, comp, sg, opt;
rb_scan_args(argc, argv, "03:", &str, &comp, &sg, &opt);
if (!NIL_P(opt)) argc--;
switch (argc) {
case 0:
str = rb_str_new2("-4712-01-01");
case 1:
comp = Qtrue;
case 2:
sg = INT2FIX(DEFAULT_SG);
}
{
int argc2 = 2;
VALUE argv2[3], hash;
argv2[0] = str;
argv2[1] = comp;
if (!NIL_P(opt)) argv2[argc2++] = opt;
hash = date_s__parse(argc2, argv2, klass);
return d_new_by_frags(klass, hash, sg);
}
}
|
.rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000', start = Date::ITALY, limit: 128) ⇒ Object
4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 |
# File 'ext/date/date_core.c', line 4861
static VALUE
date_s_rfc2822(int argc, VALUE *argv, VALUE klass)
{
VALUE str, sg, opt;
rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
switch (argc) {
case 0:
str = rb_str_new2("Mon, 1 Jan -4712 00:00:00 +0000");
case 1:
sg = INT2FIX(DEFAULT_SG);
}
{
int argc2 = 1;
VALUE argv2[2], hash;
argv2[0] = str;
if (!NIL_P(opt)) argv2[argc2++] = opt;
hash = date_s__rfc2822(argc2, argv2, klass);
return d_new_by_frags(klass, hash, sg);
}
}
|
.rfc3339(string = '-4712-01-01T00:00:00+00:00', start = Date::ITALY, limit: 128) ⇒ Object
4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 |
# File 'ext/date/date_core.c', line 4721
static VALUE
date_s_rfc3339(int argc, VALUE *argv, VALUE klass)
{
VALUE str, sg, opt;
rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
if (!NIL_P(opt)) argc--;
switch (argc) {
case 0:
str = rb_str_new2("-4712-01-01T00:00:00+00:00");
case 1:
sg = INT2FIX(DEFAULT_SG);
}
{
int argc2 = 1;
VALUE argv2[2], hash;
argv2[0] = str;
if (!NIL_P(opt)) argv2[argc2++] = opt;
hash = date_s__rfc3339(argc2, argv2, klass);
return d_new_by_frags(klass, hash, sg);
}
}
|
.rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000', start = Date::ITALY, limit: 128) ⇒ Object
4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 |
# File 'ext/date/date_core.c', line 4861
static VALUE
date_s_rfc2822(int argc, VALUE *argv, VALUE klass)
{
VALUE str, sg, opt;
rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
switch (argc) {
case 0:
str = rb_str_new2("Mon, 1 Jan -4712 00:00:00 +0000");
case 1:
sg = INT2FIX(DEFAULT_SG);
}
{
int argc2 = 1;
VALUE argv2[2], hash;
argv2[0] = str;
if (!NIL_P(opt)) argv2[argc2++] = opt;
hash = date_s__rfc2822(argc2, argv2, klass);
return d_new_by_frags(klass, hash, sg);
}
}
|
.strptime(string = '-4712-01-01', format = '%F', start = Date::ITALY) ⇒ Object
Returns a new Date object with values parsed from string
, according to the given format
:
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>
For other formats, see Formats for Dates and Times. (Unlike Date.strftime, does not support flags and width.)
See argument start.
See also strptime(3).
Related: Date._strptime (returns a hash).
4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 |
# File 'ext/date/date_core.c', line 4419
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);
}
}
|
.test_all ⇒ Object
:nodoc:
9406 9407 9408 9409 9410 9411 9412 9413 9414 9415 9416 9417 9418 9419 9420 9421 9422 |
# File 'ext/date/date_core.c', line 9406
static VALUE
date_s_test_all(VALUE klass)
{
if (date_s_test_civil(klass) == Qfalse)
return Qfalse;
if (date_s_test_ordinal(klass) == Qfalse)
return Qfalse;
if (date_s_test_commercial(klass) == Qfalse)
return Qfalse;
if (date_s_test_weeknum(klass) == Qfalse)
return Qfalse;
if (date_s_test_nth_kday(klass) == Qfalse)
return Qfalse;
if (date_s_test_unit_conv(klass) == Qfalse)
return Qfalse;
return Qtrue;
}
|
.test_civil ⇒ Object
:nodoc:
9142 9143 9144 9145 9146 9147 9148 9149 9150 9151 9152 9153 9154 9155 9156 9157 9158 9159 9160 |
# File 'ext/date/date_core.c', line 9142
static VALUE
date_s_test_civil(VALUE klass)
{
if (!test_civil(MIN_JD, MIN_JD + 366, GREGORIAN))
return Qfalse;
if (!test_civil(2305814, 2598007, GREGORIAN))
return Qfalse;
if (!test_civil(MAX_JD - 366, MAX_JD, GREGORIAN))
return Qfalse;
if (!test_civil(MIN_JD, MIN_JD + 366, ITALY))
return Qfalse;
if (!test_civil(2305814, 2598007, ITALY))
return Qfalse;
if (!test_civil(MAX_JD - 366, MAX_JD, ITALY))
return Qfalse;
return Qtrue;
}
|
.test_commercial ⇒ Object
:nodoc:
9226 9227 9228 9229 9230 9231 9232 9233 9234 9235 9236 9237 9238 9239 9240 9241 9242 9243 9244 |
# File 'ext/date/date_core.c', line 9226
static VALUE
date_s_test_commercial(VALUE klass)
{
if (!test_commercial(MIN_JD, MIN_JD + 366, GREGORIAN))
return Qfalse;
if (!test_commercial(2305814, 2598007, GREGORIAN))
return Qfalse;
if (!test_commercial(MAX_JD - 366, MAX_JD, GREGORIAN))
return Qfalse;
if (!test_commercial(MIN_JD, MIN_JD + 366, ITALY))
return Qfalse;
if (!test_commercial(2305814, 2598007, ITALY))
return Qfalse;
if (!test_commercial(MAX_JD - 366, MAX_JD, ITALY))
return Qfalse;
return Qtrue;
}
|
.test_nth_kday ⇒ Object
:nodoc:
9314 9315 9316 9317 9318 9319 9320 9321 9322 9323 9324 9325 9326 9327 9328 9329 9330 9331 9332 |
# File 'ext/date/date_core.c', line 9314
static VALUE
date_s_test_nth_kday(VALUE klass)
{
if (!test_nth_kday(MIN_JD, MIN_JD + 366, GREGORIAN))
return Qfalse;
if (!test_nth_kday(2305814, 2598007, GREGORIAN))
return Qfalse;
if (!test_nth_kday(MAX_JD - 366, MAX_JD, GREGORIAN))
return Qfalse;
if (!test_nth_kday(MIN_JD, MIN_JD + 366, ITALY))
return Qfalse;
if (!test_nth_kday(2305814, 2598007, ITALY))
return Qfalse;
if (!test_nth_kday(MAX_JD - 366, MAX_JD, ITALY))
return Qfalse;
return Qtrue;
}
|
.test_ordinal ⇒ Object
:nodoc:
9184 9185 9186 9187 9188 9189 9190 9191 9192 9193 9194 9195 9196 9197 9198 9199 9200 9201 9202 |
# File 'ext/date/date_core.c', line 9184
static VALUE
date_s_test_ordinal(VALUE klass)
{
if (!test_ordinal(MIN_JD, MIN_JD + 366, GREGORIAN))
return Qfalse;
if (!test_ordinal(2305814, 2598007, GREGORIAN))
return Qfalse;
if (!test_ordinal(MAX_JD - 366, MAX_JD, GREGORIAN))
return Qfalse;
if (!test_ordinal(MIN_JD, MIN_JD + 366, ITALY))
return Qfalse;
if (!test_ordinal(2305814, 2598007, ITALY))
return Qfalse;
if (!test_ordinal(MAX_JD - 366, MAX_JD, ITALY))
return Qfalse;
return Qtrue;
}
|
.test_unit_conv ⇒ Object
:nodoc:
9391 9392 9393 9394 9395 9396 9397 9398 9399 9400 9401 9402 9403 |
# File 'ext/date/date_core.c', line 9391
static VALUE
date_s_test_unit_conv(VALUE klass)
{
if (!test_unit_v2v_iter(sec_to_day, day_to_sec))
return Qfalse;
if (!test_unit_v2v_iter(ms_to_sec, sec_to_ms))
return Qfalse;
if (!test_unit_v2v_iter(ns_to_day, day_to_ns))
return Qfalse;
if (!test_unit_v2v_iter(ns_to_sec, sec_to_ns))
return Qfalse;
return Qtrue;
}
|
.test_weeknum ⇒ Object
:nodoc:
9268 9269 9270 9271 9272 9273 9274 9275 9276 9277 9278 9279 9280 9281 9282 9283 9284 9285 9286 9287 9288 9289 9290 |
# File 'ext/date/date_core.c', line 9268
static VALUE
date_s_test_weeknum(VALUE klass)
{
int f;
for (f = 0; f <= 1; f++) {
if (!test_weeknum(MIN_JD, MIN_JD + 366, f, GREGORIAN))
return Qfalse;
if (!test_weeknum(2305814, 2598007, f, GREGORIAN))
return Qfalse;
if (!test_weeknum(MAX_JD - 366, MAX_JD, f, GREGORIAN))
return Qfalse;
if (!test_weeknum(MIN_JD, MIN_JD + 366, f, ITALY))
return Qfalse;
if (!test_weeknum(2305814, 2598007, f, ITALY))
return Qfalse;
if (!test_weeknum(MAX_JD - 366, MAX_JD, f, ITALY))
return Qfalse;
}
return Qtrue;
}
|
.today(start = Date::ITALY) ⇒ Object
3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 |
# File 'ext/date/date_core.c', line 3784
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
Returns true
if the arguments define a valid ordinal date, false
otherwise:
Date.valid_date?(2001, 2, 3) # => true
Date.valid_date?(2001, 2, 29) # => false
Date.valid_date?(2001, 2, -1) # => true
See argument start.
Related: Date.jd, Date.new.
2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 |
# File 'ext/date/date_core.c', line 2594
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);
RETURN_FALSE_UNLESS_NUMERIC(vy);
RETURN_FALSE_UNLESS_NUMERIC(vm);
RETURN_FALSE_UNLESS_NUMERIC(vd);
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
2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 |
# File 'ext/date/date_core.c', line 2772
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);
RETURN_FALSE_UNLESS_NUMERIC(vy);
RETURN_FALSE_UNLESS_NUMERIC(vw);
RETURN_FALSE_UNLESS_NUMERIC(vd);
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
2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 |
# File 'ext/date/date_core.c', line 2594
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);
RETURN_FALSE_UNLESS_NUMERIC(vy);
RETURN_FALSE_UNLESS_NUMERIC(vm);
RETURN_FALSE_UNLESS_NUMERIC(vd);
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) ⇒ true
2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 |
# File 'ext/date/date_core.c', line 2500
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);
RETURN_FALSE_UNLESS_NUMERIC(vjd);
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
2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 |
# File 'ext/date/date_core.c', line 2682
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);
RETURN_FALSE_UNLESS_NUMERIC(vy);
RETURN_FALSE_UNLESS_NUMERIC(vd);
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;
}
|
.weeknum(*args) ⇒ Object
:nodoc:
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 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 |
# File 'ext/date/date_core.c', line 3651
static VALUE
date_s_weeknum(int argc, VALUE *argv, VALUE klass)
{
VALUE vy, vw, vd, vf, vsg, y, fr, fr2, ret;
int w, d, f;
double sg;
rb_scan_args(argc, argv, "05", &vy, &vw, &vd, &vf, &vsg);
y = INT2FIX(-4712);
w = 0;
d = 1;
f = 0;
fr2 = INT2FIX(0);
sg = DEFAULT_SG;
switch (argc) {
case 5:
val2sg(vsg, sg);
case 4:
f = NUM2INT(vf);
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_weeknum_p(y, w, d, f, sg,
&nth, &ry,
&rw, &rd, &rjd,
&ns))
rb_raise(eDateError, "invalid date");
ret = d_simple_new_internal(klass,
nth, rjd,
sg,
0, 0, 0,
HAVE_JD);
}
add_frac();
return ret;
}
|
.xmlschema(string = '-4712-01-01', start = Date::ITALY, limit: 128) ⇒ Object
4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 |
# File 'ext/date/date_core.c', line 4790
static VALUE
date_s_xmlschema(int argc, VALUE *argv, VALUE klass)
{
VALUE str, sg, opt;
rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
if (!NIL_P(opt)) argc--;
switch (argc) {
case 0:
str = rb_str_new2("-4712-01-01");
case 1:
sg = INT2FIX(DEFAULT_SG);
}
{
int argc2 = 1;
VALUE argv2[2], hash;
argv2[0] = str;
if (!NIL_P(opt)) argv2[argc2++] = opt;
hash = date_s__xmlschema(argc2, argv2, klass);
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 a fractional number, 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 …>
5959 5960 5961 5962 5963 5964 5965 5966 5967 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 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067 6068 6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 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 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275 6276 6277 6278 |
# File 'ext/date/date_core.c', line 5959
static VALUE
d_lite_plus(VALUE self, VALUE other)
{
int try_rational = 1;
get_d1(self);
again:
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);
if (!k_rational_p(other)) {
if (!try_rational) Check_Type(other, T_RATIONAL);
try_rational = 0;
goto again;
}
/* fall through */
case T_RATIONAL:
{
VALUE nth, sf, t;
int jd, df, s;
if (wholenum_p(other)) {
other = rb_rational_num(other);
goto again;
}
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 a fractional number, 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)
6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 |
# File 'ext/date/date_core.c', line 6348
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
Returns a new Date object representing the date n
months earlier; n
should be a numeric:
(Date.new(2001, 2, 3) << 1).to_s # => "2001-01-03"
(Date.new(2001, 2, 3) << -2).to_s # => "2001-04-03"
When the same day does not exist for the new month, the last day of that month is used instead:
(Date.new(2001, 3, 31) << 1).to_s # => "2001-02-28"
(Date.new(2001, 3, 31) << -6).to_s # => "2001-09-30"
This results in the following, possibly unexpected, behaviors:
d0 = Date.new(2001, 3, 31)
d0 << 2 # => #<Date: 2001-01-31>
d0 << 1 << 1 # => #<Date: 2001-01-28>
d0 = Date.new(2001, 3, 31)
d1 = d0 << 1 # => #<Date: 2001-02-28>
d2 = d1 << -1 # => #<Date: 2001-03-28>
6512 6513 6514 6515 6516 6517 |
# File 'ext/date/date_core.c', line 6512
static VALUE
d_lite_lshift(VALUE self, VALUE other)
{
expect_numeric(other);
return d_lite_rshift(self, f_negate(other));
}
|
#<=>(other) ⇒ -1, ...
Compares self
and other
, returning:
-
-1
ifother
is larger. -
0
if the two are equal. -
1
ifother
is smaller. -
nil
if the two are incomparable.
Argument other
may be:
-
Another Date object:
d = Date.new(2022, 7, 27) # => #<Date: 2022-07-27 ((2459788j,0s,0n),+0s,2299161j)> prev_date = d.prev_day # => #<Date: 2022-07-26 ((2459787j,0s,0n),+0s,2299161j)> next_date = d.next_day # => #<Date: 2022-07-28 ((2459789j,0s,0n),+0s,2299161j)> d <=> next_date # => -1 d <=> d # => 0 d <=> prev_date # => 1
-
A DateTime object:
d <=> DateTime.new(2022, 7, 26) # => 1 d <=> DateTime.new(2022, 7, 27) # => 0 d <=> DateTime.new(2022, 7, 28) # => -1
-
A numeric (compares
self.ajd
toother
):d <=> 2459788 # => -1 d <=> 2459787 # => 1 d <=> 2459786 # => 1 d <=> d.ajd # => 0
-
Any other object:
d <=> Object.new # => nil
6809 6810 6811 6812 6813 6814 6815 6816 6817 6818 6819 6820 6821 6822 6823 6824 6825 6826 6827 6828 6829 6830 6831 6832 6833 6834 6835 6836 6837 6838 6839 6840 6841 6842 6843 6844 6845 6846 6847 6848 6849 6850 6851 |
# File 'ext/date/date_core.c', line 6809
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) ⇒ true, false
Returns true
if self
and other
represent the same date, false
if not, nil
if the two are not comparable.
Argument other
may be:
-
Another Date object:
d = Date.new(2022, 7, 27) # => #<Date: 2022-07-27 ((2459788j,0s,0n),+0s,2299161j)> prev_date = d.prev_day # => #<Date: 2022-07-26 ((2459787j,0s,0n),+0s,2299161j)> next_date = d.next_day # => #<Date: 2022-07-28 ((2459789j,0s,0n),+0s,2299161j)> d === prev_date # => false d === d # => true d === next_date # => false
-
A DateTime object:
d === DateTime.new(2022, 7, 26) # => false d === DateTime.new(2022, 7, 27) # => true d === DateTime.new(2022, 7, 28) # => false
-
A numeric (compares
self.jd
toother
):d === 2459788 # => true d === 2459787 # => false d === 2459786 # => false d === d.jd # => true
-
An object not comparable:
d === Object.new # => nil
6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911 6912 6913 6914 6915 6916 6917 6918 6919 6920 6921 6922 6923 6924 6925 6926 6927 6928 6929 |
# File 'ext/date/date_core.c', line 6901
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
Returns a new Date object representing the date n
months later; n
should be a numeric:
(Date.new(2001, 2, 3) >> 1).to_s # => "2001-03-03"
(Date.new(2001, 2, 3) >> -2).to_s # => "2000-12-03"
When the same day does not exist for the new month, the last day of that month is used instead:
(Date.new(2001, 1, 31) >> 1).to_s # => "2001-02-28"
(Date.new(2001, 1, 31) >> -4).to_s # => "2000-09-30"
This results in the following, possibly unexpected, behaviors:
d0 = Date.new(2001, 1, 31)
d1 = d0 >> 1 # => #<Date: 2001-02-28>
d2 = d1 >> 1 # => #<Date: 2001-03-28>
d0 = Date.new(2001, 1, 31)
d1 = d0 >> 1 # => #<Date: 2001-02-28>
d2 = d1 >> -1 # => #<Date: 2001-01-28>
6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456 6457 6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469 6470 6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 |
# File 'ext/date/date_core.c', line 6446
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(eDateError, "invalid date");
}
encode_jd(nth, rjd, &rjd2);
return d_lite_plus(self, f_sub(rjd2, m_real_local_jd(dat)));
}
|
#ajd ⇒ Object
5221 5222 5223 5224 5225 5226 |
# File 'ext/date/date_core.c', line 5221
static VALUE
d_lite_ajd(VALUE self)
{
get_d1(self);
return m_ajd(dat);
}
|
#amjd ⇒ Object
5238 5239 5240 5241 5242 5243 |
# File 'ext/date/date_core.c', line 5238
static VALUE
d_lite_amjd(VALUE self)
{
get_d1(self);
return m_amjd(dat);
}
|
#asctime ⇒ String
Equivalent to #strftime with argument '%a %b %e %T %Y'
(or its shorthand form '%c'
):
Date.new(2001, 2, 3).asctime # => "Sat Feb 3 00:00:00 2001"
See asctime.
7286 7287 7288 7289 7290 |
# File 'ext/date/date_core.c', line 7286
static VALUE
d_lite_asctime(VALUE self)
{
return strftimev("%a %b %e %H:%M:%S %Y", self, set_tmx);
}
|
#asctime ⇒ String
Equivalent to #strftime with argument '%a %b %e %T %Y'
(or its shorthand form '%c'
):
Date.new(2001, 2, 3).asctime # => "Sat Feb 3 00:00:00 2001"
See asctime.
7286 7287 7288 7289 7290 |
# File 'ext/date/date_core.c', line 7286
static VALUE
d_lite_asctime(VALUE self)
{
return strftimev("%a %b %e %H:%M:%S %Y", self, set_tmx);
}
|
#cwday ⇒ Integer
5427 5428 5429 5430 5431 5432 |
# File 'ext/date/date_core.c', line 5427
static VALUE
d_lite_cwday(VALUE self)
{
get_d1(self);
return INT2FIX(m_cwday(dat));
}
|
#cweek ⇒ Integer
5409 5410 5411 5412 5413 5414 |
# File 'ext/date/date_core.c', line 5409
static VALUE
d_lite_cweek(VALUE self)
{
get_d1(self);
return INT2FIX(m_cweek(dat));
}
|
#cwyear ⇒ Integer
5392 5393 5394 5395 5396 5397 |
# File 'ext/date/date_core.c', line 5392
static VALUE
d_lite_cwyear(VALUE self)
{
get_d1(self);
return m_real_cwyear(dat);
}
|
#mday ⇒ Integer
5356 5357 5358 5359 5360 5361 |
# File 'ext/date/date_core.c', line 5356
static VALUE
d_lite_mday(VALUE self)
{
get_d1(self);
return INT2FIX(m_mday(dat));
}
|
#day_fraction ⇒ Object
5372 5373 5374 5375 5376 5377 5378 5379 |
# File 'ext/date/date_core.c', line 5372
static VALUE
d_lite_day_fraction(VALUE self)
{
get_d1(self);
if (simple_dat_p(dat))
return INT2FIX(0);
return m_fr(dat);
}
|
#deconstruct_keys(array_of_names_or_nil) ⇒ Hash
Returns a hash of the name/value pairs, to use in pattern matching. Possible keys are: :year
, :month
, :day
, :wday
, :yday
.
Possible usages:
d = Date.new(2022, 10, 5)
if d in wday: 3, day: ..7 # uses deconstruct_keys underneath
puts "first Wednesday of the month"
end
#=> prints "first Wednesday of the month"
case d
in year: ...2022
puts "too old"
in month: ..9
puts "quarter 1-3"
in wday: 1..5, month:
puts "working day in month #{month}"
end
#=> prints "working day in month 10"
Note that deconstruction by pattern can also be combined with class check:
if d in Date(wday: 3, day: ..7)
puts "first Wednesday of the month"
end
7505 7506 7507 7508 7509 |
# File 'ext/date/date_core.c', line 7505
static VALUE
d_lite_deconstruct_keys(VALUE self, VALUE keys)
{
return deconstruct_keys(self, keys, /* is_datetime=false */ 0);
}
|
#downto(min) {|date| ... } ⇒ self
Equivalent to #step with arguments min
and -1
.
6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696 6697 6698 |
# File 'ext/date/date_core.c', line 6685
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
Equivalent to Date#new_start with argument Date::ENGLAND.
5867 5868 5869 5870 5871 |
# File 'ext/date/date_core.c', line 5867
static VALUE
d_lite_england(VALUE self)
{
return dup_obj_with_new_start(self, ENGLAND);
}
|
#eql?(other) ⇒ Boolean
:nodoc:
6932 6933 6934 6935 6936 6937 6938 |
# File 'ext/date/date_core.c', line 6932
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));
}
|
#fill ⇒ Object
:nodoc:
5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 |
# File 'ext/date/date_core.c', line 5192
static VALUE
d_lite_fill(VALUE self)
{
get_d1(self);
if (simple_dat_p(dat)) {
get_s_jd(dat);
get_s_civil(dat);
}
else {
get_c_jd(dat);
get_c_civil(dat);
get_c_df(dat);
get_c_time(dat);
}
return self;
}
|
#friday? ⇒ Boolean
Returns true
if self
is a Friday, false
otherwise.
5539 5540 5541 5542 5543 5544 |
# File 'ext/date/date_core.c', line 5539
static VALUE
d_lite_friday_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_wday(dat) == 5);
}
|
#gregorian ⇒ Object
Equivalent to Date#new_start with argument Date::GREGORIAN.
5891 5892 5893 5894 5895 |
# File 'ext/date/date_core.c', line 5891
static VALUE
d_lite_gregorian(VALUE self)
{
return dup_obj_with_new_start(self, GREGORIAN);
}
|
#gregorian? ⇒ Boolean
5704 5705 5706 5707 5708 5709 |
# File 'ext/date/date_core.c', line 5704
static VALUE
d_lite_gregorian_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_gregorian_p(dat));
}
|
#hash ⇒ Object
:nodoc:
6941 6942 6943 6944 6945 6946 6947 6948 6949 6950 6951 6952 6953 |
# File 'ext/date/date_core.c', line 6941
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 ST2FIX(v);
}
|
#httpdate ⇒ String
Equivalent to #strftime with argument '%a, %d %b %Y %T GMT'
; see Formats for Dates and Times:
Date.new(2001, 2, 3).httpdate # => "Sat, 03 Feb 2001 00:00:00 GMT"
7351 7352 7353 7354 7355 7356 |
# File 'ext/date/date_core.c', line 7351
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);
}
|
#infinite? ⇒ Boolean
call-seq:
infinite? -> false
Returns false
13 14 15 |
# File 'lib/date.rb', line 13 def infinite? false end |
#initialize_copy(date) ⇒ Object
:nodoc:
5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 |
# File 'ext/date/date_core.c', line 5146
static VALUE
d_lite_initialize_copy(VALUE copy, VALUE date)
{
rb_check_frozen(copy);
if (copy == date)
return copy;
{
get_d2(copy, date);
if (simple_dat_p(bdat)) {
if (simple_dat_p(adat)) {
adat->s = bdat->s;
}
else {
adat->c.flags = bdat->s.flags | COMPLEX_DAT;
adat->c.nth = bdat->s.nth;
adat->c.jd = bdat->s.jd;
adat->c.df = 0;
adat->c.sf = INT2FIX(0);
adat->c.of = 0;
adat->c.sg = bdat->s.sg;
adat->c.year = bdat->s.year;
#ifndef USE_PACK
adat->c.mon = bdat->s.mon;
adat->c.mday = bdat->s.mday;
adat->c.hour = bdat->s.hour;
adat->c.min = bdat->s.min;
adat->c.sec = bdat->s.sec;
#else
adat->c.pc = bdat->s.pc;
#endif
}
}
else {
if (!complex_dat_p(adat))
rb_raise(rb_eArgError,
"cannot load complex into simple");
adat->c = bdat->c;
}
}
return copy;
}
|
#inspect ⇒ String
7058 7059 7060 7061 7062 7063 |
# File 'ext/date/date_core.c', line 7058
static VALUE
d_lite_inspect(VALUE self)
{
get_d1(self);
return mk_inspect(dat, rb_obj_class(self), self);
}
|
#inspect_raw ⇒ Object
:nodoc:
7029 7030 7031 7032 7033 7034 |
# File 'ext/date/date_core.c', line 7029
static VALUE
d_lite_inspect_raw(VALUE self)
{
get_d1(self);
return mk_inspect_raw(dat, rb_obj_class(self));
}
|
#iso8601 ⇒ String
Equivalent to #strftime with argument '%Y-%m-%d'
(or its shorthand form '%F'
);
Date.new(2001, 2, 3).iso8601 # => "2001-02-03"
7303 7304 7305 7306 7307 |
# File 'ext/date/date_core.c', line 7303
static VALUE
d_lite_iso8601(VALUE self)
{
return strftimev("%Y-%m-%d", self, set_tmx);
}
|
#italy ⇒ Object
Equivalent to Date#new_start with argument Date::ITALY.
5855 5856 5857 5858 5859 |
# File 'ext/date/date_core.c', line 5855
static VALUE
d_lite_italy(VALUE self)
{
return dup_obj_with_new_start(self, ITALY);
}
|
#jd ⇒ Integer
5255 5256 5257 5258 5259 5260 |
# File 'ext/date/date_core.c', line 5255
static VALUE
d_lite_jd(VALUE self)
{
get_d1(self);
return m_real_local_jd(dat);
}
|
#jisx0301 ⇒ String
7408 7409 7410 7411 7412 7413 7414 7415 7416 7417 7418 7419 |
# File 'ext/date/date_core.c', line 7408
static VALUE
d_lite_jisx0301(VALUE self)
{
char fmtbuf[JISX0301_DATE_SIZE];
const char *fmt;
get_d1(self);
fmt = jisx0301_date_format(fmtbuf, sizeof(fmtbuf),
m_real_local_jd(dat),
m_real_year(dat));
return strftimev(fmt, self, set_tmx);
}
|
#julian ⇒ Object
Equivalent to Date#new_start with argument Date::JULIAN.
5879 5880 5881 5882 5883 |
# File 'ext/date/date_core.c', line 5879
static VALUE
d_lite_julian(VALUE self)
{
return dup_obj_with_new_start(self, JULIAN);
}
|
#julian? ⇒ Boolean
5686 5687 5688 5689 5690 5691 |
# File 'ext/date/date_core.c', line 5686
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, which is the number of days since the beginning of the Gregorian calendar, October 15, 1582.
Date.new(2001, 2, 3).ld # => 152784
5291 5292 5293 5294 5295 5296 |
# File 'ext/date/date_core.c', line 5291
static VALUE
d_lite_ld(VALUE self)
{
get_d1(self);
return f_sub(m_real_local_jd(dat), INT2FIX(2299160));
}
|
#leap? ⇒ Boolean
5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 |
# File 'ext/date/date_core.c', line 5721
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:
7535 7536 7537 7538 7539 7540 7541 7542 7543 7544 7545 7546 7547 7548 7549 7550 7551 7552 7553 7554 7555 7556 |
# File 'ext/date/date_core.c', line 7535
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_dump_old ⇒ Object
:nodoc:
7513 7514 7515 7516 7517 7518 7519 7520 7521 7522 7523 7524 7525 7526 7527 7528 7529 7530 7531 |
# File 'ext/date/date_core.c', line 7513
static VALUE
d_lite_marshal_dump_old(VALUE self)
{
VALUE a;
get_d1(self);
a = rb_ary_new3(3,
m_ajd(dat),
m_of_in_day(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:
7559 7560 7561 7562 7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 7575 7576 7577 7578 7579 7580 7581 7582 7583 7584 7585 7586 7587 7588 7589 7590 7591 7592 7593 7594 7595 7596 7597 7598 7599 7600 7601 7602 7603 7604 7605 7606 7607 7608 7609 7610 7611 7612 7613 7614 7615 7616 7617 7618 7619 7620 7621 7622 7623 7624 7625 7626 7627 7628 7629 7630 7631 7632 |
# File 'ext/date/date_core.c', line 7559
static VALUE
d_lite_marshal_load(VALUE self, VALUE a)
{
VALUE nth, sf;
int jd, df, of;
double sg;
get_d1(self);
rb_check_frozen(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, vof, vsg;
if (RARRAY_LEN(a) == 2) {
ajd = f_sub(RARRAY_AREF(a, 0), half_days_in_day);
vof = INT2FIX(0);
vsg = RARRAY_AREF(a, 1);
if (!k_numeric_p(vsg))
vsg = DBL2NUM(RTEST(vsg) ? GREGORIAN : JULIAN);
}
else {
ajd = RARRAY_AREF(a, 0);
vof = RARRAY_AREF(a, 1);
vsg = RARRAY_AREF(a, 2);
}
old_to_new(ajd, vof, vsg,
&nth, &jd, &df, &sf, &of, &sg);
}
break;
case 6:
{
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));
}
break;
default:
rb_raise(rb_eTypeError, "invalid size");
break;
}
if (simple_dat_p(dat)) {
if (df || !f_zero_p(sf) || of) {
/* loading a fractional date; promote to complex */
dat = ruby_xrealloc(dat, sizeof(struct ComplexDateData));
RTYPEDDATA(self)->data = dat;
goto complex_data;
}
set_to_simple(self, &dat->s, nth, jd, sg, 0, 0, 0, HAVE_JD);
} else {
complex_data:
set_to_complex(self, &dat->c, nth, jd, df, sf, of, sg,
0, 0, 0, 0, 0, 0,
HAVE_JD | HAVE_DF);
}
if (FL_TEST(a, FL_EXIVAR)) {
rb_copy_generic_ivar(self, a);
FL_SET(self, FL_EXIVAR);
}
return self;
}
|
#mday ⇒ Integer
5356 5357 5358 5359 5360 5361 |
# File 'ext/date/date_core.c', line 5356
static VALUE
d_lite_mday(VALUE self)
{
get_d1(self);
return INT2FIX(m_mday(dat));
}
|
#mjd ⇒ Integer
5272 5273 5274 5275 5276 5277 |
# File 'ext/date/date_core.c', line 5272
static VALUE
d_lite_mjd(VALUE self)
{
get_d1(self);
return f_sub(m_real_local_jd(dat), INT2FIX(2400001));
}
|
#mon ⇒ Integer
5340 5341 5342 5343 5344 5345 |
# File 'ext/date/date_core.c', line 5340
static VALUE
d_lite_mon(VALUE self)
{
get_d1(self);
return INT2FIX(m_mon(dat));
}
|
#monday? ⇒ Boolean
Returns true
if self
is a Monday, false
otherwise.
5487 5488 5489 5490 5491 5492 |
# File 'ext/date/date_core.c', line 5487
static VALUE
d_lite_monday_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_wday(dat) == 1);
}
|
#mon ⇒ Integer
5340 5341 5342 5343 5344 5345 |
# File 'ext/date/date_core.c', line 5340
static VALUE
d_lite_mon(VALUE self)
{
get_d1(self);
return INT2FIX(m_mon(dat));
}
|
#new_start(start = Date::ITALY]) ⇒ Object
5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 |
# File 'ext/date/date_core.c', line 5833
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);
}
|
#next ⇒ Object
6413 6414 6415 6416 6417 |
# File 'ext/date/date_core.c', line 6413
static VALUE
d_lite_next(VALUE self)
{
return d_lite_next_day(0, (VALUE *)NULL, self);
}
|
#next_day(n = 1) ⇒ Object
Equivalent to Date#+ with argument n
.
6374 6375 6376 6377 6378 6379 6380 6381 6382 6383 |
# File 'ext/date/date_core.c', line 6374
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
Equivalent to #>> with argument n
.
6525 6526 6527 6528 6529 6530 6531 6532 6533 6534 |
# File 'ext/date/date_core.c', line 6525
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
Equivalent to #>> with argument n * 12
.
6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 |
# File 'ext/date/date_core.c', line 6559
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)));
}
|
#nth_kday?(n, k) ⇒ Boolean
:nodoc:
5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 |
# File 'ext/date/date_core.c', line 5561
static VALUE
d_lite_nth_kday_p(VALUE self, VALUE n, VALUE k)
{
int rjd, ns;
get_d1(self);
if (NUM2INT(k) != m_wday(dat))
return Qfalse;
c_nth_kday_to_jd(m_year(dat), m_mon(dat),
NUM2INT(n), NUM2INT(k), m_virtual_sg(dat), /* !=m_sg() */
&rjd, &ns);
if (m_local_jd(dat) != rjd)
return Qfalse;
return Qtrue;
}
|
#prev_day(n = 1) ⇒ Object
Equivalent to Date#- with argument n
.
6391 6392 6393 6394 6395 6396 6397 6398 6399 6400 |
# File 'ext/date/date_core.c', line 6391
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
Equivalent to #<< with argument n
.
6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 |
# File 'ext/date/date_core.c', line 6542
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
Equivalent to #<< with argument n * 12
.
6576 6577 6578 6579 6580 6581 6582 6583 6584 6585 |
# File 'ext/date/date_core.c', line 6576
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
Equivalent to #strftime with argument '%a, %-d %b %Y %T %z'
; see Formats for Dates and Times:
Date.new(2001, 2, 3).rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000"
7335 7336 7337 7338 7339 |
# File 'ext/date/date_core.c', line 7335
static VALUE
d_lite_rfc2822(VALUE self)
{
return strftimev("%a, %-d %b %Y %T %z", self, set_tmx);
}
|
#rfc3339 ⇒ String
Equivalent to #strftime with argument '%FT%T%:z'
; see Formats for Dates and Times:
Date.new(2001, 2, 3).rfc3339 # => "2001-02-03T00:00:00+00:00"
7319 7320 7321 7322 7323 |
# File 'ext/date/date_core.c', line 7319
static VALUE
d_lite_rfc3339(VALUE self)
{
return strftimev("%Y-%m-%dT%H:%M:%S%:z", self, set_tmx);
}
|
#rfc2822 ⇒ String
Equivalent to #strftime with argument '%a, %-d %b %Y %T %z'
; see Formats for Dates and Times:
Date.new(2001, 2, 3).rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000"
7335 7336 7337 7338 7339 |
# File 'ext/date/date_core.c', line 7335
static VALUE
d_lite_rfc2822(VALUE self)
{
return strftimev("%a, %-d %b %Y %T %z", self, set_tmx);
}
|
#saturday? ⇒ Boolean
Returns true
if self
is a Saturday, false
otherwise.
5552 5553 5554 5555 5556 5557 |
# File 'ext/date/date_core.c', line 5552
static VALUE
d_lite_saturday_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_wday(dat) == 6);
}
|
#start ⇒ Float
Returns the Julian start date for calendar reform; if not an infinity, the returned value is suitable for passing to Date#jd:
d = Date.new(2001, 2, 3, Date::ITALY)
s = d.start # => 2299161.0
Date.jd(s).to_s # => "1582-10-15"
d = Date.new(2001, 2, 3, Date::ENGLAND)
s = d.start # => 2361222.0
Date.jd(s).to_s # => "1752-09-14"
Date.new(2001, 2, 3, Date::GREGORIAN).start # => -Infinity
Date.new(2001, 2, 3, Date::JULIAN).start # => Infinity
See argument start.
5758 5759 5760 5761 5762 5763 |
# File 'ext/date/date_core.c', line 5758
static VALUE
d_lite_start(VALUE self)
{
get_d1(self);
return DBL2NUM(m_sg(dat));
}
|
#step(limit, step = 1) {|date| ... } ⇒ self
Calls the block with specified dates; returns self
.
-
The first
date
isself
. -
Each successive
date
isdate + step
, wherestep
is the numeric step size in days. -
The last date is the last one that is before or equal to
limit
, which should be a Date object.
Example:
limit = Date.new(2001, 12, 31)
Date.new(2001).step(limit){|date| p date.to_s if date.mday == 31 }
Output:
"2001-01-31"
"2001-03-31"
"2001-05-31"
"2001-07-31"
"2001-08-31"
"2001-10-31"
"2001-12-31"
Returns an Enumerator if no block is given.
6619 6620 6621 6622 6623 6624 6625 6626 6627 6628 6629 6630 6631 6632 6633 6634 6635 6636 6637 6638 6639 6640 6641 6642 6643 6644 6645 6646 6647 6648 6649 6650 6651 6652 6653 6654 6655 6656 |
# File 'ext/date/date_core.c', line 6619
static VALUE
d_lite_step(int argc, VALUE *argv, VALUE self)
{
VALUE limit, step, date;
int c;
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;
c = f_cmp(step, INT2FIX(0));
if (c < 0) {
while (FIX2INT(d_lite_cmp(date, limit)) >= 0) {
rb_yield(date);
date = d_lite_plus(date, step);
}
}
else if (c == 0) {
while (1)
rb_yield(date);
}
else /* if (c > 0) */ {
while (FIX2INT(d_lite_cmp(date, limit)) <= 0) {
rb_yield(date);
date = d_lite_plus(date, step);
}
}
return self;
}
|
#strftime(format = '%F') ⇒ String
Returns a string representation of the date in self
, formatted according the given format
:
Date.new(2001, 2, 3).strftime # => "2001-02-03"
For other formats, see Formats for Dates and Times.
7249 7250 7251 7252 7253 7254 |
# File 'ext/date/date_core.c', line 7249
static VALUE
d_lite_strftime(int argc, VALUE *argv, VALUE self)
{
return date_strftime_internal(argc, argv, self,
"%Y-%m-%d", set_tmx);
}
|
#next ⇒ Object
6413 6414 6415 6416 6417 |
# File 'ext/date/date_core.c', line 6413
static VALUE
d_lite_next(VALUE self)
{
return d_lite_next_day(0, (VALUE *)NULL, self);
}
|
#sunday? ⇒ Boolean
Returns true
if self
is a Sunday, false
otherwise.
5474 5475 5476 5477 5478 5479 |
# File 'ext/date/date_core.c', line 5474
static VALUE
d_lite_sunday_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_wday(dat) == 0);
}
|
#thursday? ⇒ Boolean
Returns true
if self
is a Thursday, false
otherwise.
5526 5527 5528 5529 5530 5531 |
# File 'ext/date/date_core.c', line 5526
static VALUE
d_lite_thursday_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_wday(dat) == 4);
}
|
#to_date ⇒ self
Returns self
.
8984 8985 8986 8987 8988 |
# File 'ext/date/date_core.c', line 8984
static VALUE
date_to_date(VALUE self)
{
return self;
}
|
#to_datetime ⇒ Object
8999 9000 9001 9002 9003 9004 9005 9006 9007 9008 9009 9010 9011 9012 9013 9014 9015 9016 9017 9018 9019 9020 9021 9022 9023 9024 9025 9026 9027 9028 9029 9030 9031 |
# File 'ext/date/date_core.c', line 8999
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
Returns a string representation of the date in self
in ISO 8601 extended date format ('%Y-%m-%d'
):
Date.new(2001, 2, 3).to_s # => "2001-02-03"
6971 6972 6973 6974 6975 |
# File 'ext/date/date_core.c', line 6971
static VALUE
d_lite_to_s(VALUE self)
{
return strftimev("%Y-%m-%d", self, set_tmx);
}
|
#to_time ⇒ Time
8961 8962 8963 8964 8965 8966 8967 8968 8969 8970 8971 8972 8973 8974 8975 8976 |
# File 'ext/date/date_core.c', line 8961
static VALUE
date_to_time(VALUE self)
{
get_d1a(self);
if (m_julian_p(adat)) {
VALUE tmp = d_lite_gregorian(self);
get_d1b(tmp);
adat = bdat;
}
return f_local3(rb_cTime,
m_real_year(adat),
INT2FIX(m_mon(adat)),
INT2FIX(m_mday(adat)));
}
|
#tuesday? ⇒ Boolean
Returns true
if self
is a Tuesday, false
otherwise.
5500 5501 5502 5503 5504 5505 |
# File 'ext/date/date_core.c', line 5500
static VALUE
d_lite_tuesday_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_wday(dat) == 2);
}
|
#upto(max) {|date| ... } ⇒ self
Equivalent to #step with arguments max
and 1
.
6664 6665 6666 6667 6668 6669 6670 6671 6672 6673 6674 6675 6676 6677 |
# File 'ext/date/date_core.c', line 6664
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 ⇒ Integer
5461 5462 5463 5464 5465 5466 |
# File 'ext/date/date_core.c', line 5461
static VALUE
d_lite_wday(VALUE self)
{
get_d1(self);
return INT2FIX(m_wday(dat));
}
|
#wednesday? ⇒ Boolean
Returns true
if self
is a Wednesday, false
otherwise.
5513 5514 5515 5516 5517 5518 |
# File 'ext/date/date_core.c', line 5513
static VALUE
d_lite_wednesday_p(VALUE self)
{
get_d1(self);
return f_boolcast(m_wday(dat) == 3);
}
|
#iso8601 ⇒ String
Equivalent to #strftime with argument '%Y-%m-%d'
(or its shorthand form '%F'
);
Date.new(2001, 2, 3).iso8601 # => "2001-02-03"
7303 7304 7305 7306 7307 |
# File 'ext/date/date_core.c', line 7303
static VALUE
d_lite_iso8601(VALUE self)
{
return strftimev("%Y-%m-%d", self, set_tmx);
}
|
#yday ⇒ Integer
5324 5325 5326 5327 5328 5329 |
# File 'ext/date/date_core.c', line 5324
static VALUE
d_lite_yday(VALUE self)
{
get_d1(self);
return INT2FIX(m_yday(dat));
}
|