Class: Date

Inherits:

Object

Object
Date

show all

Includes:: Comparable

Defined in:: lib/date.rb,
ext/date/date_core.c

Direct Known Subclasses

DateTime

Defined Under Namespace

Classes: Error, Infinity

Constant Summary collapse

VERSION = :nodoc:

'3.2.2'

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 parsed elements.
._iso8601(string, limit: 128) ⇒ Hash

Returns a hash of parsed elements.
._jisx0301(string, limit: 128) ⇒ Hash

Returns a hash of parsed elements.
._load(s) ⇒ Object

:nodoc:.
._parse(string[, comp = true], limit: 128) ⇒ Hash

Parses the given representation of date and time, and returns a hash of parsed elements.
._rfc2822(*args) ⇒ Object

Returns a hash of parsed elements.
._rfc3339(string, limit: 128) ⇒ Hash

Returns a hash of parsed elements.
._rfc822(*args) ⇒ Object

Returns a hash of parsed elements.
._strptime(string[, format = '%F']) ⇒ Hash

Parses the given representation of date and time with the given template, and returns a hash of parsed elements.
._xmlschema(string, limit: 128) ⇒ Hash

Returns a hash of parsed elements.
.civil(*args) ⇒ Object

Creates a date object denoting the given calendar date.
.commercial([cwyear = -4712[, cweek=1[, cwday=1[, start=Date::ITALY]]]]) ⇒ Object

Creates a date object denoting the given week date.
.gregorian_leap?(y) ⇒ Object

Returns true if the given year is a leap year of the proleptic Gregorian calendar.
.httpdate(string = 'Mon, 01 Jan -4712 00:00:00 GMT'[, start=Date::ITALY], limit: 128) ⇒ Object

Creates a new Date object by parsing from a string according to some RFC 2616 format.
.iso8601(string = '-4712-01-01'[, start=Date::ITALY], limit: 128) ⇒ Object

Creates a new Date object by parsing from a string according to some typical ISO 8601 formats.
.jd([jd = 0[, start=Date::ITALY]]) ⇒ Object

Creates a date object denoting the given chronological Julian day number.
.jisx0301(string = '-4712-01-01'[, start=Date::ITALY], limit: 128) ⇒ Object

Creates a new Date object by parsing from a string according to some typical JIS X 0301 formats.
.julian_leap?(year) ⇒ Boolean

Returns true if the given year is a leap year of the proleptic Julian calendar.
.leap?(y) ⇒ Object

Returns true if the given year is a leap year of the proleptic Gregorian calendar.
.new!(*args) ⇒ Object
.nth_kday(*args) ⇒ Object
.ordinal([year = -4712[, yday=1[, start=Date::ITALY]]]) ⇒ Object

Creates a date object denoting the given ordinal date.
.parse(string = '-4712-01-01'[, comp=true[, start=Date::ITALY]], limit: 128) ⇒ Object

Parses the given representation of date and time, and creates a date object.
.rfc2822(*args) ⇒ Object

