class Date

Class Date provides methods for storing and manipulating calendar dates.

Consider usingclass Time instead of class Date if:

You need both dates and times; Date handles only dates.
You need only Gregorian dates (and not Julian dates); seeJulian and Gregorian Calendars.

A Date object, once created, is immutable, and cannot be modified.

Creating a Date¶↑

You can create a date for the current date, usingDate.today:

Date.today# => #<Date: 1999-12-31>

You can create a specific date from various combinations of arguments:

Date.new takes integer year, month, and day-of-month:
```
Date.new(1999,12,31)# => #<Date: 1999-12-31>
```
Date.ordinal takes integer year and day-of-year:
```
Date.ordinal(1999,365)# => #<Date: 1999-12-31>
```

Date.jd takes integer Julian day:

Date.jd(2451544)# => #<Date: 1999-12-31>

Date.commercial takes integer commercial data (year, week, day-of-week):
```
Date.commercial(1999,52,5)# => #<Date: 1999-12-31>
```

Date.parse takes a string, which it parses heuristically:

Date.parse('1999-12-31')# => #<Date: 1999-12-31>Date.parse('31-12-1999')# => #<Date: 1999-12-31>Date.parse('1999-365')# => #<Date: 1999-12-31>Date.parse('1999-W52-5')# => #<Date: 1999-12-31>

Date.strptime takes a date string and a format string, then parses the date string according to the format string:

Date.strptime('1999-12-31','%Y-%m-%d')# => #<Date: 1999-12-31>Date.strptime('31-12-1999','%d-%m-%Y')# => #<Date: 1999-12-31>Date.strptime('1999-365','%Y-%j')# => #<Date: 1999-12-31>Date.strptime('1999-W52-5','%G-W%V-%u')# => #<Date: 1999-12-31>Date.strptime('1999 52 5','%Y %U %w')# => #<Date: 1999-12-31>Date.strptime('1999 52 5','%Y %W %u')# => #<Date: 1999-12-31>Date.strptime('fri31dec99','%a%d%b%y')# => #<Date: 1999-12-31>

See also the specialized methods in“Specialized Format Strings” in Formats for Dates and Times

Argument`limit`¶↑

Certain singleton methods in Date that parse string arguments also take optional keyword argumentlimit, which can limit the length of the string argument.

Whenlimit is:

Non-negative: raisesArgumentError if the string length is greater thanlimit.
Other numeric ornil: ignoreslimit.
Other non-numeric: raisesTypeError.

Constants

ABBR_DAYNAMES: An array of strings of abbreviated day names inEnglish. The first is “Sun”.
ABBR_MONTHNAMES: An array of strings of abbreviated month names inEnglish. The first element is nil.
DAYNAMES: An array of strings of the full names of days of the week inEnglish. The first is “Sunday”.
ENGLAND: The Julian day number of the day of calendar reform for England and her colonies.
GREGORIAN: The Julian day number of the day of calendar reform for the proleptic Gregorian calendar.
ITALY: The Julian day number of the day of calendar reform for Italy and some catholic countries.
JULIAN: The Julian day number of the day of calendar reform for the proleptic Julian calendar.
MONTHNAMES: An array of strings of full month names inEnglish. The first element is nil.

Public Class Methods

_httpdate(string, limit: 128) → hash

Source

static VALUEdate_s__httpdate(int argc, VALUE *argv, VALUE klass){    VALUE str, opt;    rb_scan_args(argc, argv, "1:", &str, &opt);    if (!NIL_P(str)) str = check_limit(str, opt);    return date__httpdate(str);}

Returns a hash of values parsed fromstring, which should be a validHTTP 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).

_iso8601(string, limit: 128) → hash

Source

static VALUEdate_s__iso8601(int argc, VALUE *argv, VALUE klass){    VALUE str, opt;    rb_scan_args(argc, argv, "1:", &str, &opt);    if (!NIL_P(str)) str = check_limit(str, opt);    return date__iso8601(str);}

Returns a hash of values parsed fromstring, which should contain anISO 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 argumentlimit.

Related:Date.iso8601 (returns a Date object).

_jisx0301(string, limit: 128) → hash

Source