Creates a new Date object by parsing from a string according to some typical RFC 2822 formats.
.rfc3339(string = '-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ Object

Creates a new Date object by parsing from a string according to some typical RFC 3339 formats.
.rfc822(*args) ⇒ Object

Creates a new Date object by parsing from a string according to some typical RFC 2822 formats.
.strptime([string = '-4712-01-01'[, format='%F'[, start=Date::ITALY]]]) ⇒ Object

Parses the given representation of date and time with the given template, and creates a date object.
.test_all ⇒ Object
.test_civil ⇒ Object

tests.
.test_commercial ⇒ Object
.test_nth_kday ⇒ Object
.test_ordinal ⇒ Object
.test_unit_conv ⇒ Object
.test_weeknum ⇒ Object
.today([start = Date::ITALY]) ⇒ Object

Creates a date object denoting the present day.
.valid_civil?(*args) ⇒ Object

Returns true if the given calendar date is valid, and false if not.
.valid_commercial?(cwyear, cweek, cwday[, start = Date::ITALY]) ⇒ Boolean

Returns true if the given week date is valid, and false if not.
.valid_date?(*args) ⇒ Object

Returns true if the given calendar date is valid, and false if not.
.valid_jd?(jd[, start = Date::ITALY]) ⇒ Boolean

Just returns true.
.valid_ordinal?(year, yday[, start = Date::ITALY]) ⇒ Boolean

Returns true if the given ordinal date is valid, and false if not.
.weeknum(*args) ⇒ Object
.xmlschema(string = '-4712-01-01'[, start=Date::ITALY], limit: 128) ⇒ Object

Creates a new Date object by parsing from a string according to some typical XML Schema formats.

Instance Method Summary collapse

#+(other) ⇒ Object

Returns a date object pointing other days after self.
#-(other) ⇒ Object

Returns the difference between the two dates if the other is a date object.
#<<(n) ⇒ Object

Returns a date object pointing n months before self.
#<=>(other) ⇒ -1, ...

Compares the two dates and returns -1, zero, 1 or nil.
#===(other) ⇒ Boolean

Returns true if they are the same day.
#>>(n) ⇒ Object

Returns a date object pointing n months after self.
#ajd ⇒ Object

Returns the astronomical Julian day number.
#amjd ⇒ Object

Returns the astronomical modified Julian day number.
#asctime ⇒ Object

Returns a string in asctime(3) format (but without “n0” at the end).
#ctime ⇒ Object

Returns a string in asctime(3) format (but without “n0” at the end).
#cwday ⇒ Fixnum

Returns the day of calendar week (1-7, Monday is 1).
#cweek ⇒ Fixnum

Returns the calendar week number (1-53).
#cwyear ⇒ Integer

Returns the calendar week based year.
#day ⇒ Object

Returns the day of the month (1-31).
#day_fraction ⇒ Object

Returns the fractional part of the day.
#downto(min) ⇒ Object

This method is equivalent to step(min, -1){|date| …}.
#england ⇒ Object

This method is equivalent to new_start(Date::ENGLAND).
#eql?(other) ⇒ Boolean

:nodoc:.
#fill ⇒ Object
#friday? ⇒ Boolean

Returns true if the date is Friday.
#gregorian ⇒ Object

This method is equivalent to new_start(Date::GREGORIAN).
#gregorian? ⇒ Boolean

Returns true if the date is on or after the day of calendar reform.
#hash ⇒ Object

:nodoc:.
#httpdate ⇒ String

This method is equivalent to strftime(‘%a, %d %b %Y %T GMT’).
#infinite? ⇒ Boolean
#initialize(*args) ⇒ Object constructor
#initialize_copy(date) ⇒ Object

:nodoc:.
#inspect ⇒ String

Returns the value as a string for inspection.
#inspect_raw ⇒ Object
#iso8601 ⇒ Object

This method is equivalent to strftime(‘%F’).
#italy ⇒ Object

This method is equivalent to new_start(Date::ITALY).
#jd ⇒ Integer

Returns the Julian day number.
#jisx0301 ⇒ String

Returns a string in a JIS X 0301 format.
#julian ⇒ Object

This method is equivalent to new_start(Date::JULIAN).
#julian? ⇒ Boolean

Returns true if the date is before the day of calendar reform.
#ld ⇒ Integer

Returns the Lilian day number.
#leap? ⇒ Boolean

Returns true if the year is a leap year.
#marshal_dump ⇒ Object

:nodoc:.
#marshal_dump_old ⇒ Object
#marshal_load(a) ⇒ Object

:nodoc:.
#mday ⇒ Object

Returns the day of the month (1-31).
#mjd ⇒ Integer

Returns the modified Julian day number.
#mon ⇒ Object

Returns the month (1-12).
#monday? ⇒ Boolean

Returns true if the date is Monday.
#month ⇒ Object

Returns the month (1-12).
#new_start([start = Date::ITALY]) ⇒ Object

Duplicates self and resets its day of calendar reform.
#next ⇒ Object

Returns a date object denoting the following day.
#next_day([n = 1]) ⇒ Object

This method is equivalent to d + n.
#next_month([n = 1]) ⇒ Object

This method is equivalent to d >> n.
#next_year([n = 1]) ⇒ Object

This method is equivalent to d >> (n * 12).
#nth_kday?(n, k) ⇒ Boolean
#prev_day([n = 1]) ⇒ Object

This method is equivalent to d - n.
#prev_month([n = 1]) ⇒ Object

This method is equivalent to d << n.
#prev_year([n = 1]) ⇒ Object

This method is equivalent to d << (n * 12).
#rfc2822 ⇒ Object

This method is equivalent to strftime(‘%a, %-d %b %Y %T %z’).
#rfc3339 ⇒ String

This method is equivalent to strftime(‘%FT%T%:z’).
#rfc822 ⇒ Object

This method is equivalent to strftime(‘%a, %-d %b %Y %T %z’).
#saturday? ⇒ Boolean

Returns true if the date is Saturday.
#start ⇒ Float

Returns the Julian day number denoting the day of calendar reform.
#step(*args) ⇒ Object

Iterates evaluation of the given block, which takes a date object.
#strftime([format = '%F']) ⇒ String

Formats date according to the directives in the given format string.
#succ ⇒ Object

Returns a date object denoting the following day.
#sunday? ⇒ Boolean

Returns true if the date is Sunday.
#thursday? ⇒ Boolean

Returns true if the date is Thursday.
#to_date ⇒ self

Returns self.
#to_datetime ⇒ Object

Returns a DateTime object which denotes self.
#to_s ⇒ String

Returns a string in an ISO 8601 format.
#to_time ⇒ Time

Returns a Time object which denotes self.
#tuesday? ⇒ Boolean

Returns true if the date is Tuesday.
#upto(max) ⇒ Object

This method is equivalent to step(max, 1){|date| …}.
#wday ⇒ Fixnum

Returns the day of week (0-6, Sunday is zero).
#wednesday? ⇒ Boolean

Returns true if the date is Wednesday.
#xmlschema ⇒ Object

This method is equivalent to strftime(‘%F’).
#yday ⇒ Fixnum

Returns the day of the year (1-366).
#year ⇒ Integer

Returns the year.

Constructor Details

#initialize(*args) ⇒ `Object`

# File 'ext/date/date_core.c', line 3422

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 parsed elements.

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

Returns:

(Hash)

# File 'ext/date/date_core.c', line 4714

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 parsed elements.

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

Returns:

(Hash)

# File 'ext/date/date_core.c', line 4474

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 parsed elements.

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

Returns:

(Hash)

# File 'ext/date/date_core.c', line 4773

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:

# File 'ext/date/date_core.c', line 7386

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`

Parses the given representation of date and time, and returns a hash of parsed elements.

This method *does not* function as a validator. If the input string does not match valid formats strictly, you may get a cryptic result. Should consider to use ‘Date._strptime` or `DateTime._strptime` instead of this method as possible.

If the optional second argument is true and the detected year is in the range “00” to “99”, considers the year a 2-digit form and makes it full.

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

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

Returns:

(Hash)

# File 'ext/date/date_core.c', line 4399

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

._rfc2822(string, limit: 128) ⇒ `Hash` ._rfc822(string, limit: 128) ⇒ `Hash`

Returns a hash of parsed elements.

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

Overloads:

._rfc2822(string, limit: 128) ⇒ Hash
Returns:
- (Hash)
._rfc822(string, limit: 128) ⇒ Hash
Returns:
- (Hash)

# File 'ext/date/date_core.c', line 4654

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 parsed elements.

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

Returns:

(Hash)

# File 'ext/date/date_core.c', line 4535

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` ._rfc822(string, limit: 128) ⇒ `Hash`

Returns a hash of parsed elements.

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

Overloads:

._rfc2822(string, limit: 128) ⇒ Hash
Returns:
- (Hash)
._rfc822(string, limit: 128) ⇒ Hash
Returns:
- (Hash)

# File 'ext/date/date_core.c', line 4654

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`

Parses the given representation of date and time with the given template, and returns a hash of parsed elements. _strptime does not support specification of flags and width unlike strftime.

Date._strptime('2001-02-03', '%Y-%m-%d')

#=> :mon=>2, :mday=>3

._xmlschema(string, limit: 128) ⇒ `Hash`

Returns a hash of parsed elements.

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

Returns:

(Hash)

# File 'ext/date/date_core.c', line 4594

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([year = -4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ `Object` .new([year = -4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ `Object`

Creates a date object denoting the given calendar date.

In this class, BCE years are counted astronomically. Thus, the year before the year 1 is the year zero, and the year preceding the year zero is the year -1. The month and the day of month should be a negative or a positive number (as a relative month/day from the end of year/month when negative). They should not be zero.

The last argument should be a Julian day number which denotes the day of calendar reform. Date::ITALY (2299161=1582-10-15), Date::ENGLAND (2361222=1752-09-14), Date::GREGORIAN (the proleptic Gregorian calendar) and Date::JULIAN (the proleptic Julian calendar) can be specified as a day of calendar reform.

Date.new(2001)    #=> #<Date: 2001-01-01 ...>
Date.new(2001,2,3)  #=> #<Date: 2001-02-03 ...>
Date.new(2001,2,-1) #=> #<Date: 2001-02-28 ...>

.commercial([cwyear = -4712[, cweek=1[, cwday=1[, start=Date::ITALY]]]]) ⇒ `Object`

Creates a date object denoting the given week date.

The week and the day of week should be a negative or a positive number (as a relative week/day from the end of year/week when negative). They should not be zero.

Date.commercial(2001) #=> #<Date: 2001-01-01 ...>
Date.commercial(2002) #=> #<Date: 2001-12-31 ...>
Date.commercial(2001,5,6) #=> #<Date: 2001-02-03 ...>

.gregorian_leap?(year) ⇒ `Boolean` .leap?(year) ⇒ `Boolean`

Returns true if the given year is a leap year of the proleptic Gregorian calendar.

Date.gregorian_leap?(1900)  #=> false
Date.gregorian_leap?(2000)  #=> true

Overloads:

.gregorian_leap?(year) ⇒ Boolean
Returns:
- (Boolean)
.leap?(year) ⇒ Boolean
Returns:
- (Boolean)

# File 'ext/date/date_core.c', line 2946

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`

Creates a new Date object by parsing from a string according to some RFC 2616 format.

Date.httpdate('Sat, 03 Feb 2001 00:00:00 GMT')

#=> #<Date: 2001-02-03 …>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

# File 'ext/date/date_core.c', line 4739

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];
        argv2[0] = str;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
  VALUE 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`

Creates a new Date object by parsing from a string according to some typical ISO 8601 formats.

Date.iso8601('2001-02-03')  #=> #<Date: 2001-02-03 ...>
Date.iso8601('20010203')    #=> #<Date: 2001-02-03 ...>
Date.iso8601('2001-W05-6')  #=> #<Date: 2001-02-03 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

# File 'ext/date/date_core.c', line 4500

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];
        argv2[0] = str;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
  VALUE hash = date_s__iso8601(argc2, argv2, klass);
  return d_new_by_frags(klass, hash, sg);
    }
}

.jd([jd = 0[, start=Date::ITALY]]) ⇒ `Object`

Creates a date object denoting the given chronological Julian day number.

Date.jd(2451944)    #=> #<Date: 2001-02-03 ...>
Date.jd(2451945)    #=> #<Date: 2001-02-04 ...>
Date.jd(0)    #=> #<Date: -4712-01-01 ...>

.jisx0301(string = '-4712-01-01'[, start=Date::ITALY], limit: 128) ⇒ `Object`

Creates a new Date object by parsing from a string according to some typical JIS X 0301 formats.

Date.jisx0301('H13.02.03')    #=> #<Date: 2001-02-03 ...>

For no-era year, legacy format, Heisei is assumed.

Date.jisx0301('13.02.03')     #=> #<Date: 2001-02-03 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

# File 'ext/date/date_core.c', line 4801

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];
        argv2[0] = str;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
  VALUE 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 of the proleptic Julian calendar.

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

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 2924

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` .leap?(year) ⇒ `Boolean`

Returns true if the given year is a leap year of the proleptic Gregorian calendar.

Date.gregorian_leap?(1900)  #=> false
Date.gregorian_leap?(2000)  #=> true

Overloads:

.gregorian_leap?(year) ⇒ Boolean
Returns:
- (Boolean)
.leap?(year) ⇒ Boolean
Returns:
- (Boolean)

# File 'ext/date/date_core.c', line 2946

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`

# File 'ext/date/date_core.c', line 3097

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`

# File 'ext/date/date_core.c', line 3599

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`

Creates a date object denoting the given ordinal date.

The day of year should be a negative or a positive number (as a relative day from the end of year when negative). It should not be zero.

Date.ordinal(2001)  #=> #<Date: 2001-01-01 ...>
Date.ordinal(2001,34) #=> #<Date: 2001-02-03 ...>
Date.ordinal(2001,-1) #=> #<Date: 2001-12-31 ...>

.parse(string = '-4712-01-01'[, comp=true[, start=Date::ITALY]], limit: 128) ⇒ `Object`

Parses the given representation of date and time, and creates a date object.

This method *does not* function as a validator. If the input string does not match valid formats strictly, you may get a cryptic result. Should consider to use ‘Date.strptime` instead of this method as possible.

If the optional second argument is true and the detected year is in the range “00” to “99”, considers the year a 2-digit form and makes it full.

Date.parse('2001-02-03')    #=> #<Date: 2001-02-03 ...>
Date.parse('20010203')    #=> #<Date: 2001-02-03 ...>
Date.parse('3rd Feb 2001')  #=> #<Date: 2001-02-03 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

# File 'ext/date/date_core.c', line 4429

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];
        argv2[0] = str;
        argv2[1] = comp;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
  VALUE 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` .rfc822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `Object`

Creates a new Date object by parsing from a string according to some typical RFC 2822 formats.

Date.rfc2822('Sat, 3 Feb 2001 00:00:00 +0000')

#=> #<Date: 2001-02-03 …>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

# File 'ext/date/date_core.c', line 4680

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];
        argv2[0] = str;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
  VALUE 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`

Creates a new Date object by parsing from a string according to some typical RFC 3339 formats.

Date.rfc3339('2001-02-03T04:05:06+07:00') #=> #<Date: 2001-02-03 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

# File 'ext/date/date_core.c', line 4559

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];
        argv2[0] = str;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
  VALUE 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` .rfc822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `Object`