static VALUEdate_s__jisx0301(int argc, VALUE *argv, VALUE klass){    VALUE str, opt;    rb_scan_args(argc, argv, "1:", &str, &opt);    if (!NIL_P(str)) str = check_limit(str, opt);    return date__jisx0301(str);}

Returns a hash of values parsed fromstring, which should be a validJIS 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 argumentlimit.

Related:Date.jisx0301 (returns a Date object).

_parse(string, comp = true, limit: 128) → hash

Source

static VALUEdate_s__parse(int argc, VALUE *argv, VALUE klass){    return date_s__parse_internal(argc, argv, klass);}

Note: This method recognizes many forms instring, but it is not a validator. For formats, see“Specialized Format Strings” in Formats for Dates and Times

Ifstring does not specify a valid date, the result is unpredictable; consider usingDate._strptime instead.

Returns a hash of values parsed fromstring:

Date._parse('2001-02-03')# => {:year=>2001, :mon=>2, :mday=>3}

Ifcomp istrue 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 argumentlimit.

Related:Date.parse(returns a Date object).

_rfc2822(string, limit: 128) → hash

Source

static VALUEdate_s__rfc2822(int argc, VALUE *argv, VALUE klass){    VALUE str, opt;    rb_scan_args(argc, argv, "1:", &str, &opt);    if (!NIL_P(str)) str = check_limit(str, opt);    return date__rfc2822(str);}

Returns a hash of values parsed fromstring, which should be a validRFC 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 argumentlimit.

Related:Date.rfc2822 (returns a Date object).

_rfc3339(string, limit: 128) → hash

Source

static VALUEdate_s__rfc3339(int argc, VALUE *argv, VALUE klass){    VALUE str, opt;    rb_scan_args(argc, argv, "1:", &str, &opt);    if (!NIL_P(str)) str = check_limit(str, opt);    return date__rfc3339(str);}

Returns a hash of values parsed fromstring, which should be a validRFC 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 argumentlimit.

Related:Date.rfc3339 (returns a Date object).

_rfc2822(string, limit: 128) → hash

Source

static VALUEdate_s__rfc2822(int argc, VALUE *argv, VALUE klass){    VALUE str, opt;    rb_scan_args(argc, argv, "1:", &str, &opt);    if (!NIL_P(str)) str = check_limit(str, opt);    return date__rfc2822(str);}

Returns a hash of values parsed fromstring, which should be a validRFC 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 argumentlimit.

Related:Date.rfc2822 (returns a Date object).

_strptime(string, format = '%F') → hash

Source

static VALUEdate_s__strptime(int argc, VALUE *argv, VALUE klass){    return date_s__strptime_internal(argc, argv, klass, "%F");}

Returns a hash of values parsed fromstring according to the givenformat:

Date._strptime('2001-02-03','%Y-%m-%d')# => {:year=>2001, :mon=>2, :mday=>3}

For other formats, seeFormats for Dates and Times. (UnlikeDate.strftime, does not support flags and width.)

See alsostrptime(3).

Related:Date.strptime (returns a Date object).

_xmlschema(string, limit: 128) → hash

Source

static VALUEdate_s__xmlschema(int argc, VALUE *argv, VALUE klass){    VALUE str, opt;    rb_scan_args(argc, argv, "1:", &str, &opt);    if (!NIL_P(str)) str = check_limit(str, opt);    return date__xmlschema(str);}

Returns a hash of values parsed fromstring, which should be a valid XML date format:

d =Date.new(2001,2,3)s =d.xmlschema# => "2001-02-03"Date._xmlschema(s)# => {:year=>2001, :mon=>2, :mday=>3}

See argumentlimit.

Related:Date.xmlschema (returns a Date object).

civil(*args)

Source

static VALUEdate_s_civil(int argc, VALUE *argv, VALUE klass){    return date_initialize(argc, argv, d_lite_s_alloc_simple(klass));}

Same asDate.new.

commercial(cwyear = -4712, cweek = 1, cwday = 1, start = Date::ITALY) → date

Source

static VALUEdate_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;}

Returns a new Date object constructed from the arguments.

Argumentcwyear gives the year, and should be an integer.

Argumentcweek 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"

Argumentcwday 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"

Whencweek 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 argumentstart.

gregorian_leap?(year) → true or false

Source