Creates a new Date object by parsing from a string according to some typical RFC 2822 formats.

Date.rfc2822('Sat, 3 Feb 2001 00:00:00 +0000')

#=> #<Date: 2001-02-03 …>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

# File 'ext/date/date_core.c', line 4680

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];
        argv2[0] = str;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
  VALUE 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`

Parses the given representation of date and time with the given template, and creates a date object. strptime does not support specification of flags and width unlike strftime.

Date.strptime('2001-02-03', '%Y-%m-%d') #=> #<Date: 2001-02-03 ...>
Date.strptime('03-02-2001', '%d-%m-%Y') #=> #<Date: 2001-02-03 ...>
Date.strptime('2001-034', '%Y-%j')  #=> #<Date: 2001-02-03 ...>
Date.strptime('2001-W05-6', '%G-W%V-%u')  #=> #<Date: 2001-02-03 ...>
Date.strptime('2001 04 6', '%Y %U %w')  #=> #<Date: 2001-02-03 ...>
Date.strptime('2001 05 6', '%Y %W %u')  #=> #<Date: 2001-02-03 ...>
Date.strptime('sat3feb01', '%a%d%b%y')  #=> #<Date: 2001-02-03 ...>

.test_all ⇒ `Object`

# File 'ext/date/date_core.c', line 9261

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`

tests

# File 'ext/date/date_core.c', line 9010

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`

# File 'ext/date/date_core.c', line 9090

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`

# File 'ext/date/date_core.c', line 9174

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`

# File 'ext/date/date_core.c', line 9050

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`

# File 'ext/date/date_core.c', line 9247

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`

# File 'ext/date/date_core.c', line 9130

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`

Creates a date object denoting the present day.

Date.today   #=> #<Date: 2011-06-11 ...>

# File 'ext/date/date_core.c', line 3679

static VALUE
date_s_today(int argc, VALUE *argv, VALUE klass)
{
    VALUE vsg, nth, ret;
    double sg;
    time_t t;
    struct tm tm;
    int y, ry, m, d;

    rb_scan_args(argc, argv, "01", &vsg);

    if (argc < 1)
  sg = DEFAULT_SG;
    else
  val2sg(vsg, sg);

    if (time(&t) == -1)
  rb_sys_fail("time");
    tzset();
    if (!localtime_r(&t, &tm))
  rb_sys_fail("localtime");

    y = tm.tm_year + 1900;
    m = tm.tm_mon + 1;
    d = tm.tm_mday;

    decode_year(INT2FIX(y), -1, &nth, &ry);

    ret = d_simple_new_internal(klass,
        nth, 0,
        GREGORIAN,
        ry, m, d,
        HAVE_CIVIL);
    {
  get_d1(ret);
  set_sg(dat, sg);
    }
    return ret;
}

.valid_civil?(year, month, mday[, start = Date::ITALY]) ⇒ `Boolean` .valid_date?(year, month, mday[, start = Date::ITALY]) ⇒ `Boolean`

Returns true if the given calendar date is valid, and false if not. Valid in this context is whether the arguments passed to this method would be accepted by ::new.

Date.valid_date?(2001,2,3)  #=> true
Date.valid_date?(2001,2,29) #=> false
Date.valid_date?(2001,2,-1) #=> true

.valid_commercial?(cwyear, cweek, cwday[, start = Date::ITALY]) ⇒ `Boolean`

Returns true if the given week date is valid, and false if not.

Date.valid_commercial?(2001,5,6)  #=> true
Date.valid_commercial?(2001,5,8)  #=> false

.valid_civil?(year, month, mday[, start = Date::ITALY]) ⇒ `Boolean` .valid_date?(year, month, mday[, start = Date::ITALY]) ⇒ `Boolean`

Returns true if the given calendar date is valid, and false if not. Valid in this context is whether the arguments passed to this method would be accepted by ::new.

Date.valid_date?(2001,2,3)  #=> true
Date.valid_date?(2001,2,29) #=> false
Date.valid_date?(2001,2,-1) #=> true

.valid_jd?(jd[, start = Date::ITALY]) ⇒ `Boolean`

Just returns true. It’s nonsense, but is for symmetry.

Date.valid_jd?(2451944)   #=> true

.valid_ordinal?(year, yday[, start = Date::ITALY]) ⇒ `Boolean`

Returns true if the given ordinal date is valid, and false if not.

Date.valid_ordinal?(2001,34)  #=> true
Date.valid_ordinal?(2001,366) #=> false

.weeknum(*args) ⇒ `Object`

# File 'ext/date/date_core.c', line 3550

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`

Creates a new Date object by parsing from a string according to some typical XML Schema formats.

Date.xmlschema('2001-02-03')  #=> #<Date: 2001-02-03 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing ‘limit: nil`, but note that it may take a long time to parse.

# File 'ext/date/date_core.c', line 4618

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];
        argv2[0] = str;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
  VALUE 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 …>

# File 'ext/date/date_core.c', line 5715

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)

# File 'ext/date/date_core.c', line 6104

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 date object pointing n months before self. The argument n should be a numeric value.

Date.new(2001,2,3)  <<  1   #=> #<Date: 2001-01-03 ...>
Date.new(2001,2,3)  << -2   #=> #<Date: 2001-04-03 ...>

When the same day does not exist for the corresponding month, the last day of the month is used instead:

Date.new(2001,3,28) << 1   #=> #<Date: 2001-02-28 ...>
Date.new(2001,3,31) << 1   #=> #<Date: 2001-02-28 ...>

This also results in the following, possibly unexpected, behavior:

Date.new(2001,3,31) << 2         #=> #<Date: 2001-01-31 ...>
Date.new(2001,3,31) << 1 << 1    #=> #<Date: 2001-01-28 ...>

Date.new(2001,3,31) << 1 << -1   #=> #<Date: 2001-03-28 ...>

# File 'ext/date/date_core.c', line 6256

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

#<=>(other) ⇒ `-1`, ...

Compares the two dates and returns -1, zero, 1 or nil. The other should be a date object or a numeric value as an astronomical Julian day number.

Date.new(2001,2,3) <=> Date.new(2001,2,4)   #=> -1
Date.new(2001,2,3) <=> Date.new(2001,2,3)   #=> 0
Date.new(2001,2,3) <=> Date.new(2001,2,2)   #=> 1
Date.new(2001,2,3) <=> Object.new           #=> nil
Date.new(2001,2,3) <=> Rational(4903887,2)  #=> 0

#===(other) ⇒ `Boolean`

Returns true if they are the same day.

Date.new(2001,2,3) === Date.new(2001,2,3)

#=> true

Date.new(2001,2,3) === Date.new(2001,2,4)

#=> false

DateTime.new(2001,2,3) === DateTime.new(2001,2,3,12)

#=> true

DateTime.new(2001,2,3) === DateTime.new(2001,2,3,0,0,0,'+24:00')

#=> true

DateTime.new(2001,2,3) === DateTime.new(2001,2,4,0,0,0,'+24:00')

#=> false

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 6601

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 date object pointing n months after self. The argument n should be a numeric value.

Date.new(2001,2,3)  >>  1   #=> #<Date: 2001-03-03 ...>
Date.new(2001,2,3)  >> -2   #=> #<Date: 2000-12-03 ...>

When the same day does not exist for the corresponding month, the last day of the month is used instead:

Date.new(2001,1,28) >> 1   #=> #<Date: 2001-02-28 ...>
Date.new(2001,1,31) >> 1   #=> #<Date: 2001-02-28 ...>

This also results in the following, possibly unexpected, behavior:

Date.new(2001,1,31) >> 2         #=> #<Date: 2001-03-31 ...>
Date.new(2001,1,31) >> 1 >> 1    #=> #<Date: 2001-03-28 ...>

Date.new(2001,1,31) >> 1 >> -1   #=> #<Date: 2001-01-28 ...>

# File 'ext/date/date_core.c', line 6194

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`

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)

# File 'ext/date/date_core.c', line 5020

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

#amjd ⇒ `Object`

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

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

# File 'ext/date/date_core.c', line 5037

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

#asctime ⇒ `String` #ctime ⇒ `String`

Returns a string in asctime(3) format (but without “n0” at the end). This method is equivalent to strftime(‘%c’).

#asctime ⇒ `String` #ctime ⇒ `String`

Returns a string in asctime(3) format (but without “n0” at the end). This method is equivalent to strftime(‘%c’).

#cwday ⇒ `Fixnum`

Returns the day of calendar week (1-7, Monday is 1).

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

Returns:

(Fixnum)

# File 'ext/date/date_core.c', line 5213

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

#cweek ⇒ `Fixnum`

Returns the calendar week number (1-53).

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

Returns:

(Fixnum)

# File 'ext/date/date_core.c', line 5198

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

#cwyear ⇒ `Integer`

Returns the calendar week based year.

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

Returns:

(Integer)

# File 'ext/date/date_core.c', line 5183

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

#mday ⇒ `Fixnum` #day ⇒ `Fixnum`

Returns the day of the month (1-31).

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

Overloads:

#mday ⇒ Fixnum
Returns:
- (Fixnum)
#day ⇒ Fixnum
Returns:
- (Fixnum)

# File 'ext/date/date_core.c', line 5150

static VALUE
d_lite_mday(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_mday(dat));
}

#day_fraction ⇒ `Object`

Returns the fractional part of the day.

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

# File 'ext/date/date_core.c', line 5165

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

#downto(min) ⇒ `Object` #downto(min) {|date| ... } ⇒ `self`

This method is equivalent to step(min, -1){|date| …}.

Overloads:

#downto(min) {|date| ... } ⇒ self
Yields:
- (date)
Returns:
- (self)

# File 'ext/date/date_core.c', line 6428

static VALUE
d_lite_downto(VALUE self, VALUE min)
{
    VALUE date;

    RETURN_ENUMERATOR(self, 1, &min);

    date = self;
    while (FIX2INT(d_lite_cmp(date, min)) >= 0) {
  rb_yield(date);
  date = d_lite_plus(date, INT2FIX(-1));
    }
    return self;
}

#england ⇒ `Object`

This method is equivalent to new_start(Date::ENGLAND).

# File 'ext/date/date_core.c', line 5623

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

#eql?(other) ⇒ `Boolean`

:nodoc:

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 6632

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`

# File 'ext/date/date_core.c', line 4991

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 the date is Friday.

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 5322

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

#gregorian ⇒ `Object`

This method is equivalent to new_start(Date::GREGORIAN).