static VALUEdate_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));}

Returnstrue if the given year is a leap year in theproleptic Gregorian calendar,false otherwise:

Date.gregorian_leap?(2000)# => trueDate.gregorian_leap?(2001)# => false

Related:Date.julian_leap?.

httpdate(string = 'Mon, 01 Jan -4712 00:00:00 GMT', start = Date::ITALY, limit: 128) → date

Source

static VALUEdate_s_httpdate(int argc, VALUE *argv, VALUE klass){    VALUE str, sg, opt;    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);    switch (argc) {      case 0:        str = rb_str_new2(JULIAN_EPOCH_DATETIME_HTTPDATE);      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);    }}

Returns a new Date object with values parsed fromstring, which should be a validHTTP date format:

d =Date.new(2001,2,3)s =d.httpdate# => "Sat, 03 Feb 2001 00:00:00 GMT"Date.httpdate(s)# => #<Date: 2001-02-03>

See:

Argumentstart.
Argumentlimit.

Related:Date._httpdate (returns a hash).

iso8601(string = '-4712-01-01', start = Date::ITALY, limit: 128) → date

Source

static VALUEdate_s_iso8601(int argc, VALUE *argv, VALUE klass){    VALUE str, sg, opt;    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);    switch (argc) {      case 0:        str = rb_str_new2(JULIAN_EPOCH_DATE);      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);    }}

Returns a new Date object with values parsed fromstring, which should contain anISO 8601 formatted date:

d =Date.new(2001,2,3)s =d.iso8601# => "2001-02-03"Date.iso8601(s)# => #<Date: 2001-02-03>

See:

Argumentstart.
Argumentlimit.

Related:Date._iso8601 (returns a hash).

jd(jd = 0, start = Date::ITALY) → date

Source

static VALUEdate_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;}

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 tostart:

Date::ITALY# => 2299161Date.jd(Date::ITALY).gregorian?# => trueDate.jd(Date::ITALY+1).gregorian?# => true

Julian, otherwise
```
Date.jd(Date::ITALY-1).julian?# => true
```

See argumentstart.

Related:Date.new.

jisx0301(string = '-4712-01-01', start = Date::ITALY, limit: 128) → date

Source

static VALUEdate_s_jisx0301(int argc, VALUE *argv, VALUE klass){    VALUE str, sg, opt;    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);    switch (argc) {      case 0:        str = rb_str_new2(JULIAN_EPOCH_DATE);      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);    }}

Returns a new Date object with values parsed fromstring, which should be a validJIS 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:

Argumentstart.
Argumentlimit.

Related:Date._jisx0301 (returns a hash).

json_create(object)

Source

# File ext/json/lib/json/add/date.rb, line 10defself.json_create(object)civil(*object.values_at('y','m','d','sg'))end

Seeas_json.

julian_leap?(year) → true or false

Source

static VALUEdate_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));}

Returnstrue if the given year is a leap year in theproleptic Julian calendar,false otherwise:

Date.julian_leap?(1900)# => trueDate.julian_leap?(1901)# => false

Related:Date.gregorian_leap?.

gregorian_leap?(year) → true or false

Source

static VALUEdate_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));}

Returnstrue if the given year is a leap year in theproleptic Gregorian calendar,false otherwise:

Date.gregorian_leap?(2000)# => trueDate.gregorian_leap?(2001)# => false

Related:Date.julian_leap?.

new(year = -4712, month = 1, mday = 1, start = Date::ITALY) → date

Source

static VALUEdate_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;}

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"

Argumentmonth 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"

Argumentmday should be in range (1..n) or range (-n..-1) wheren is the number of days in the month; when the argument is negative, counts backward from the end of the month.

See argumentstart.

Related:Date.jd.

ordinal(year = -4712, yday = 1, start = Date::ITALY) → date

Source

static VALUEdate_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;}

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 argumentyear, 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 argumentyday ==n, returns the date for thenth day of the given year:

Date.ordinal(2001,14).to_s# => "2001-01-14"

With negative argumentyday, counts backward from the end of the year:

Date.ordinal(2001,-14).to_s# => "2001-12-18"

Raises an exception ifyday is zero or out of range.

See argumentstart.

Related:Date.jd,Date.new.

parse(string = '-4712-01-01', comp = true, start = Date::ITALY, limit: 128) → date

Source

static VALUEdate_s_parse(int argc, VALUE *argv, VALUE klass){    VALUE str, comp, sg, opt;    argc = rb_scan_args(argc, argv, "03:", &str, &comp, &sg, &opt);    switch (argc) {      case 0:        str = rb_str_new2(JULIAN_EPOCH_DATE);      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);    }}

Note: This method recognizes many forms instring, but it is not a validator. For formats, see“Specialized Format Strings” in Formats for Dates and Times Ifstring does not specify a valid date, the result is unpredictable; consider usingDate._strptime instead.

Returns a new Date object with values parsed fromstring:

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>

Ifcomp istrue 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:

Argumentstart.
Argumentlimit.

Related:Date._parse (returns a hash).

rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000', start = Date::ITALY, limit: 128) → date

Source

static VALUEdate_s_rfc2822(int argc, VALUE *argv, VALUE klass){    VALUE str, sg, opt;    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);    switch (argc) {      case 0:        str = rb_str_new2(JULIAN_EPOCH_DATETIME_RFC3339);      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);    }}

Returns a new Date object with values parsed fromstring, which should be a validRFC 2822 date format:

d =Date.new(2001,2,3)s =d.rfc2822# => "Sat, 3 Feb 2001 00:00:00 +0000"Date.rfc2822(s)# => #<Date: 2001-02-03>

See:

Argumentstart.
Argumentlimit.

Related:Date._rfc2822 (returns a hash).

rfc3339(string = '-4712-01-01T00:00:00+00:00', start = Date::ITALY, limit: 128) → date

Source

static VALUEdate_s_rfc3339(int argc, VALUE *argv, VALUE klass){    VALUE str, sg, opt;    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);    switch (argc) {      case 0:        str = rb_str_new2(JULIAN_EPOCH_DATETIME);      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);    }}

Returns a new Date object with values parsed fromstring, which should be a validRFC 3339 format:

d =Date.new(2001,2,3)s =d.rfc3339# => "2001-02-03T00:00:00+00:00"Date.rfc3339(s)# => #<Date: 2001-02-03>

See:

Argumentstart.
Argumentlimit.

Related:Date._rfc3339 (returns a hash).

rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000', start = Date::ITALY, limit: 128) → date

Source

static VALUEdate_s_rfc2822(int argc, VALUE *argv, VALUE klass){    VALUE str, sg, opt;    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);    switch (argc) {      case 0:        str = rb_str_new2(JULIAN_EPOCH_DATETIME_RFC3339);      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);    }}

Returns a new Date object with values parsed fromstring, which should be a validRFC 2822 date format:

d =Date.new(2001,2,3)s =d.rfc2822# => "Sat, 3 Feb 2001 00:00:00 +0000"Date.rfc2822(s)# => #<Date: 2001-02-03>

See:

Argumentstart.
Argumentlimit.

Related:Date._rfc2822 (returns a hash).

strptime(string = '-4712-01-01', format = '%F', start = Date::ITALY) → date

Source

static VALUEdate_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(JULIAN_EPOCH_DATE);      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);    }}

Returns a new Date object with values parsed fromstring, according to the givenformat:

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, seeFormats for Dates and Times. (UnlikeDate.strftime, does not support flags and width.)

See argumentstart.

Public Instance Methods

d + other → date

Source

static VALUEd_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;    }}

Returns a date object pointingother 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 ...>

d - other → date or rational

Source

static VALUEd_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));    }}

If the other is a date object, returns aRational whose value is the difference between the two dates in days. If the other is a numeric value, returns a date object pointingother 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)

d << n → date

Source

static VALUEd_lite_lshift(VALUE self, VALUE other){    expect_numeric(other);    return d_lite_rshift(self, f_negate(other));}

Returns a new Date object representing the daten 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>

self <=> other → -1, 0, 1 or nil

Source

static VALUEd_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);            }        }    }}

Comparesself andother, returning:

-1 ifother is larger.
0 if the two are equal.
1 ifother is smaller.
nil if the two are incomparable.

Argumentother 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# => -1d<=>d# => 0d<=>prev_date# => 1

ADateTime object:

d<=>DateTime.new(2022,7,26)# => 1d<=>DateTime.new(2022,7,27)# => 0d<=>DateTime.new(2022,7,28)# => -1

A numeric (comparesself.ajd toother):

d<=>2459788# => -1d<=>2459787# => 1d<=>2459786# => 1d<=>d.ajd# => 0

Any other object:
```
d<=>Object.new# => nil
```

self === other → true, false, or nil.

Source

static VALUEd_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;        }    }}

Returnstrue ifself andother represent the same date,false if not,nil if the two are not comparable.

Argumentother 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# => falsed===d# => trued===next_date# => false

ADateTime object:

d===DateTime.new(2022,7,26)# => falsed===DateTime.new(2022,7,27)# => trued===DateTime.new(2022,7,28)# => false

A numeric (comparesself.jd toother):

d===2459788# => trued===2459787# => falsed===2459786# => falsed===d.jd# => true

An object not comparable:
```
d===Object.new# => nil
```

d >> n → new_date

Source

static VALUEd_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)));}

Returns a new Date object representing the daten 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>

ajd → rational

Source

static VALUEd_lite_ajd(VALUE self){    get_d1(self);    return m_ajd(dat);}

Returns the astronomical Julian day number. This is a fractional number, which is not adjusted by the offset.

DateTime.new(2001,2,3,4,5,6,'+7').ajd#=> (11769328217/4800)DateTime.new(2001,2,2,14,5,6,'-7').ajd#=> (11769328217/4800)

amjd → rational

Source

static VALUEd_lite_amjd(VALUE self){    get_d1(self);    return m_amjd(dat);}

Returns the astronomical modified Julian day number. This is a fractional number, which is not adjusted by the offset.

DateTime.new(2001,2,3,4,5,6,'+7').amjd#=> (249325817/4800)DateTime.new(2001,2,2,14,5,6,'-7').amjd#=> (249325817/4800)

as_json(*)

Source

# File ext/json/lib/json/add/date.rb, line 32defas_json(*)  {JSON.create_id=>self.class.name,'y'=>year,'m'=>month,'d'=>day,'sg'=>start,  }end

MethodsDate#as_json andDate.json_create may be used to serialize and deserialize a Date object; seeMarshal.

MethodDate#as_json serializesself, returning a 2-element hash representingself:

require'json/add/date'x =Date.today.as_json# => {"json_class"=>"Date", "y"=>2023, "m"=>11, "d"=>21, "sg"=>2299161.0}

MethodJSON.create deserializes such a hash, returning a Date object:

Date.json_create(x)# => #<Date: 2023-11-21 ((2460270j,0s,0n),+0s,2299161j)>

asctime

Source

Also aliased as:ctime

ctime

Alias for:asctime

cwday → integer

Source

static VALUEd_lite_cwday(VALUE self){    get_d1(self);    return INT2FIX(m_cwday(dat));}

Returns the commercial-date weekday index forself (seeDate.commercial); 1 is Monday:

Date.new(2001,2,3).cwday# => 6

cweek → integer

Source

static VALUEd_lite_cweek(VALUE self){    get_d1(self);    return INT2FIX(m_cweek(dat));}

Returns commercial-date week index forself (seeDate.commercial):

Date.new(2001,2,3).cweek# => 5

cwyear → integer

Source

static VALUEd_lite_cwyear(VALUE self){    get_d1(self);    return m_real_cwyear(dat);}

Returns commercial-date year forself (seeDate.commercial):

Date.new(2001,2,3).cwyear# => 2001Date.new(2000,1,1).cwyear# => 1999

day

Alias for:mday

day_fraction → rational

Source

static VALUEd_lite_day_fraction(VALUE self){    get_d1(self);    if (simple_dat_p(dat))        return INT2FIX(0);    return m_fr(dat);}

Returns the fractional part of the day in range (Rational(0, 1)…Rational(1, 1)):

DateTime.new(2001,2,3,12).day_fraction# => (1/2)

deconstruct_keys(array_of_names_or_nil) → hash

Source