# File 'ext/date/date_core.c', line 5647

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

#gregorian? ⇒ `Boolean`

Returns true if the date is on or after the day of calendar reform.

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

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 5480

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

#hash ⇒ `Object`

:nodoc:

# File 'ext/date/date_core.c', line 6641

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`

This method is equivalent to strftime(‘%a, %d %b %Y %T GMT’). See also RFC 2616.

Returns:

(String)

# File 'ext/date/date_core.c', line 7195

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`

Returns:

(Boolean)



9
10
11

# File 'lib/date.rb', line 9

def infinite?
  false
end

#initialize_copy(date) ⇒ `Object`

:nodoc:

# File 'ext/date/date_core.c', line 4946

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`

Returns the value as a string for inspection.

Date.new(2001,2,3).inspect

#=> “#<Date: 2001-02-03>”

DateTime.new(2001,2,3,4,5,6,'-7').inspect

#=> “#<DateTime: 2001-02-03T04:05:06-07:00>”

Returns:

(String)

# File 'ext/date/date_core.c', line 6755

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

#inspect_raw ⇒ `Object`

# File 'ext/date/date_core.c', line 6725

static VALUE
d_lite_inspect_raw(VALUE self)
{
    get_d1(self);
    return mk_inspect_raw(dat, rb_obj_class(self));
}

#iso8601 ⇒ `String` #xmlschema ⇒ `String`

This method is equivalent to strftime(‘%F’).

Overloads:

#iso8601 ⇒ String
Returns:
- (String)
#xmlschema ⇒ String
Returns:
- (String)

# File 'ext/date/date_core.c', line 7157

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

#italy ⇒ `Object`

This method is equivalent to new_start(Date::ITALY).

# File 'ext/date/date_core.c', line 5611

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

#jd ⇒ `Integer`

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

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

Returns:

(Integer)

# File 'ext/date/date_core.c', line 5054

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

#jisx0301 ⇒ `String`

Returns a string in a JIS X 0301 format.

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

Returns:

(String)

# File 'ext/date/date_core.c', line 7250

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`

This method is equivalent to new_start(Date::JULIAN).

# File 'ext/date/date_core.c', line 5635

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

#julian? ⇒ `Boolean`

Returns true if the date is before the day of calendar reform.

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

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 5464

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

#ld ⇒ `Integer`

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

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

Returns:

(Integer)

# File 'ext/date/date_core.c', line 5087

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

#leap? ⇒ `Boolean`

Returns true if the year is a leap year.

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

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 5496

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:

# File 'ext/date/date_core.c', line 7286

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`

# File 'ext/date/date_core.c', line 7264

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:

# File 'ext/date/date_core.c', line 7310

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 ⇒ `Fixnum` #day ⇒ `Fixnum`

Returns the day of the month (1-31).

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

Overloads:

#mday ⇒ Fixnum
Returns:
- (Fixnum)
#day ⇒ Fixnum
Returns:
- (Fixnum)

# File 'ext/date/date_core.c', line 5150

static VALUE
d_lite_mday(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_mday(dat));
}

#mjd ⇒ `Integer`

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

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

Returns:

(Integer)

# File 'ext/date/date_core.c', line 5071

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

#mon ⇒ `Fixnum` #month ⇒ `Fixnum`

Returns the month (1-12).

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

Overloads:

#mon ⇒ Fixnum
Returns:
- (Fixnum)
#month ⇒ Fixnum
Returns:
- (Fixnum)

# File 'ext/date/date_core.c', line 5134

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

#monday? ⇒ `Boolean`

Returns true if the date is Monday.

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 5270

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

#mon ⇒ `Fixnum` #month ⇒ `Fixnum`

Returns the month (1-12).

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

Overloads:

#mon ⇒ Fixnum
Returns:
- (Fixnum)
#month ⇒ Fixnum
Returns:
- (Fixnum)

# File 'ext/date/date_core.c', line 5134

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

#new_start([start = Date::ITALY]) ⇒ `Object`

Duplicates self and resets its day of calendar reform.

d = Date.new(1582,10,15)
d.new_start(Date::JULIAN)   #=> #<Date: 1582-10-05 ...>

# File 'ext/date/date_core.c', line 5590

static VALUE
d_lite_new_start(int argc, VALUE *argv, VALUE self)
{
    VALUE vsg;
    double sg;

    rb_scan_args(argc, argv, "01", &vsg);

    sg = DEFAULT_SG;
    if (argc >= 1)
  val2sg(vsg, sg);

    return dup_obj_with_new_start(self, sg);
}

#succ ⇒ `Object` #next ⇒ `Object`

Returns a date object denoting the following day.

# File 'ext/date/date_core.c', line 6165

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

#next_day([n = 1]) ⇒ `Object`

This method is equivalent to d + n.

# File 'ext/date/date_core.c', line 6130

static VALUE
d_lite_next_day(int argc, VALUE *argv, VALUE self)
{
    VALUE n;

    rb_scan_args(argc, argv, "01", &n);
    if (argc < 1)
  n = INT2FIX(1);
    return d_lite_plus(self, n);
}

#next_month([n = 1]) ⇒ `Object`

This method is equivalent to d >> n.

See Date#>> for examples.

# File 'ext/date/date_core.c', line 6271

static VALUE
d_lite_next_month(int argc, VALUE *argv, VALUE self)
{
    VALUE n;

    rb_scan_args(argc, argv, "01", &n);
    if (argc < 1)
  n = INT2FIX(1);
    return d_lite_rshift(self, n);
}

#next_year([n = 1]) ⇒ `Object`

This method is equivalent to d >> (n * 12).

Date.new(2001,2,3).next_year      #=> #<Date: 2002-02-03 ...>
Date.new(2008,2,29).next_year     #=> #<Date: 2009-02-28 ...>
Date.new(2008,2,29).next_year(4)  #=> #<Date: 2012-02-29 ...>

#nth_kday?(n, k) ⇒ `Boolean`

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 5343

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`

This method is equivalent to d - n.

# File 'ext/date/date_core.c', line 6147

static VALUE
d_lite_prev_day(int argc, VALUE *argv, VALUE self)
{
    VALUE n;

    rb_scan_args(argc, argv, "01", &n);
    if (argc < 1)
  n = INT2FIX(1);
    return d_lite_minus(self, n);
}

#prev_month([n = 1]) ⇒ `Object`

This method is equivalent to d << n.

See Date#<< for examples.

# File 'ext/date/date_core.c', line 6290

static VALUE
d_lite_prev_month(int argc, VALUE *argv, VALUE self)
{
    VALUE n;

    rb_scan_args(argc, argv, "01", &n);
    if (argc < 1)
  n = INT2FIX(1);
    return d_lite_lshift(self, n);
}

#prev_year([n = 1]) ⇒ `Object`

This method is equivalent to d << (n * 12).

Date.new(2001,2,3).prev_year      #=> #<Date: 2000-02-03 ...>
Date.new(2008,2,29).prev_year     #=> #<Date: 2007-02-28 ...>
Date.new(2008,2,29).prev_year(4)  #=> #<Date: 2004-02-29 ...>

#rfc2822 ⇒ `String` #rfc822 ⇒ `String`

This method is equivalent to strftime(‘%a, %-d %b %Y %T %z’).