static VALUEd_lite_deconstruct_keys(VALUE self, VALUE keys){    return deconstruct_keys(self, keys, /* is_datetime=false */ 0);}

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)ifdinwday:3,day:..7# uses deconstruct_keys underneathputs"first Wednesday of the month"end#=> prints "first Wednesday of the month"casedinyear:...2022puts"too old"inmonth:..9puts"quarter 1-3"inwday: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:

ifdinDate(wday:3,day:..7)puts"first Wednesday of the month"end

downto(min){|date| ... } → self

Source

static VALUEd_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;}

Equivalent tostep with argumentsmin and-1.

england → new_date

Source

static VALUEd_lite_england(VALUE self){    return dup_obj_with_new_start(self, ENGLAND);}

Equivalent toDate#new_start with argumentDate::ENGLAND.

friday? → true or false

Source

static VALUEd_lite_friday_p(VALUE self){    get_d1(self);    return f_boolcast(m_wday(dat) == 5);}

Returnstrue ifself is a Friday,false otherwise.

gregorian → new_date

Source

static VALUEd_lite_gregorian(VALUE self){    return dup_obj_with_new_start(self, GREGORIAN);}

Equivalent toDate#new_start with argumentDate::GREGORIAN.

gregorian? → true or false

Source

static VALUEd_lite_gregorian_p(VALUE self){    get_d1(self);    return f_boolcast(m_gregorian_p(dat));}

Returnstrue if the date is on or after the date of calendar reform,false otherwise:

Date.new(1582,10,15).gregorian?# => true(Date.new(1582,10,15)-1).gregorian?# => false

httpdate → string

Source

static VALUEd_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);}

Equivalent tostrftime with argument'%a, %d %b %Y %T GMT'; seeFormats for Dates and Times:

Date.new(2001,2,3).httpdate# => "Sat, 03 Feb 2001 00:00:00 GMT"

infinite? → false

Source

# File ext/date/lib/date.rb, line 13definfinite?falseend

Returnsfalse

inspect → string

Source

static VALUEd_lite_inspect(VALUE self){    get_d1(self);    return mk_inspect(dat, rb_obj_class(self), self);}

Returns a string representation ofself:

Date.new(2001,2,3).inspect# => "#<Date: 2001-02-03 ((2451944j,0s,0n),+0s,2299161j)>"

iso8601 → string

Source

static VALUEd_lite_iso8601(VALUE self){    return strftimev("%Y-%m-%d", self, set_tmx);}

Equivalent tostrftime with argument'%Y-%m-%d' (or itsshorthand form'%F');

Date.new(2001,2,3).iso8601# => "2001-02-03"

Also aliased as:xmlschema

italy → new_date

Source

static VALUEd_lite_italy(VALUE self){    return dup_obj_with_new_start(self, ITALY);}

Equivalent toDate#new_start with argumentDate::ITALY.

jd → integer

Source

static VALUEd_lite_jd(VALUE self){    get_d1(self);    return m_real_local_jd(dat);}

Returns the Julian day number. This is a whole number, which is adjusted by the offset as the local time.

DateTime.new(2001,2,3,4,5,6,'+7').jd#=> 2451944DateTime.new(2001,2,3,4,5,6,'-7').jd#=> 2451944

jisx0301 → string

Source

static VALUEd_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);}

Returns a string representation of the date inself in JIS X 0301 format.

Date.new(2001,2,3).jisx0301# => "H13.02.03"

julian → new_date

Source

static VALUEd_lite_julian(VALUE self){    return dup_obj_with_new_start(self, JULIAN);}

Equivalent toDate#new_start with argumentDate::JULIAN.

julian? → true or false

Source

static VALUEd_lite_julian_p(VALUE self){    get_d1(self);    return f_boolcast(m_julian_p(dat));}

Returnstrue if the date is before the date of calendar reform,false otherwise:

(Date.new(1582,10,15)-1).julian?# => trueDate.new(1582,10,15).julian?# => false

ld → integer

Source

static VALUEd_lite_ld(VALUE self){    get_d1(self);    return f_sub(m_real_local_jd(dat), INT2FIX(2299160));}

Returns theLilian 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

leap? → true or false

Source

static VALUEd_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);}

Returnstrue if the year is a leap year,false otherwise:

Date.new(2000).leap?# => trueDate.new(2001).leap?# => false

mday

Source

Also aliased as:day

mjd → integer

Source

static VALUEd_lite_mjd(VALUE self){    get_d1(self);    return f_sub(m_real_local_jd(dat), INT2FIX(2400001));}

Returns the modified Julian day number. This is a whole number, which is adjusted by the offset as the local time.

DateTime.new(2001,2,3,4,5,6,'+7').mjd#=> 51943DateTime.new(2001,2,3,4,5,6,'-7').mjd#=> 51943

mon → integer

Source

static VALUEd_lite_mon(VALUE self){    get_d1(self);    return INT2FIX(m_mon(dat));}

Returns the month in range (1..12):

Date.new(2001,2,3).mon# => 2

Also aliased as:month

monday? → true or false

Source

static VALUEd_lite_monday_p(VALUE self){    get_d1(self);    return f_boolcast(m_wday(dat) == 1);}

Returnstrue ifself is a Monday,false otherwise.

month

Alias for:mon

new_start(start = Date::ITALY]) → new_date

Source

static VALUEd_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);}

Returns a copy ofself with the givenstart value:

d0 =Date.new(2000,2,3)d0.julian?# => falsed1 =d0.new_start(Date::JULIAN)d1.julian?# => true

See argumentstart.

next → new_date

Source

static VALUEd_lite_next(VALUE self){    return d_lite_next_day(0, (VALUE *)NULL, self);}

Returns a new Date object representing the following day:

d =Date.new(2001,2,3)d.to_s# => "2001-02-03"d.next.to_s# => "2001-02-04"

Also aliased as:succ

next_day(n = 1) → new_date

Source

static VALUEd_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);}

Equivalent toDate#+ with argumentn.

next_month(n = 1) → new_date

Source

static VALUEd_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);}

Equivalent to>> with argumentn.

next_year(n = 1) → new_date

Source

static VALUEd_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)));}

Equivalent to>> with argumentn * 12.

prev_day(n = 1) → new_date

Source

static VALUEd_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);}

Equivalent toDate#- with argumentn.

prev_month(n = 1) → new_date

Source

static VALUEd_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);}

Equivalent to<< with argumentn.

prev_year(n = 1) → new_date

Source

static VALUEd_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)));}

Equivalent to<< with argumentn * 12.

rfc2822 → string

Source

static VALUEd_lite_rfc2822(VALUE self){    return strftimev("%a, %-d %b %Y %T %z", self, set_tmx);}

Equivalent tostrftime with argument'%a, %-d %b %Y %T %z'; seeFormats for Dates and Times:

Date.new(2001,2,3).rfc2822# => "Sat, 3 Feb 2001 00:00:00 +0000"

Also aliased as:rfc822, rfc822

rfc3339 → string

Source

static VALUEd_lite_rfc3339(VALUE self){    return strftimev("%Y-%m-%dT%H:%M:%S%:z", self, set_tmx);}

Equivalent tostrftime with argument'%FT%T%:z'; seeFormats for Dates and Times:

Date.new(2001,2,3).rfc3339# => "2001-02-03T00:00:00+00:00"

rfc822

Alias for:rfc2822

saturday? → true or false

Source

static VALUEd_lite_saturday_p(VALUE self){    get_d1(self);    return f_boolcast(m_wday(dat) == 6);}

Returnstrue ifself is a Saturday,false otherwise.

start → float

Source

static VALUEd_lite_start(VALUE self){    get_d1(self);    return DBL2NUM(m_sg(dat));}

Returns the Julian start date for calendar reform; if not an infinity, the returned value is suitable for passing toDate#jd:

d =Date.new(2001,2,3,Date::ITALY)s =d.start# => 2299161.0Date.jd(s).to_s# => "1582-10-15"d =Date.new(2001,2,3,Date::ENGLAND)s =d.start# => 2361222.0Date.jd(s).to_s# => "1752-09-14"Date.new(2001,2,3,Date::GREGORIAN).start# => -InfinityDate.new(2001,2,3,Date::JULIAN).start# => Infinity

See argumentstart.

step(limit, step = 1){|date| ... } → self

Source

static VALUEd_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;}

Calls the block with specified dates; returnsself.

The firstdate isself.
Each successivedate isdate + step, wherestep is the numeric step size in days.
The last date is the last one that is before or equal tolimit, which should be a Date object.