Overloads:

#rfc2822 ⇒ String
Returns:
- (String)
#rfc822 ⇒ String
Returns:
- (String)

# File 'ext/date/date_core.c', line 7182

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

#rfc3339 ⇒ `String`

This method is equivalent to strftime(‘%FT%T%:z’).

Returns:

(String)

# File 'ext/date/date_core.c', line 7169

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

#rfc2822 ⇒ `String` #rfc822 ⇒ `String`

This method is equivalent to strftime(‘%a, %-d %b %Y %T %z’).

Overloads:

#rfc2822 ⇒ String
Returns:
- (String)
#rfc822 ⇒ String
Returns:
- (String)

# File 'ext/date/date_core.c', line 7182

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

#saturday? ⇒ `Boolean`

Returns true if the date is Saturday.

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 5335

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

#start ⇒ `Float`

Returns the Julian day number denoting the day of calendar reform.

Date.new(2001,2,3).start      #=> 2299161.0
Date.new(2001,2,3,Date::GREGORIAN).start  #=> -Infinity

Returns:

(Float)

# File 'ext/date/date_core.c', line 5520

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

#step(limit[, step = 1]) ⇒ `Object` #step(limit[, step = 1]) {|date| ... } ⇒ `self`

Iterates evaluation of the given block, which takes a date object. The limit should be a date object.

Date.new(2001).step(Date.new(2001,-1,-1)).select{|d| d.sunday?}.size

#=> 52

Overloads:

#step(limit[, step = 1]) {|date| ... } ⇒ self
Yields:
- (date)
Returns:
- (self)