Example:

limit =Date.new(2001,12,31)Date.new(2001).step(limit){|date|pdate.to_sifdate.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 anEnumerator if no block is given.

strftime(format = '%F') → string

Source

static VALUEd_lite_strftime(int argc, VALUE *argv, VALUE self){    return date_strftime_internal(argc, argv, self,                                  "%Y-%m-%d", set_tmx);}

Returns a string representation of the date inself, formatted according the givenformat:

Date.new(2001,2,3).strftime# => "2001-02-03"

For other formats, seeFormats for Dates and Times.

succ

Alias for:next

sunday? → true or false

Source

static VALUEd_lite_sunday_p(VALUE self){    get_d1(self);    return f_boolcast(m_wday(dat) == 0);}

Returnstrue ifself is a Sunday,false otherwise.

thursday? → true or false

Source

static VALUEd_lite_thursday_p(VALUE self){    get_d1(self);    return f_boolcast(m_wday(dat) == 4);}

Returnstrue ifself is a Thursday,false otherwise.

to_date → self

Source

static VALUEdate_to_date(VALUE self){    return self;}

Returnsself.

to_datetime → datetime

Source

static VALUEdate_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;        }    }}

Returns aDateTime whose value is the same asself:

Date.new(2001,2,3).to_datetime# => #<DateTime: 2001-02-03T00:00:00+00:00>

to_json(*args)

Source

# File ext/json/lib/json/add/date.rb, line 51defto_json(*args)as_json.to_json(*args)end

Returns aJSON string representingself:

require'json/add/date'putsDate.today.to_json

Output:

{"json_class":"Date","y":2023,"m":11,"d":21,"sg":2299161.0}

to_s → string

Source

static VALUEd_lite_to_s(VALUE self){    return strftimev("%Y-%m-%d", self, set_tmx);}

Returns a string representation of the date inself inISO 8601 extended date format ('%Y-%m-%d'):

Date.new(2001,2,3).to_s# => "2001-02-03"

to_time → time

Source

static VALUEdate_to_time(VALUE self){    VALUE t;    get_d1a(self);    if (m_julian_p(adat)) {        VALUE g = d_lite_gregorian(self);        get_d1b(g);        adat = bdat;        self = g;    }    t = f_local3(rb_cTime,        m_real_year(adat),        INT2FIX(m_mon(adat)),        INT2FIX(m_mday(adat)));    RB_GC_GUARD(self); /* may be the converted gregorian */    return t;}

Returns a newTime object with the same value asself; ifself is a Julian date, derives its Gregorian date for conversion to the Time object:

Date.new(2001,2,3).to_time# => 2001-02-03 00:00:00 -0600Date.new(2001,2,3,Date::JULIAN).to_time# => 2001-02-16 00:00:00 -0600

tuesday? → true or false

Source

static VALUEd_lite_tuesday_p(VALUE self){    get_d1(self);    return f_boolcast(m_wday(dat) == 2);}

Returnstrue ifself is a Tuesday,false otherwise.

upto(max){|date| ... } → self

Source

static VALUEd_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;}

Equivalent tostep with argumentsmax and1.

wday → integer

Source

static VALUEd_lite_wday(VALUE self){    get_d1(self);    return INT2FIX(m_wday(dat));}

Returns the day of week in range (0..6); Sunday is 0:

Date.new(2001,2,3).wday# => 6

wednesday? → true or false

Source

static VALUEd_lite_wednesday_p(VALUE self){    get_d1(self);    return f_boolcast(m_wday(dat) == 3);}

Returnstrue ifself is a Wednesday,false otherwise.

xmlschema

Alias for:iso8601

yday → integer

Source

static VALUEd_lite_yday(VALUE self){    get_d1(self);    return INT2FIX(m_yday(dat));}

Returns the day of the year, in range (1..366):

Date.new(2001,2,3).yday# => 34

year → integer

Source

static VALUEd_lite_year(VALUE self){    get_d1(self);    return m_real_year(dat);}

Returns the year:

Date.new(2001,2,3).year# => 2001(Date.new(1,1,1)-1).year# => 0

Movatterモバイル変換

class Date

Creating a Date¶↑

Argumentlimit¶↑

Argument`limit`¶↑