# File 'ext/date/date_core.c', line 6360

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`

Formats date according to the directives in the given format string. The directives begin with a percent (%) character. Any text not listed as a directive will be passed through to the output string.

A directive consists of a percent (%) character, zero or more flags, an optional minimum field width, an optional modifier, and a conversion specifier as follows.

%<flags><width><modifier><conversion>

Flags:

-  don't pad a numerical output.
_  use spaces for padding.
0  use zeros for padding.
^  upcase the result string.
#  change case.

The minimum field width specifies the minimum width.

The modifiers are “E”, “O”, “:”, “::” and “:::”. “E” and “O” are ignored. No effect to result currently.

Format directives:

Date (Year, Month, Day):
  Y - Year with century (can be negative, 4 digits at least)
          -0001, 0000, 1995, 2009, 14292, etc.
  %C - year / 100 (round down.  20 in 2009)
  y - year % 100 (00..99)

  m - Month of the year, zero-padded (01..12)
          _m  blank-padded ( 1..12)
          %-m  no-padded (1..12)
  B - The full month name (``January'')
          %^B  uppercased (``JANUARY'')
  %b - The abbreviated month name (``Jan'')
          %^b  uppercased (``JAN'')
  h - Equivalent to %b

  d - Day of the month, zero-padded (01..31)
          %-d  no-padded (1..31)
  e - Day of the month, blank-padded ( 1..31)

  j - Day of the year (001..366)

Time (Hour, Minute, Second, Subsecond):
  H - Hour of the day, 24-hour clock, zero-padded (00..23)
  k - Hour of the day, 24-hour clock, blank-padded ( 0..23)
  I - Hour of the day, 12-hour clock, zero-padded (01..12)
  l - Hour of the day, 12-hour clock, blank-padded ( 1..12)
  P - Meridian indicator, lowercase (``am'' or ``pm'')
  p - Meridian indicator, uppercase (``AM'' or ``PM'')

  M - Minute of the hour (00..59)

  S - Second of the minute (00..60)

  L - Millisecond of the second (000..999)
  N - Fractional seconds digits, default is 9 digits (nanosecond)
          3N  millisecond (3 digits)   %15N femtosecond (15 digits)
          6N  microsecond (6 digits)   %18N attosecond  (18 digits)
          9N  nanosecond  (9 digits)   %21N zeptosecond (21 digits)
          12N picosecond (12 digits)   %24N yoctosecond (24 digits)

Time zone:
  z - Time zone as hour and minute offset from UTC (e.g. +0900)
          %:z - hour and minute offset from UTC with a colon (e.g. +09:00)
          %::z - hour, minute and second offset from UTC (e.g. +09:00:00)
          %:::z - hour, minute and second offset from UTC
                                            (e.g. +09, +09:30, +09:30:30)
  Z - Equivalent to %:z (e.g. +09:00)

Weekday:
  A - The full weekday name (``Sunday'')
          %^A  uppercased (``SUNDAY'')
  %a - The abbreviated name (``Sun'')
          %^a  uppercased (``SUN'')
  u - Day of the week (Monday is 1, 1..7)
  %w - Day of the week (Sunday is 0, 0..6)

ISO 8601 week-based year and week number:
The week 1 of YYYY starts with a Monday and includes YYYY-01-04.
The days in the year before the first week are in the last week of
the previous year.
  %G - The week-based year
  g - The last 2 digits of the week-based year (00..99)
  V - Week number of the week-based year (01..53)

Week number:
The week 1 of YYYY starts with a Sunday or Monday (according to %U
or %W).  The days in the year before the first week are in week 0.
  %U - Week number of the year.  The week starts with Sunday.  (00..53)
  %W - Week number of the year.  The week starts with Monday.  (00..53)

Seconds since the Unix Epoch:
  s - Number of seconds since 1970-01-01 00:00:00 UTC.
  %Q - Number of milliseconds since 1970-01-01 00:00:00 UTC.

Literal string:
  n - Newline character (\n)
  t - Tab character (\t)
  %% - Literal ``%'' character

Combination:
  c - date and time (a b %e T %Y)
  D - Date (m/d/y)
  F - The ISO 8601 date format (Y-m-d)
  v - VMS date (e-%^b-%Y)
  %x - Same as %D
  %X - Same as %T
  %r - 12-hour time (%I:%M:%S %p)
  %R - 24-hour time (%H:%M)
  %T - 24-hour time (%H:%M:%S)
  %+ - date(1) (%a %b %e %H:%M:%S %Z %Y)

This method is similar to the strftime() function defined in ISO C and POSIX. Several directives (%a, %A, %b, %B, %c, %p, %r, %x, %X, %E*, %O* and %Z) are locale dependent in the function. However, this method is locale independent. So, the result may differ even if the same format string is used in other systems such as C. It is good practice to avoid %x and %X because there are corresponding locale independent representations, %D and %T.

Examples:

d = DateTime.new(2007,11,19,8,37,48,"-06:00")

#=> #<DateTime: 2007-11-19T08:37:48-0600 …>

d.strftime("Printed on %m/%d/%Y")   #=> "Printed on 11/19/2007"
d.strftime("at %I:%M%p")            #=> "at 08:37AM"

Various ISO 8601 formats:

Y%m%d           => 20071119                  Calendar date (basic)
F               => 2007-11-19                Calendar date (extended)
Y-m            => 2007-11                   Calendar date, reduced accuracy, specific month
Y               => 2007                      Calendar date, reduced accuracy, specific year
C               => 20                        Calendar date, reduced accuracy, specific century
Y%j             => 2007323                   Ordinal date (basic)
Y-j            => 2007-323                  Ordinal date (extended)
GW%V%u          => 2007W471                  Week date (basic)
G-W%V-u        => 2007-W47-1                Week date (extended)
GW%V            => 2007W47                   Week date, reduced accuracy, specific week (basic)
G-W%V           => 2007-W47                  Week date, reduced accuracy, specific week (extended)
H%M%S           => 083748                    Local time (basic)
T               => 08:37:48                  Local time (extended)
H%M             => 0837                      Local time, reduced accuracy, specific minute (basic)
H:%M            => 08:37                     Local time, reduced accuracy, specific minute (extended)
H               => 08                        Local time, reduced accuracy, specific hour
H%M%S,L        => 083748,000                Local time with decimal fraction, comma as decimal sign (basic)
T,L            => 08:37:48,000              Local time with decimal fraction, comma as decimal sign (extended)
H%M%S.%L        => 083748.000                Local time with decimal fraction, full stop as decimal sign (basic)
T.%L            => 08:37:48.000              Local time with decimal fraction, full stop as decimal sign (extended)
H%M%S%z         => 083748-0600               Local time and the difference from UTC (basic)
T%:z            => 08:37:48-06:00            Local time and the difference from UTC (extended)
Y%m%dT%H%M%S%z  => 20071119T083748-0600      Date and time of day for calendar date (basic)
FT%T%:z         => 2007-11-19T08:37:48-06:00 Date and time of day for calendar date (extended)
Y%jT%H%M%S%z    => 2007323T083748-0600       Date and time of day for ordinal date (basic)
Y-jT%T%:z      => 2007-323T08:37:48-06:00   Date and time of day for ordinal date (extended)
GW%V%uT%H%M%S%z => 2007W471T083748-0600      Date and time of day for week date (basic)
G-W%V-uT%T%:z  => 2007-W47-1T08:37:48-06:00 Date and time of day for week date (extended)
Y%m%dT%H%M      => 20071119T0837             Calendar date and local time (basic)
FT%R            => 2007-11-19T08:37          Calendar date and local time (extended)
Y%jT%H%MZ       => 2007323T0837Z             Ordinal date and UTC of day (basic)
Y-jT%RZ        => 2007-323T08:37Z           Ordinal date and UTC of day (extended)
GW%V%uT%H%M%z   => 2007W471T0837-0600        Week date and local time and difference from UTC (basic)
G-W%V-uT%R%:z  => 2007-W47-1T08:37-06:00    Week date and local time and difference from UTC (extended)

#succ ⇒ `Object` #next ⇒ `Object`

Returns a date object denoting the following day.

# File 'ext/date/date_core.c', line 6165

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

#sunday? ⇒ `Boolean`

Returns true if the date is Sunday.

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 5257

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

#thursday? ⇒ `Boolean`

Returns true if the date is Thursday.

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 5309

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

#to_date ⇒ `self`

Returns self.

Returns:

(self)

# File 'ext/date/date_core.c', line 8862

static VALUE
date_to_date(VALUE self)
{
    return self;
}

#to_datetime ⇒ `Object`

Returns a DateTime object which denotes self.

# File 'ext/date/date_core.c', line 8874

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 in an ISO 8601 format. (This method doesn’t use the expanded representations.)

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

Returns:

(String)

# File 'ext/date/date_core.c', line 6669

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

#to_time ⇒ `Time`

Returns a Time object which denotes self. If self is a julian date, convert it to a gregorian date before converting it to Time.

Returns:

(Time)

# File 'ext/date/date_core.c', line 8839

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 the date is Tuesday.

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 5283

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

#upto(max) ⇒ `Object` #upto(max) {|date| ... } ⇒ `self`

This method is equivalent to step(max, 1){|date| …}.

Overloads:

#upto(max) {|date| ... } ⇒ self
Yields:
- (date)
Returns:
- (self)

# File 'ext/date/date_core.c', line 6406

static VALUE
d_lite_upto(VALUE self, VALUE max)
{
    VALUE date;

    RETURN_ENUMERATOR(self, 1, &max);

    date = self;
    while (FIX2INT(d_lite_cmp(date, max)) <= 0) {
  rb_yield(date);
  date = d_lite_plus(date, INT2FIX(1));
    }
    return self;
}

#wday ⇒ `Fixnum`

Returns the day of week (0-6, Sunday is zero).

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

Returns:

(Fixnum)

# File 'ext/date/date_core.c', line 5244

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

#wednesday? ⇒ `Boolean`

Returns true if the date is Wednesday.

Returns:

(Boolean)

# File 'ext/date/date_core.c', line 5296

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

#iso8601 ⇒ `String` #xmlschema ⇒ `String`

This method is equivalent to strftime(‘%F’).

Overloads:

#iso8601 ⇒ String
Returns:
- (String)
#xmlschema ⇒ String
Returns:
- (String)

# File 'ext/date/date_core.c', line 7157

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

#yday ⇒ `Fixnum`

Returns the day of the year (1-366).

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

Returns:

(Fixnum)

# File 'ext/date/date_core.c', line 5118

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

#year ⇒ `Integer`

Returns the year.

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

Returns:

(Integer)

# File 'ext/date/date_core.c', line 5103

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

Class: Date

Direct Known Subclasses

Defined Under Namespace

Constant Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args) ⇒ Object

Class Method Details

._httpdate(string, limit: 128) ⇒ Hash

._iso8601(string, limit: 128) ⇒ Hash

._jisx0301(string, limit: 128) ⇒ Hash

._load(s) ⇒ Object

._parse(string[, comp = true], limit: 128) ⇒ Hash

._rfc2822(string, limit: 128) ⇒ Hash ._rfc822(string, limit: 128) ⇒ Hash

._rfc3339(string, limit: 128) ⇒ Hash

._rfc2822(string, limit: 128) ⇒ Hash ._rfc822(string, limit: 128) ⇒ Hash

._strptime(string[, format = '%F']) ⇒ Hash

._xmlschema(string, limit: 128) ⇒ Hash

.civil([year = -4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Object .new([year = -4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Object

.commercial([cwyear = -4712[, cweek=1[, cwday=1[, start=Date::ITALY]]]]) ⇒ Object

.gregorian_leap?(year) ⇒ Boolean .leap?(year) ⇒ Boolean

.httpdate(string = 'Mon, 01 Jan -4712 00:00:00 GMT'[, start=Date::ITALY], limit: 128) ⇒ Object

.iso8601(string = '-4712-01-01'[, start=Date::ITALY], limit: 128) ⇒ Object

.jd([jd = 0[, start=Date::ITALY]]) ⇒ Object

.jisx0301(string = '-4712-01-01'[, start=Date::ITALY], limit: 128) ⇒ Object

.julian_leap?(year) ⇒ Boolean

.gregorian_leap?(year) ⇒ Boolean .leap?(year) ⇒ Boolean

.new!(*args) ⇒ Object

.nth_kday(*args) ⇒ Object

.ordinal([year = -4712[, yday=1[, start=Date::ITALY]]]) ⇒ Object

.parse(string = '-4712-01-01'[, comp=true[, start=Date::ITALY]], limit: 128) ⇒ Object

.rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ Object .rfc822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ Object

.rfc3339(string = '-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ Object

.rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ Object .rfc822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ Object

.strptime([string = '-4712-01-01'[, format='%F'[, start=Date::ITALY]]]) ⇒ Object

.test_all ⇒ Object

.test_civil ⇒ Object

.test_commercial ⇒ Object

.test_nth_kday ⇒ Object

.test_ordinal ⇒ Object

.test_unit_conv ⇒ Object

.test_weeknum ⇒ Object

.today([start = Date::ITALY]) ⇒ Object

.valid_civil?(year, month, mday[, start = Date::ITALY]) ⇒ Boolean .valid_date?(year, month, mday[, start = Date::ITALY]) ⇒ Boolean

.valid_commercial?(cwyear, cweek, cwday[, start = Date::ITALY]) ⇒ Boolean

.valid_civil?(year, month, mday[, start = Date::ITALY]) ⇒ Boolean .valid_date?(year, month, mday[, start = Date::ITALY]) ⇒ Boolean

.valid_jd?(jd[, start = Date::ITALY]) ⇒ Boolean

.valid_ordinal?(year, yday[, start = Date::ITALY]) ⇒ Boolean

.weeknum(*args) ⇒ Object

.xmlschema(string = '-4712-01-01'[, start=Date::ITALY], limit: 128) ⇒ Object

Instance Method Details

#+(other) ⇒ Object

#-(other) ⇒ Object

#<<(n) ⇒ Object

#<=>(other) ⇒ -1, ...

#===(other) ⇒ Boolean

#>>(n) ⇒ Object

#ajd ⇒ Object

#amjd ⇒ Object

#asctime ⇒ String #ctime ⇒ String

#asctime ⇒ String #ctime ⇒ String

#cwday ⇒ Fixnum

#cweek ⇒ Fixnum

#cwyear ⇒ Integer

#mday ⇒ Fixnum #day ⇒ Fixnum

#day_fraction ⇒ Object

#downto(min) ⇒ Object #downto(min) {|date| ... } ⇒ self

#england ⇒ Object

#eql?(other) ⇒ Boolean

#fill ⇒ Object

#friday? ⇒ Boolean

#gregorian ⇒ Object

#gregorian? ⇒ Boolean

#hash ⇒ Object

#httpdate ⇒ String

#infinite? ⇒ Boolean

#initialize_copy(date) ⇒ Object

#inspect ⇒ String

#inspect_raw ⇒ Object

#initialize(*args) ⇒ `Object`

._httpdate(string, limit: 128) ⇒ `Hash`

._iso8601(string, limit: 128) ⇒ `Hash`

._jisx0301(string, limit: 128) ⇒ `Hash`

._load(s) ⇒ `Object`

._parse(string[, comp = true], limit: 128) ⇒ `Hash`

._rfc2822(string, limit: 128) ⇒ `Hash` ._rfc822(string, limit: 128) ⇒ `Hash`

._rfc3339(string, limit: 128) ⇒ `Hash`

._rfc2822(string, limit: 128) ⇒ `Hash` ._rfc822(string, limit: 128) ⇒ `Hash`

._strptime(string[, format = '%F']) ⇒ `Hash`

._xmlschema(string, limit: 128) ⇒ `Hash`

.civil([year = -4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ `Object` .new([year = -4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ `Object`

.commercial([cwyear = -4712[, cweek=1[, cwday=1[, start=Date::ITALY]]]]) ⇒ `Object`

.gregorian_leap?(year) ⇒ `Boolean` .leap?(year) ⇒ `Boolean`

.httpdate(string = 'Mon, 01 Jan -4712 00:00:00 GMT'[, start=Date::ITALY], limit: 128) ⇒ `Object`

.iso8601(string = '-4712-01-01'[, start=Date::ITALY], limit: 128) ⇒ `Object`

.jd([jd = 0[, start=Date::ITALY]]) ⇒ `Object`

.jisx0301(string = '-4712-01-01'[, start=Date::ITALY], limit: 128) ⇒ `Object`

.julian_leap?(year) ⇒ `Boolean`

.gregorian_leap?(year) ⇒ `Boolean` .leap?(year) ⇒ `Boolean`

.new!(*args) ⇒ `Object`

.nth_kday(*args) ⇒ `Object`

.ordinal([year = -4712[, yday=1[, start=Date::ITALY]]]) ⇒ `Object`

.parse(string = '-4712-01-01'[, comp=true[, start=Date::ITALY]], limit: 128) ⇒ `Object`

.rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `Object` .rfc822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `Object`

.rfc3339(string = '-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ `Object`

.rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `Object` .rfc822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `Object`

.strptime([string = '-4712-01-01'[, format='%F'[, start=Date::ITALY]]]) ⇒ `Object`

.test_all ⇒ `Object`

.test_civil ⇒ `Object`

.test_commercial ⇒ `Object`

.test_nth_kday ⇒ `Object`

.test_ordinal ⇒ `Object`

.test_unit_conv ⇒ `Object`

.test_weeknum ⇒ `Object`

.today([start = Date::ITALY]) ⇒ `Object`

.valid_civil?(year, month, mday[, start = Date::ITALY]) ⇒ `Boolean` .valid_date?(year, month, mday[, start = Date::ITALY]) ⇒ `Boolean`

.valid_commercial?(cwyear, cweek, cwday[, start = Date::ITALY]) ⇒ `Boolean`

.valid_civil?(year, month, mday[, start = Date::ITALY]) ⇒ `Boolean` .valid_date?(year, month, mday[, start = Date::ITALY]) ⇒ `Boolean`

.valid_jd?(jd[, start = Date::ITALY]) ⇒ `Boolean`

.valid_ordinal?(year, yday[, start = Date::ITALY]) ⇒ `Boolean`

.weeknum(*args) ⇒ `Object`

.xmlschema(string = '-4712-01-01'[, start=Date::ITALY], limit: 128) ⇒ `Object`

#+(other) ⇒ `Object`

#-(other) ⇒ `Object`

#<<(n) ⇒ `Object`

#<=>(other) ⇒ `-1`, ...

#===(other) ⇒ `Boolean`

#>>(n) ⇒ `Object`

#ajd ⇒ `Object`

#amjd ⇒ `Object`

#asctime ⇒ `String` #ctime ⇒ `String`

#asctime ⇒ `String` #ctime ⇒ `String`

#cwday ⇒ `Fixnum`

#cweek ⇒ `Fixnum`

#cwyear ⇒ `Integer`

#mday ⇒ `Fixnum` #day ⇒ `Fixnum`

#day_fraction ⇒ `Object`

#downto(min) ⇒ `Object` #downto(min) {|date| ... } ⇒ `self`

#england ⇒ `Object`

#eql?(other) ⇒ `Boolean`

#fill ⇒ `Object`

#friday? ⇒ `Boolean`

#gregorian ⇒ `Object`

#gregorian? ⇒ `Boolean`

#hash ⇒ `Object`

#httpdate ⇒ `String`

#infinite? ⇒ `Boolean`

#initialize_copy(date) ⇒ `Object`

#inspect ⇒ `String`

#inspect_raw ⇒ `Object`

#iso8601 ⇒ `String` #xmlschema ⇒ `String`

#italy ⇒ `Object`

#jd ⇒ `Integer`

#jisx0301 ⇒ `String`

#julian ⇒ `Object`

#julian? ⇒ `Boolean`

#ld ⇒ `Integer`

#leap? ⇒ `Boolean`

#marshal_dump ⇒ `Object`