Class: Date

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
lib/date.rb,
date_core.c

Direct Known Subclasses

DateTime

Defined Under Namespace

Classes: Infinity

Constant Summary collapse

MONTHNAMES =

An array of stirng of full month name in English. The first element is nil.

mk_ary_of_str(13, monthnames)
ABBR_MONTHNAMES =

An array of string of abbreviated month name in English. The first element is nil.

mk_ary_of_str(13, abbr_monthnames)
DAYNAMES =

An array of string of full name of days of the week in English. The first is “Sunday”.

mk_ary_of_str(7, daynames)
ABBR_DAYNAMES =

An array of string of abbreviated day name 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

Instance Method Summary collapse

Class Method Details

._httpdate(string) ⇒ Hash

Returns a hash of parsed elements.

Returns:

  • (Hash)

4512
4513
4514
4515
4516
# File 'date_core.c', line 4512

static VALUE
date_s__httpdate(VALUE klass, VALUE str)
{
    return date__httpdate(str);
}

._iso8601(string) ⇒ Hash

Returns a hash of parsed elements.

Returns:

  • (Hash)

4343
4344
4345
4346
4347
# File 'date_core.c', line 4343

static VALUE
date_s__iso8601(VALUE klass, VALUE str)
{
    return date__iso8601(str);
}

._jisx0301(string) ⇒ Hash

Returns a hash of parsed elements.

Returns:

  • (Hash)

4554
4555
4556
4557
4558
# File 'date_core.c', line 4554

static VALUE
date_s__jisx0301(VALUE klass, VALUE str)
{
    return date__jisx0301(str);
}

._loadObject

:nodoc:


7242
7243
7244
7245
7246
7247
7248
7249
7250
# File 'date_core.c', line 7242

static VALUE
date_s__load(VALUE klass, VALUE s)
{
    VALUE a, obj;

    a = rb_marshal_load(s);
    obj = d_lite_s_alloc(klass);
    return d_lite_marshal_load(obj, a);
}

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

Parses the given representation of date and time, and returns a hash of parsed elements. This method does not function as a validator.

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

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

Returns:

  • (Hash)

4283
4284
4285
4286
4287
# File 'date_core.c', line 4283

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

._rfc2822(string) ⇒ Hash ._rfc822(string) ⇒ Hash

Returns a hash of parsed elements.

Overloads:

  • ._rfc2822(string) ⇒ Hash

    Returns:

    • (Hash)
  • ._rfc822(string) ⇒ Hash

    Returns:

    • (Hash)

4469
4470
4471
4472
4473
# File 'date_core.c', line 4469

static VALUE
date_s__rfc2822(VALUE klass, VALUE str)
{
    return date__rfc2822(str);
}

._rfc3339(string) ⇒ Hash

Returns a hash of parsed elements.

Returns:

  • (Hash)

4386
4387
4388
4389
4390
# File 'date_core.c', line 4386

static VALUE
date_s__rfc3339(VALUE klass, VALUE str)
{
    return date__rfc3339(str);
}

._rfc2822(string) ⇒ Hash ._rfc822(string) ⇒ Hash

Returns a hash of parsed elements.

Overloads:

  • ._rfc2822(string) ⇒ Hash

    Returns:

    • (Hash)
  • ._rfc822(string) ⇒ Hash

    Returns:

    • (Hash)

4469
4470
4471
4472
4473
# File 'date_core.c', line 4469

static VALUE
date_s__rfc2822(VALUE klass, VALUE str)
{
    return date__rfc2822(str);
}

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

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

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

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

See also strptime(3) and strftime.

Returns:

  • (Hash)

4189
4190
4191
4192
4193
# File 'date_core.c', line 4189

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

._xmlschema(string) ⇒ Hash

Returns a hash of parsed elements.

Returns:

  • (Hash)

4427
4428
4429
4430
4431
# File 'date_core.c', line 4427

static VALUE
date_s__xmlschema(VALUE klass, VALUE str)
{
    return date__xmlschema(str);
}

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

Creates a date object denoting the given calendar date.

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

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

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

See also jd.


3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
# File 'date_core.c', line 3337

static VALUE
date_s_civil(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vm, vd, vsg, y, fr, fr2, ret;
    int m, d;
    double sg;

    rb_scan_args(argc, argv, "04", &vy, &vm, &vd, &vsg);

    y = INT2FIX(-4712);
    m = 1;
    d = 1;
    fr2 = INT2FIX(0);
    sg = DEFAULT_SG;

    switch (argc) {
      case 4:
  val2sg(vsg, sg);
      case 3:
  num2int_with_frac(d, positive_inf);
      case 2:
  m = NUM2INT(vm);
      case 1:
  y = vy;
    }

    if (guess_style(y, sg) < 0) {
  VALUE nth;
  int ry, rm, rd;

  if (!valid_gregorian_p(y, m, d,
             &nth, &ry,
             &rm, &rd))
      rb_raise(rb_eArgError, "invalid date");

  ret = d_simple_new_internal(klass,
            nth, 0,
            sg,
            ry, rm, rd,
            HAVE_CIVIL);
    }
    else {
  VALUE nth;
  int ry, rm, rd, rjd, ns;

  if (!valid_civil_p(y, m, d, sg,
         &nth, &ry,
         &rm, &rd, &rjd,
         &ns))
      rb_raise(rb_eArgError, "invalid date");

  ret = d_simple_new_internal(klass,
            nth, rjd,
            sg,
            ry, rm, rd,
            HAVE_JD | HAVE_CIVIL);
    }
    add_frac();
    return ret;
}

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

Creates a date object denoting the given week date.

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

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

See also jd and new.


3414
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453
3454
3455
3456
3457
3458
# File 'date_core.c', line 3414

static VALUE
date_s_commercial(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vw, vd, vsg, y, fr, fr2, ret;
    int w, d;
    double sg;

    rb_scan_args(argc, argv, "04", &vy, &vw, &vd, &vsg);

    y = INT2FIX(-4712);
    w = 1;
    d = 1;
    fr2 = INT2FIX(0);
    sg = DEFAULT_SG;

    switch (argc) {
      case 4:
  val2sg(vsg, sg);
      case 3:
  num2int_with_frac(d, positive_inf);
      case 2:
  w = NUM2INT(vw);
      case 1:
  y = vy;
    }

    {
  VALUE nth;
  int ry, rw, rd, rjd, ns;

  if (!valid_commercial_p(y, w, d, sg,
        &nth, &ry,
        &rw, &rd, &rjd,
        &ns))
      rb_raise(rb_eArgError, "invalid date");

  ret = d_simple_new_internal(klass,
            nth, rjd,
            sg,
            0, 0, 0,
            HAVE_JD);
    }
    add_frac();
    return ret;
}

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

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

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

Overloads:

  • .gregorian_leap?(year) ⇒ Boolean

    Returns:

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

    Returns:

    • (Boolean)

Returns:

  • (Boolean)

2889
2890
2891
2892
2893
2894
2895
2896
2897
# File 'date_core.c', line 2889

static VALUE
date_s_gregorian_leap_p(VALUE klass, VALUE y)
{
    VALUE nth;
    int ry;

    decode_year(y, -1, &nth, &ry);
    return f_boolcast(c_gregorian_leap_p(ry));
}

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

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

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

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


4528
4529
4530
4531
4532
4533
4534
4535
4536
4537
4538
4539
4540
4541
4542
4543
4544
4545
4546
# File 'date_core.c', line 4528

static VALUE
date_s_httpdate(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg;

    rb_scan_args(argc, argv, "02", &str, &sg);

    switch (argc) {
      case 0:
  str = rb_str_new2("Mon, 01 Jan -4712 00:00:00 GMT");
      case 1:
  sg = INT2FIX(DEFAULT_SG);
    }

    {
  VALUE hash = date_s__httpdate(klass, str);
  return d_new_by_frags(klass, hash, sg);
    }
}

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

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

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

4360
4361
4362
4363
4364
4365
4366
4367
4368
4369
4370
4371
4372
4373
4374
4375
4376
4377
4378
# File 'date_core.c', line 4360

static VALUE
date_s_iso8601(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg;

    rb_scan_args(argc, argv, "02", &str, &sg);

    switch (argc) {
      case 0:
  str = rb_str_new2("-4712-01-01");
      case 1:
  sg = INT2FIX(DEFAULT_SG);
    }

    {
  VALUE hash = date_s__iso8601(klass, str);
  return d_new_by_frags(klass, hash, sg);
    }
}

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

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

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

See also new.


3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3229
3230
3231
3232
3233
3234
3235
3236
3237
3238
3239
3240
3241
3242
3243
3244
3245
3246
3247
3248
3249
3250
3251
# File 'date_core.c', line 3219

static VALUE
date_s_jd(int argc, VALUE *argv, VALUE klass)
{
    VALUE vjd, vsg, jd, fr, fr2, ret;
    double sg;

    rb_scan_args(argc, argv, "02", &vjd, &vsg);

    jd = INT2FIX(0);
    fr2 = INT2FIX(0);
    sg = DEFAULT_SG;

    switch (argc) {
      case 2:
  val2sg(vsg, sg);
      case 1:
  num2num_with_frac(jd, positive_inf);
    }

    {
  VALUE nth;
  int rjd;

  decode_jd(jd, &nth, &rjd);
  ret = d_simple_new_internal(klass,
            nth, rjd,
            sg,
            0, 0, 0,
            HAVE_JD);
    }
    add_frac();
    return ret;
}

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

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

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

4569
4570
4571
4572
4573
4574
4575
4576
4577
4578
4579
4580
4581
4582
4583
4584
4585
4586
4587
# File 'date_core.c', line 4569

static VALUE
date_s_jisx0301(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg;

    rb_scan_args(argc, argv, "02", &str, &sg);

    switch (argc) {
      case 0:
  str = rb_str_new2("-4712-01-01");
      case 1:
  sg = INT2FIX(DEFAULT_SG);
    }

    {
  VALUE hash = date_s__jisx0301(klass, str);
  return d_new_by_frags(klass, hash, sg);
    }
}

.julian_leap?(year) ⇒ Boolean

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

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

Returns:

  • (Boolean)

Returns:

  • (Boolean)

2868
2869
2870
2871
2872
2873
2874
2875
2876
# File 'date_core.c', line 2868

static VALUE
date_s_julian_leap_p(VALUE klass, VALUE y)
{
    VALUE nth;
    int ry;

    decode_year(y, +1, &nth, &ry);
    return f_boolcast(c_julian_leap_p(ry));
}

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

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

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

Overloads:

  • .gregorian_leap?(year) ⇒ Boolean

    Returns:

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

    Returns:

    • (Boolean)

Returns:

  • (Boolean)

2889
2890
2891
2892
2893
2894
2895
2896
2897
# File 'date_core.c', line 2889

static VALUE
date_s_gregorian_leap_p(VALUE klass, VALUE y)
{
    VALUE nth;
    int ry;

    decode_year(y, -1, &nth, &ry);
    return f_boolcast(c_gregorian_leap_p(ry));
}

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

Creates a date object denoting the given calendar date.

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

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

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

See also jd.


3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
# File 'date_core.c', line 3337

static VALUE
date_s_civil(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vm, vd, vsg, y, fr, fr2, ret;
    int m, d;
    double sg;

    rb_scan_args(argc, argv, "04", &vy, &vm, &vd, &vsg);

    y = INT2FIX(-4712);
    m = 1;
    d = 1;
    fr2 = INT2FIX(0);
    sg = DEFAULT_SG;

    switch (argc) {
      case 4:
  val2sg(vsg, sg);
      case 3:
  num2int_with_frac(d, positive_inf);
      case 2:
  m = NUM2INT(vm);
      case 1:
  y = vy;
    }

    if (guess_style(y, sg) < 0) {
  VALUE nth;
  int ry, rm, rd;

  if (!valid_gregorian_p(y, m, d,
             &nth, &ry,
             &rm, &rd))
      rb_raise(rb_eArgError, "invalid date");

  ret = d_simple_new_internal(klass,
            nth, 0,
            sg,
            ry, rm, rd,
            HAVE_CIVIL);
    }
    else {
  VALUE nth;
  int ry, rm, rd, rjd, ns;

  if (!valid_civil_p(y, m, d, sg,
         &nth, &ry,
         &rm, &rd, &rjd,
         &ns))
      rb_raise(rb_eArgError, "invalid date");

  ret = d_simple_new_internal(klass,
            nth, rjd,
            sg,
            ry, rm, rd,
            HAVE_JD | HAVE_CIVIL);
    }
    add_frac();
    return ret;
}

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

Creates a date object denoting the given ordinal date.

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

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

See also jd and new.


3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
3300
3301
3302
3303
3304
3305
3306
3307
3308
3309
3310
# File 'date_core.c', line 3269

static VALUE
date_s_ordinal(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vd, vsg, y, fr, fr2, ret;
    int d;
    double sg;

    rb_scan_args(argc, argv, "03", &vy, &vd, &vsg);

    y = INT2FIX(-4712);
    d = 1;
    fr2 = INT2FIX(0);
    sg = DEFAULT_SG;

    switch (argc) {
      case 3:
  val2sg(vsg, sg);
      case 2:
  num2int_with_frac(d, positive_inf);
      case 1:
  y = vy;
    }

    {
  VALUE nth;
  int ry, rd, rjd, ns;

  if (!valid_ordinal_p(y, d, sg,
           &nth, &ry,
           &rd, &rjd,
           &ns))
      rb_raise(rb_eArgError, "invalid date");

  ret = d_simple_new_internal(klass,
             nth, rjd,
             sg,
             0, 0, 0,
             HAVE_JD);
    }
    add_frac();
    return ret;
}

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

Parses the given representation of date and time, and creates a date object. This method does not function as a validator.

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

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

4304
4305
4306
4307
4308
4309
4310
4311
4312
4313
4314
4315
4316
4317
4318
4319
4320
4321
4322
4323
4324
4325
4326
4327
4328
# File 'date_core.c', line 4304

static VALUE
date_s_parse(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, comp, sg;

    rb_scan_args(argc, argv, "03", &str, &comp, &sg);

    switch (argc) {
      case 0:
  str = rb_str_new2("-4712-01-01");
      case 1:
  comp = Qtrue;
      case 2:
  sg = INT2FIX(DEFAULT_SG);
    }

    {
  VALUE argv2[2], hash;

  argv2[0] = str;
  argv2[1] = comp;
  hash = date_s__parse(2, argv2, klass);
  return d_new_by_frags(klass, hash, sg);
    }
}

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

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

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

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


4486
4487
4488
4489
4490
4491
4492
4493
4494
4495
4496
4497
4498
4499
4500
4501
4502
4503
4504
# File 'date_core.c', line 4486

static VALUE
date_s_rfc2822(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg;

    rb_scan_args(argc, argv, "02", &str, &sg);

    switch (argc) {
      case 0:
  str = rb_str_new2("Mon, 1 Jan -4712 00:00:00 +0000");
      case 1:
  sg = INT2FIX(DEFAULT_SG);
    }

    {
  VALUE hash = date_s__rfc2822(klass, str);
  return d_new_by_frags(klass, hash, sg);
    }
}

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

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

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

4401
4402
4403
4404
4405
4406
4407
4408
4409
4410
4411
4412
4413
4414
4415
4416
4417
4418
4419
# File 'date_core.c', line 4401

static VALUE
date_s_rfc3339(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg;

    rb_scan_args(argc, argv, "02", &str, &sg);

    switch (argc) {
      case 0:
  str = rb_str_new2("-4712-01-01T00:00:00+00:00");
      case 1:
  sg = INT2FIX(DEFAULT_SG);
    }

    {
  VALUE hash = date_s__rfc3339(klass, str);
  return d_new_by_frags(klass, hash, sg);
    }
}

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

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

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

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


4486
4487
4488
4489
4490
4491
4492
4493
4494
4495
4496
4497
4498
4499
4500
4501
4502
4503
4504
# File 'date_core.c', line 4486

static VALUE
date_s_rfc2822(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg;

    rb_scan_args(argc, argv, "02", &str, &sg);

    switch (argc) {
      case 0:
  str = rb_str_new2("Mon, 1 Jan -4712 00:00:00 +0000");
      case 1:
  sg = INT2FIX(DEFAULT_SG);
    }

    {
  VALUE hash = date_s__rfc2822(klass, str);
  return d_new_by_frags(klass, hash, sg);
    }
}

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

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

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

See also strptime(3) and strftime.


4213
4214
4215
4216
4217
4218
4219
4220
4221
4222
4223
4224
4225
4226
4227
4228
4229
4230
4231
4232
4233
4234
4235
4236
4237
# File 'date_core.c', line 4213

static VALUE
date_s_strptime(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, fmt, sg;

    rb_scan_args(argc, argv, "03", &str, &fmt, &sg);

    switch (argc) {
      case 0:
  str = rb_str_new2("-4712-01-01");
      case 1:
  fmt = rb_str_new2("%F");
      case 2:
  sg = INT2FIX(DEFAULT_SG);
    }

    {
  VALUE argv2[2], hash;

  argv2[0] = str;
  argv2[1] = fmt;
  hash = date_s__strptime(2, argv2, klass);
  return d_new_by_frags(klass, hash, sg);
    }
}

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

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

Creates a date object denoting the present day.


3590
3591
3592
3593
3594
3595
3596
3597
3598
3599
3600
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621
3622
3623
3624
3625
3626
3627
3628
# File 'date_core.c', line 3590

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

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

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

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

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

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

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

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

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

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

See also jd and civil.

Overloads:

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

    Returns:

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

    Returns:

    • (Boolean)

Returns:

  • (Boolean)

2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
# File 'date_core.c', line 2522

static VALUE
date_s_valid_civil_p(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vm, vd, vsg;
    VALUE argv2[4];

    rb_scan_args(argc, argv, "31", &vy, &vm, &vd, &vsg);

    argv2[0] = vy;
    argv2[1] = vm;
    argv2[2] = vd;
    if (argc < 4)
  argv2[3] = INT2FIX(DEFAULT_SG);
    else
  argv2[3] = vsg;

    if (NIL_P(valid_civil_sub(4, argv2, klass, 0)))
  return Qfalse;
    return Qtrue;
}

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

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

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

See also jd and commercial.

Returns:

  • (Boolean)

Returns:

  • (Boolean)

2685
2686
2687
2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
# File 'date_core.c', line 2685

static VALUE
date_s_valid_commercial_p(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vw, vd, vsg;
    VALUE argv2[4];

    rb_scan_args(argc, argv, "31", &vy, &vw, &vd, &vsg);

    argv2[0] = vy;
    argv2[1] = vw;
    argv2[2] = vd;
    if (argc < 4)
  argv2[3] = INT2FIX(DEFAULT_SG);
    else
  argv2[3] = vsg;

    if (NIL_P(valid_commercial_sub(4, argv2, klass, 0)))
  return Qfalse;
    return Qtrue;
}

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

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

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

See also jd and civil.

Overloads:

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

    Returns:

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

    Returns:

    • (Boolean)

Returns:

  • (Boolean)

2522
2523
2524
2525
2526
2527
2528
2529
2530
2531
2532
2533
2534
2535
2536
2537
2538
2539
2540
2541
# File 'date_core.c', line 2522

static VALUE
date_s_valid_civil_p(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vm, vd, vsg;
    VALUE argv2[4];

    rb_scan_args(argc, argv, "31", &vy, &vm, &vd, &vsg);

    argv2[0] = vy;
    argv2[1] = vm;
    argv2[2] = vd;
    if (argc < 4)
  argv2[3] = INT2FIX(DEFAULT_SG);
    else
  argv2[3] = vsg;

    if (NIL_P(valid_civil_sub(4, argv2, klass, 0)))
  return Qfalse;
    return Qtrue;
}

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

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

Date.valid_jd?(2451944)   #=> true

See also jd.

Returns:

  • (Boolean)

Returns:

  • (Boolean)

2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
# File 'date_core.c', line 2433

static VALUE
date_s_valid_jd_p(int argc, VALUE *argv, VALUE klass)
{
    VALUE vjd, vsg;
    VALUE argv2[2];

    rb_scan_args(argc, argv, "11", &vjd, &vsg);

    argv2[0] = vjd;
    if (argc < 2)
  argv2[1] = INT2FIX(DEFAULT_SG);
    else
  argv2[1] = vsg;

    if (NIL_P(valid_jd_sub(2, argv2, klass, 0)))
  return Qfalse;
    return Qtrue;
}

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

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

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

See also jd and ordinal.

Returns:

  • (Boolean)

Returns:

  • (Boolean)

2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
# File 'date_core.c', line 2603

static VALUE
date_s_valid_ordinal_p(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vd, vsg;
    VALUE argv2[3];

    rb_scan_args(argc, argv, "21", &vy, &vd, &vsg);

    argv2[0] = vy;
    argv2[1] = vd;
    if (argc < 3)
  argv2[2] = INT2FIX(DEFAULT_SG);
    else
  argv2[2] = vsg;

    if (NIL_P(valid_ordinal_sub(3, argv2, klass, 0)))
  return Qfalse;
    return Qtrue;
}

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

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

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

4442
4443
4444
4445
4446
4447
4448
4449
4450
4451
4452
4453
4454
4455
4456
4457
4458
4459
4460
# File 'date_core.c', line 4442

static VALUE
date_s_xmlschema(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg;

    rb_scan_args(argc, argv, "02", &str, &sg);

    switch (argc) {
      case 0:
  str = rb_str_new2("-4712-01-01");
      case 1:
  sg = INT2FIX(DEFAULT_SG);
    }

    {
  VALUE hash = date_s__xmlschema(klass, str);
  return d_new_by_frags(klass, hash, sg);
    }
}

Instance Method Details

#+(other) ⇒ Object

Returns a date object pointing other days after self. The other should be a numeric value. If the other is flonum, assumes its precision is at most nanosecond.

Date.new(2001,2,3) + 1  #=> #<Date: 2001-02-04 ...>
DateTime.new(2001,2,3) + Rational(1,2)

#=> #<DateTime: 2001-02-03T12:00:00+00:00 …>

DateTime.new(2001,2,3) + Rational(-1,2)

#=> #<DateTime: 2001-02-02T12:00:00+00:00 …>

DateTime.jd(0,12) + DateTime.new(2001,2,3).ajd

#=> #<DateTime: 2001-02-03T00:00:00+00:00 …>


5456
5457
5458
5459
5460
5461
5462
5463
5464
5465
5466
5467
5468
5469
5470
5471
5472
5473
5474
5475
5476
5477
5478
5479
5480
5481
5482
5483
5484
5485
5486
5487
5488
5489
5490
5491
5492
5493
5494
5495
5496
5497
5498
5499
5500
5501
5502
5503
5504
5505
5506
5507
5508
5509
5510
5511
5512
5513
5514
5515
5516
5517
5518
5519
5520
5521
5522
5523
5524
5525
5526
5527
5528
5529
5530
5531
5532
5533
5534
5535
5536
5537
5538
5539
5540
5541
5542
5543
5544
5545
5546
5547
5548
5549
5550
5551
5552
5553
5554
5555
5556
5557
5558
5559
5560
5561
5562
5563
5564
5565
5566
5567
5568
5569
5570
5571
5572
5573
5574
5575
5576
5577
5578
5579
5580
5581
5582
5583
5584
5585
5586
5587
5588
5589
5590
5591
5592
5593
5594
5595
5596
5597
5598
5599
5600
5601
5602
5603
5604
5605
5606
5607
5608
5609
5610
5611
5612
5613
5614
5615
5616
5617
5618
5619
5620
5621
5622
5623
5624
5625
5626
5627
5628
5629
5630
5631
5632
5633
5634
5635
5636
5637
5638
5639
5640
5641
5642
5643
5644
5645
5646
5647
5648
5649
5650
5651
5652
5653
5654
5655
5656
5657
5658
5659
5660
5661
5662
5663
5664
5665
5666
5667
5668
5669
5670
5671
5672
5673
5674
5675
5676
5677
5678
5679
5680
5681
5682
5683
5684
5685
5686
5687
5688
5689
5690
5691
5692
5693
5694
5695
5696
5697
5698
5699
5700
5701
5702
5703
5704
5705
5706
5707
5708
5709
5710
5711
5712
5713
5714
5715
5716
5717
5718
5719
5720
5721
5722
5723
5724
5725
5726
5727
5728
5729
5730
5731
5732
5733
5734
5735
5736
5737
5738
5739
5740
5741
5742
5743
5744
5745
5746
5747
5748
5749
5750
5751
5752
5753
5754
5755
5756
5757
5758
5759
5760
5761
5762
5763
5764
5765
5766
5767
5768
5769
5770
5771
5772
5773
5774
5775
5776
5777
5778
5779
5780
5781
5782
5783
5784
5785
5786
5787
5788
5789
5790
5791
5792
5793
5794
5795
5796
5797
5798
5799
5800
# File 'date_core.c', line 5456

static VALUE
d_lite_plus(VALUE self, VALUE other)
{
    get_d1(self);

    switch (TYPE(other)) {
      case T_FIXNUM:
  {
      VALUE nth;
      long t;
      int jd;

      nth = m_nth(dat);
      t = FIX2LONG(other);
      if (DIV(t, CM_PERIOD)) {
    nth = f_add(nth, INT2FIX(DIV(t, CM_PERIOD)));
    t = MOD(t, CM_PERIOD);
      }

      if (!t)
    jd = m_jd(dat);
      else {
    jd = m_jd(dat) + (int)t;

    if (jd < 0) {
        nth = f_sub(nth, INT2FIX(1));
        jd += CM_PERIOD;
    }
    else if (jd >= CM_PERIOD) {
        nth = f_add(nth, INT2FIX(1));
        jd -= CM_PERIOD;
    }
      }

      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;
    if (jd < 0) {
        nth = f_sub(nth, INT2FIX(1));
        jd += CM_PERIOD;
    }
    else if (jd >= CM_PERIOD) {
        nth = f_add(nth, INT2FIX(1));
        jd -= CM_PERIOD;
    }
      }

      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;
    if (jd < 0) {
        nth = f_sub(nth, INT2FIX(1));
        jd += CM_PERIOD;
    }
    else if (jd >= CM_PERIOD) {
        nth = f_add(nth, INT2FIX(1));
        jd -= CM_PERIOD;
    }
      }

      if (f_zero_p(nth))
    nth = m_nth(dat);
      else
    nth = f_add(m_nth(dat), nth);

      if (!df && f_zero_p(sf) && !m_of(dat))
    return d_simple_new_internal(rb_obj_class(self),
               nth, (int)jd,
               m_sg(dat),
               0, 0, 0,
               (dat->s.flags | HAVE_JD) &
               ~(HAVE_CIVIL | HAVE_TIME |
                 COMPLEX_DAT));
      else
    return d_complex_new_internal(rb_obj_class(self),
                nth, (int)jd,
                df, sf,
                m_of(dat), m_sg(dat),
                0, 0, 0,
                0, 0, 0,
                (dat->c.flags |
                 HAVE_JD | HAVE_DF) &
                ~(HAVE_CIVIL | HAVE_TIME));
  }
  break;
      default:
  if (!k_numeric_p(other))
      rb_raise(rb_eTypeError, "expected numeric");
  other = f_to_r(other);
#ifdef CANONICALIZATION_FOR_MATHN
  if (!k_rational_p(other))
      return d_lite_plus(self, other);
#endif
  /* fall through */
      case T_RATIONAL:
  {
      VALUE nth, sf, t;
      int jd, df, s;

      if (wholenum_p(other))
    return d_lite_plus(self, RRATIONAL(other)->num);

      if (f_positive_p(other))
    s = +1;
      else {
    s = -1;
    other = f_negate(other);
      }

      nth = f_idiv(other, INT2FIX(CM_PERIOD));
      t = f_mod(other, INT2FIX(CM_PERIOD));

      jd = FIX2INT(f_idiv(t, INT2FIX(1)));
      t = f_mod(t, INT2FIX(1));

      t = f_mul(t, INT2FIX(DAY_IN_SECONDS));
      df = FIX2INT(f_idiv(t, INT2FIX(1)));
      t = f_mod(t, INT2FIX(1));

      sf = f_mul(t, INT2FIX(SECOND_IN_NANOSECONDS));

      if (s < 0) {
    nth = f_negate(nth);
    jd = -jd;
    df = -df;
    sf = f_negate(sf);
      }

      if (f_zero_p(sf))
    sf = m_sf(dat);
      else {
    sf = f_add(m_sf(dat), sf);
    if (f_lt_p(sf, INT2FIX(0))) {
        df -= 1;
        sf = f_add(sf, INT2FIX(SECOND_IN_NANOSECONDS));
    }
    else if (f_ge_p(sf, INT2FIX(SECOND_IN_NANOSECONDS))) {
        df += 1;
        sf = f_sub(sf, INT2FIX(SECOND_IN_NANOSECONDS));
    }
      }

      if (!df)
    df = m_df(dat);
      else {
    df = m_df(dat) + df;
    if (df < 0) {
        jd -= 1;
        df += DAY_IN_SECONDS;
    }
    else if (df >= DAY_IN_SECONDS) {
        jd += 1;
        df -= DAY_IN_SECONDS;
    }
      }

      if (!jd)
    jd = m_jd(dat);
      else {
    jd = m_jd(dat) + jd;
    if (jd < 0) {
        nth = f_sub(nth, INT2FIX(1));
        jd += CM_PERIOD;
    }
    else if (jd >= CM_PERIOD) {
        nth = f_add(nth, INT2FIX(1));
        jd -= CM_PERIOD;
    }
      }

      if (f_zero_p(nth))
    nth = m_nth(dat);
      else
    nth = f_add(m_nth(dat), nth);

      if (!df && f_zero_p(sf) && !m_of(dat))
    return d_simple_new_internal(rb_obj_class(self),
               nth, jd,
               m_sg(dat),
               0, 0, 0,
               (dat->s.flags | HAVE_JD) &
               ~(HAVE_CIVIL | HAVE_TIME |
                 COMPLEX_DAT));
      else
    return d_complex_new_internal(rb_obj_class(self),
                nth, jd,
                df, sf,
                m_of(dat), m_sg(dat),
                0, 0, 0,
                0, 0, 0,
                (dat->c.flags |
                 HAVE_JD | HAVE_DF) &
                ~(HAVE_CIVIL | HAVE_TIME));
  }
  break;
    }
}

#-(other) ⇒ Object

Returns the difference between the two dates if the other is a date object. If the other is a numeric value, returns a date object pointing other days before self. If the other is flonum, assumes its precision is at most nanosecond.

Date.new(2001,2,3) - 1  #=> #<Date: 2001-02-02 ...>
DateTime.new(2001,2,3) - Rational(1,2)

#=> #<DateTime: 2001-02-02T12:00:00+00:00 …>

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

#=> (33/1)

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

#=> (1/2)


5878
5879
5880
5881
5882
5883
5884
5885
5886
5887
5888
5889
5890
5891
5892
5893
5894
5895
5896
5897
# File 'date_core.c', line 5878

static VALUE
d_lite_minus(VALUE self, VALUE other)
{
    if (k_date_p(other))
  return minus_dd(self, other);

    switch (TYPE(other)) {
      case T_FIXNUM:
  return d_lite_plus(self, LONG2NUM(-FIX2LONG(other)));
      case T_FLOAT:
  return d_lite_plus(self, DBL2NUM(-RFLOAT_VALUE(other)));
      default:
  if (!k_numeric_p(other))
      rb_raise(rb_eTypeError, "expected numeric");
  /* fall through */
      case T_BIGNUM:
      case T_RATIONAL:
  return d_lite_plus(self, f_negate(other));
    }
}

#<<(n) ⇒ Object

Returns a date object pointing n months before self. The n should be a numeric value.

Date.new(2001,2,3) << 1 #=> #<Date: 2001-01-03 ...>
Date.new(2001,1,31) << 11 #=> #<Date: 2000-02-29 ...>
Date.new(2001,2,3) << -1  #=> #<Date: 2001-03-03 ...>

6006
6007
6008
6009
6010
# File 'date_core.c', line 6006

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

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

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

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

See also Comparable.

Returns:

  • (-1, 0, +1, nil)

6261
6262
6263
6264
6265
6266
6267
6268
6269
6270
6271
6272
6273
6274
6275
6276
6277
6278
6279
6280
6281
6282
6283
6284
6285
6286
6287
6288
6289
6290
6291
6292
6293
6294
6295
6296
6297
6298
6299
6300
6301
6302
6303
6304
6305
6306
6307
6308
6309
6310
6311
6312
6313
6314
6315
6316
6317
6318
6319
6320
6321
6322
6323
6324
6325
6326
6327
6328
6329
6330
6331
6332
6333
6334
6335
6336
6337
6338
6339
6340
6341
6342
6343
6344
6345
6346
6347
6348
6349
6350
6351
6352
6353
6354
6355
6356
6357
6358
6359
6360
6361
6362
6363
6364
6365
6366
6367
6368
6369
6370
# File 'date_core.c', line 6261

static VALUE
d_lite_cmp(VALUE self, VALUE other)
{
    if (!k_date_p(other))
  return cmp_gen(self, other);

    {
  get_d2(self, other);

  if (!(simple_dat_p(adat) && simple_dat_p(bdat) &&
        m_gregorian_p(adat) == m_gregorian_p(bdat)))
      return cmp_dd(self, other);

  if (have_jd_p(adat) &&
      have_jd_p(bdat)) {
      VALUE a_nth, b_nth;
      int a_jd, b_jd;

      a_nth = m_nth(adat);
      b_nth = m_nth(bdat);
      if (f_eqeq_p(a_nth, b_nth)) {
    a_jd = m_jd(adat);
    b_jd = m_jd(bdat);
    if (a_jd == b_jd) {
        return INT2FIX(0);
    }
    else if (a_jd < b_jd) {
        return INT2FIX(-1);
    }
    else {
        return INT2FIX(1);
    }
      }
      else if (a_nth < b_nth) {
    return INT2FIX(-1);
      }
      else {
    return INT2FIX(1);
      }
  }
  else {
#ifndef USE_PACK
      VALUE a_nth, b_nth;
      int a_year, b_year,
    a_mon, b_mon,
    a_mday, b_mday;
#else
      VALUE a_nth, b_nth;
      int a_year, b_year,
    a_pd, b_pd;
#endif

      a_nth = m_nth(adat);
      b_nth = m_nth(bdat);
      if (f_eqeq_p(a_nth, b_nth)) {
    a_year = m_year(adat);
    b_year = m_year(bdat);
    if (a_year == b_year) {
#ifndef USE_PACK
        a_mon = m_mon(adat);
        b_mon = m_mon(bdat);
        if (a_mon == b_mon) {
      a_mday = m_mday(adat);
      b_mday = m_mday(bdat);
      if (a_mday == b_mday) {
          return INT2FIX(0);
      }
      else if (a_mday < b_mday) {
          return INT2FIX(-1);
      }
      else {
          return INT2FIX(1);
      }
        }
        else if (a_mon < b_mon) {
      return INT2FIX(-1);
        }
        else {
      return INT2FIX(1);
        }
#else
        a_pd = m_pc(adat);
        b_pd = m_pc(bdat);
        if (a_pd == b_pd) {
      return INT2FIX(0);
        }
        else if (a_pd < b_pd) {
      return INT2FIX(-1);
        }
        else {
      return INT2FIX(1);
        }
#endif
    }
    else if (a_year < b_year) {
        return INT2FIX(-1);
    }
    else {
        return INT2FIX(1);
    }
      }
      else if (f_lt_p(a_nth, b_nth)) {
    return INT2FIX(-1);
      }
      else {
    return INT2FIX(1);
      }
  }
    }
}

#===(other) ⇒ Boolean

Returns true if they are the same day.

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

#=> true

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

#=> false

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

#=> true

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

#=> true

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

#=> false

Returns:

  • (Boolean)

6401
6402
6403
6404
6405
6406
6407
6408
6409
6410
6411
6412
6413
6414
6415
6416
6417
6418
6419
6420
6421
6422
6423
6424
6425
6426
6427
6428
6429
6430
6431
6432
6433
6434
6435
6436
6437
6438
6439
6440
6441
6442
6443
6444
6445
6446
6447
6448
6449
6450
6451
6452
6453
6454
6455
6456
6457
6458
6459
6460
6461
6462
6463
6464
6465
6466
6467
# File 'date_core.c', line 6401

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);

  if (have_jd_p(adat) &&
      have_jd_p(bdat)) {
      VALUE a_nth, b_nth;
      int a_jd, b_jd;

      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;
  }
  else {
#ifndef USE_PACK
      VALUE a_nth, b_nth;
      int a_year, b_year,
    a_mon, b_mon,
    a_mday, b_mday;
#else
      VALUE a_nth, b_nth;
      int a_year, b_year,
    a_pd, b_pd;
#endif

      a_nth = m_nth(adat);
      b_nth = m_nth(bdat);
      if (f_eqeq_p(a_nth, b_nth)) {
    a_year = m_year(adat);
    b_year = m_year(bdat);
    if (a_year == b_year) {
#ifndef USE_PACK
        a_mon = m_mon(adat);
        b_mon = m_mon(bdat);
        if (a_mon == b_mon) {
      a_mday = m_mday(adat);
      b_mday = m_mday(bdat);
      if (a_mday == b_mday)
          return Qtrue;
        }
#else
        /* mon and mday only */
        a_pd = (m_pc(adat) >> MDAY_SHIFT);
        b_pd = (m_pc(bdat) >> MDAY_SHIFT);
        if (a_pd == b_pd) {
      return Qtrue;
        }
#endif
    }
      }
      return Qfalse;
  }
    }
}

#>>(n) ⇒ Object

Returns a date object pointing n months after self. The n should be a numeric value.

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

5956
5957
5958
5959
5960
5961
5962
5963
5964
5965
5966
5967
5968
5969
5970
5971
5972
5973
5974
5975
5976
5977
5978
5979
5980
5981
5982
5983
5984
5985
5986
5987
5988
5989
5990
5991
5992
5993
# File 'date_core.c', line 5956

static VALUE
d_lite_rshift(VALUE self, VALUE other)
{
    VALUE t, y, nth, rjd2;
    int m, d, rjd;
    double sg;

    get_d1(self);
    t = f_add3(f_mul(m_real_year(dat), INT2FIX(12)),
         INT2FIX(m_mon(dat) - 1),
         other);
    if (FIXNUM_P(t)) {
  long it = FIX2LONG(t);
  y = LONG2NUM(DIV(it, 12));
  it = MOD(it, 12);
  m = (int)it + 1;
    }
    else {
  y = f_idiv(t, INT2FIX(12));
  t = f_mod(t, INT2FIX(12));
  m = FIX2INT(t) + 1;
    }
    d = m_mday(dat);
    sg = m_sg(dat);

    while (1) {
  int ry, rm, rd, ns;

  if (valid_civil_p(y, m, d, sg,
        &nth, &ry,
        &rm, &rd, &rjd, &ns))
      break;
  if (--d < 1)
      rb_raise(rb_eArgError, "invalid date");
    }
    encode_jd(nth, rjd, &rjd2);
    return d_lite_plus(self, f_sub(rjd2, m_real_local_jd(dat)));
}

#ajdObject

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)

4761
4762
4763
4764
4765
4766
# File 'date_core.c', line 4761

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

#amjdObject

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)

4778
4779
4780
4781
4782
4783
# File 'date_core.c', line 4778

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

#asctimeString #ctimeString

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

See also asctime(3) or ctime(3).

Overloads:

  • #asctimeString

    Returns:

    • (String)
  • #ctimeString

    Returns:

    • (String)

7004
7005
7006
7007
7008
# File 'date_core.c', line 7004

static VALUE
d_lite_asctime(VALUE self)
{
    return strftimev("%a %b %e %H:%M:%S %Y", self, set_tmx);
}

#asctimeString #ctimeString

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

See also asctime(3) or ctime(3).

Overloads:

  • #asctimeString

    Returns:

    • (String)
  • #ctimeString

    Returns:

    • (String)

7004
7005
7006
7007
7008
# File 'date_core.c', line 7004

static VALUE
d_lite_asctime(VALUE self)
{
    return strftimev("%a %b %e %H:%M:%S %Y", self, set_tmx);
}

#cwdayFixnum

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

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

Returns:

  • (Fixnum)

4954
4955
4956
4957
4958
4959
# File 'date_core.c', line 4954

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

#cweekFixnum

Returns the calendar week number (1-53).

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

Returns:

  • (Fixnum)

4939
4940
4941
4942
4943
4944
# File 'date_core.c', line 4939

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

#cwyearInteger

Returns the calendar week based year.

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

Returns:

  • (Integer)

4924
4925
4926
4927
4928
4929
# File 'date_core.c', line 4924

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

#mdayFixnum #dayFixnum

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

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

Overloads:

  • #mdayFixnum

    Returns:

    • (Fixnum)
  • #dayFixnum

    Returns:

    • (Fixnum)

4891
4892
4893
4894
4895
4896
# File 'date_core.c', line 4891

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

#day_fractionObject

Returns the fractional part of the day.

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

4906
4907
4908
4909
4910
4911
4912
4913
# File 'date_core.c', line 4906

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)

6163
6164
6165
6166
6167
6168
6169
6170
6171
6172
6173
6174
6175
6176
# File 'date_core.c', line 6163

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

#englandObject

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


5364
5365
5366
5367
5368
# File 'date_core.c', line 5364

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

#eql?Boolean

:nodoc:

Returns:

  • (Boolean)

6470
6471
6472
6473
6474
6475
6476
# File 'date_core.c', line 6470

static VALUE
d_lite_eql_p(VALUE self, VALUE other)
{
    if (!k_date_p(other))
  return Qfalse;
    return f_zero_p(d_lite_cmp(self, other));
}

#friday?Boolean

Returns true if the date is Friday.

Returns:

  • (Boolean)

Returns:

  • (Boolean)

5063
5064
5065
5066
5067
5068
# File 'date_core.c', line 5063

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

#gregorianObject

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


5388
5389
5390
5391
5392
# File 'date_core.c', line 5388

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

#gregorian?Boolean

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

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

Returns:

  • (Boolean)

Returns:

  • (Boolean)

5221
5222
5223
5224
5225
5226
# File 'date_core.c', line 5221

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

#hashObject

:nodoc:


6479
6480
6481
6482
6483
6484
6485
6486
6487
6488
6489
6490
6491
# File 'date_core.c', line 6479

static VALUE
d_lite_hash(VALUE self)
{
    st_index_t v, h[4];

    get_d1(self);
    h[0] = m_nth(dat);
    h[1] = m_jd(dat);
    h[2] = m_df(dat);
    h[3] = m_sf(dat);
    v = rb_memhash(h, sizeof(h));
    return LONG2FIX(v);
}

#httpdateString

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

Returns:

  • (String)

7055
7056
7057
7058
7059
7060
# File 'date_core.c', line 7055

static VALUE
d_lite_httpdate(VALUE self)
{
    volatile VALUE dup = dup_obj_with_new_offset(self, 0);
    return strftimev("%a, %d %b %Y %T GMT", dup, set_tmx);
}

#initialize_copyObject

:nodoc:


4705
4706
4707
4708
4709
4710
4711
4712
4713
4714
4715
4716
4717
4718
4719
4720
4721
4722
4723
4724
4725
4726
4727
4728
4729
# File 'date_core.c', line 4705

static VALUE
d_lite_initialize_copy(VALUE copy, VALUE date)
{
    rb_check_frozen(copy);
    rb_check_trusted(copy);

    if (copy == date)
  return copy;
    {
  get_d2(copy, date);
  if (simple_dat_p(bdat)) {
      adat->s = bdat->s;
      adat->s.flags &= ~COMPLEX_DAT;
  }
  else {
      if (!complex_dat_p(adat))
    rb_raise(rb_eArgError,
       "cannot load complex into simple");

      adat->c = bdat->c;
      adat->c.flags |= COMPLEX_DAT;
  }
    }
    return copy;
}

#inspectString

Returns the value as a string for inspection.

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

#=> “#<Date: 2001-02-03 ((2451944j,0s,0n),+0s,2299161j)>”

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

#=> “#<DateTime: 2001-02-03T04:05:06-07:00 ((2451944j,39906s,0n),-25200s,2299161j)>”

Returns:

  • (String)

6612
6613
6614
6615
6616
6617
6618
6619
6620
6621
6622
# File 'date_core.c', line 6612

static VALUE
d_lite_inspect(VALUE self)
{
    get_d1(self);
    {
  VALUE to_s;

  RB_GC_GUARD(to_s) = f_to_s(self);
  return mk_inspect(dat, rb_obj_classname(self), RSTRING_PTR(to_s));
    }
}

#iso8601String #xmlschemaString

This method is equivalent to strftime('%F').

Overloads:

  • #iso8601String

    Returns:

    • (String)
  • #xmlschemaString

    Returns:

    • (String)

7017
7018
7019
7020
7021
# File 'date_core.c', line 7017

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

#italyObject

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


5352
5353
5354
5355
5356
# File 'date_core.c', line 5352

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

#jdInteger

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)

4795
4796
4797
4798
4799
4800
# File 'date_core.c', line 4795

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

#jisx0301String

Returns a string in a JIS X 0301 format.

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

Returns:

  • (String)

7096
7097
7098
7099
7100
7101
7102
7103
7104
7105
# File 'date_core.c', line 7096

static VALUE
d_lite_jisx0301(VALUE self)
{
    VALUE s;

    get_d1(self);
    s = jisx0301_date(m_real_local_jd(dat),
          m_real_year(dat));
    return strftimev(RSTRING_PTR(s), self, set_tmx);
}

#julianObject

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


5376
5377
5378
5379
5380
# File 'date_core.c', line 5376

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

#julian?Boolean

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

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

Returns:

  • (Boolean)

Returns:

  • (Boolean)

5205
5206
5207
5208
5209
5210
# File 'date_core.c', line 5205

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

#ldInteger

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)

4828
4829
4830
4831
4832
4833
# File 'date_core.c', line 4828

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)

Returns:

  • (Boolean)

5237
5238
5239
5240
5241
5242
5243
5244
5245
5246
5247
5248
5249
5250
# File 'date_core.c', line 5237

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_dumpObject

:nodoc:


7130
7131
7132
7133
7134
7135
7136
7137
7138
7139
7140
7141
7142
7143
7144
7145
7146
7147
7148
7149
7150
7151
# File 'date_core.c', line 7130

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_loadObject

:nodoc:


7154
7155
7156
7157
7158
7159
7160
7161
7162
7163
7164
7165
7166
7167
7168
7169
7170
7171
7172
7173
7174
7175
7176
7177
7178
7179
7180
7181
7182
7183
7184
7185
7186
7187
7188
7189
7190
7191
7192
7193
7194
7195
7196
7197
7198
7199
7200
7201
7202
7203
7204
7205
7206
7207
7208
7209
7210
7211
7212
7213
7214
7215
7216
7217
7218
7219
7220
7221
7222
7223
7224
7225
7226
7227
7228
7229
7230
7231
7232
7233
7234
7235
7236
7237
7238
7239
# File 'date_core.c', line 7154

static VALUE
d_lite_marshal_load(VALUE self, VALUE a)
{
    get_d1(self);

    rb_check_frozen(self);
    rb_check_trusted(self);

    if (TYPE(a) != T_ARRAY)
  rb_raise(rb_eTypeError, "expected an array");

    switch (RARRAY_LEN(a)) {
      case 2: /* 1.6.x */
      case 3: /* 1.8.x, 1.9.2 */
  {
      VALUE ajd, of, sg, nth, sf;
      int jd, df, rof;
      double rsg;


      if  (RARRAY_LEN(a) == 2) {
    ajd = f_sub(RARRAY_PTR(a)[0], half_days_in_day);
    of = INT2FIX(0);
    sg = RARRAY_PTR(a)[1];
    if (!k_numeric_p(sg))
        sg = DBL2NUM(RTEST(sg) ? GREGORIAN : JULIAN);
      }
      else {
    ajd = RARRAY_PTR(a)[0];
    of = RARRAY_PTR(a)[1];
    sg = RARRAY_PTR(a)[2];
      }

      old_to_new(ajd, of, sg,
           &nth, &jd, &df, &sf, &rof, &rsg);

      if (!df && f_zero_p(sf) && !rof) {
    set_to_simple(&dat->s, nth, jd, rsg, 0, 0, 0, HAVE_JD);
      } else {
    if (!complex_dat_p(dat))
        rb_raise(rb_eArgError,
           "cannot load complex into simple");

    set_to_complex(&dat->c, nth, jd, df, sf, rof, rsg,
             0, 0, 0, 0, 0, 0,
             HAVE_JD | HAVE_DF | COMPLEX_DAT);
      }
  }
  break;
      case 6:
  {
      VALUE nth, sf;
      int jd, df, of;
      double sg;

      nth = RARRAY_PTR(a)[0];
      jd = NUM2INT(RARRAY_PTR(a)[1]);
      df = NUM2INT(RARRAY_PTR(a)[2]);
      sf = RARRAY_PTR(a)[3];
      of = NUM2INT(RARRAY_PTR(a)[4]);
      sg = NUM2DBL(RARRAY_PTR(a)[5]);
      if (!df && f_zero_p(sf) && !of) {
    set_to_simple(&dat->s, nth, jd, sg, 0, 0, 0, HAVE_JD);
      } else {
    if (!complex_dat_p(dat))
        rb_raise(rb_eArgError,
           "cannot load complex into simple");

    set_to_complex(&dat->c, nth, jd, df, sf, of, sg,
             0, 0, 0, 0, 0, 0,
             HAVE_JD | HAVE_DF | COMPLEX_DAT);
      }
  }
  break;
      default:
  rb_raise(rb_eTypeError, "invalid size");
  break;
    }

    if (FL_TEST(a, FL_EXIVAR)) {
  rb_copy_generic_ivar(self, a);
  FL_SET(self, FL_EXIVAR);
    }

    return self;
}

#mdayFixnum #dayFixnum

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

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

Overloads:

  • #mdayFixnum

    Returns:

    • (Fixnum)
  • #dayFixnum

    Returns:

    • (Fixnum)

4891
4892
4893
4894
4895
4896
# File 'date_core.c', line 4891

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

#mjdInteger

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)

4812
4813
4814
4815
4816
4817
# File 'date_core.c', line 4812

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

#monFixnum #monthFixnum

Returns the month (1-12).

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

Overloads:

  • #monFixnum

    Returns:

    • (Fixnum)
  • #monthFixnum

    Returns:

    • (Fixnum)

4875
4876
4877
4878
4879
4880
# File 'date_core.c', line 4875

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)

Returns:

  • (Boolean)

5011
5012
5013
5014
5015
5016
# File 'date_core.c', line 5011

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

#monFixnum #monthFixnum

Returns the month (1-12).

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

Overloads:

  • #monFixnum

    Returns:

    • (Fixnum)
  • #monthFixnum

    Returns:

    • (Fixnum)

4875
4876
4877
4878
4879
4880
# File 'date_core.c', line 4875

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

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

Duplicates self and resets its the day of calendar reform.

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

5331
5332
5333
5334
5335
5336
5337
5338
5339
5340
5341
5342
5343
5344
# File 'date_core.c', line 5331

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

#nextObject

Returns a date object denoting the following day.


5939
5940
5941
5942
5943
# File 'date_core.c', line 5939

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.


5905
5906
5907
5908
5909
5910
5911
5912
5913
5914
# File 'date_core.c', line 5905

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


6018
6019
6020
6021
6022
6023
6024
6025
6026
6027
# File 'date_core.c', line 6018

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)


6052
6053
6054
6055
6056
6057
6058
6059
6060
6061
# File 'date_core.c', line 6052

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

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

#prev_day([n = 1]) ⇒ Object

This method is equivalent to d - n.


5922
5923
5924
5925
5926
5927
5928
5929
5930
5931
# File 'date_core.c', line 5922

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


6035
6036
6037
6038
6039
6040
6041
6042
6043
6044
# File 'date_core.c', line 6035

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)


6069
6070
6071
6072
6073
6074
6075
6076
6077
6078
# File 'date_core.c', line 6069

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

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

#rfc2822String #rfc822String

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

Overloads:

  • #rfc2822String

    Returns:

    • (String)
  • #rfc822String

    Returns:

    • (String)

7042
7043
7044
7045
7046
# File 'date_core.c', line 7042

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

#rfc3339String

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

Returns:

  • (String)

7029
7030
7031
7032
7033
# File 'date_core.c', line 7029

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

#rfc2822String #rfc822String

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

Overloads:

  • #rfc2822String

    Returns:

    • (String)
  • #rfc822String

    Returns:

    • (String)

7042
7043
7044
7045
7046
# File 'date_core.c', line 7042

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)

Returns:

  • (Boolean)

5076
5077
5078
5079
5080
5081
# File 'date_core.c', line 5076

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

#startFloat

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)

5261
5262
5263
5264
5265
5266
# File 'date_core.c', line 5261

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)

6093
6094
6095
6096
6097
6098
6099
6100
6101
6102
6103
6104
6105
6106
6107
6108
6109
6110
6111
6112
6113
6114
6115
6116
6117
6118
6119
6120
6121
6122
6123
6124
6125
6126
6127
6128
6129
6130
6131
6132
# File 'date_core.c', line 6093

static VALUE
d_lite_step(int argc, VALUE *argv, VALUE self)
{
    VALUE limit, step, date;

    rb_scan_args(argc, argv, "11", &limit, &step);

    if (argc < 2)
  step = INT2FIX(1);

#if 0
    if (f_zero_p(step))
  rb_raise(rb_eArgError, "step can't be 0");
#endif

    RETURN_ENUMERATOR(self, argc, argv);

    date = self;
    switch (FIX2INT(f_cmp(step, INT2FIX(0)))) {
      case -1:
  while (FIX2INT(d_lite_cmp(date, limit)) >= 0) {
      rb_yield(date);
      date = d_lite_plus(date, step);
  }
  break;
      case 0:
  while (1)
      rb_yield(date);
  break;
      case 1:
  while (FIX2INT(d_lite_cmp(date, limit)) <= 0) {
      rb_yield(date);
      date = d_lite_plus(date, step);
  }
  break;
      default:
  abort();
    }
    return self;
}

#strftime([format = '%F']) ⇒ String

Formats date according to the directives in the given format

string.
The directives begins with a percent (%) character.
Any text not listed as a directive will be passed through to the
output string.

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

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

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

The minimum field width specifies the minimum width.

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

Format directives:

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

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

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

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

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

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

    %S - Second of the minute (00..59)

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

  Time zone:
    %z - Time zone as hour and minute offset from UTC (e.g. +0900)
            %:z - hour and minute offset from UTC with a colon (e.g. +09:00)
            %::z - hour, minute and second offset from UTC (e.g. +09:00:00)
            %:::z - hour, minute and second offset from UTC
                                              (e.g. +09, +09:30, +09:30:30)
    %Z - Time zone abbreviation name or something similar information.

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

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

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

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

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

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

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

Examples:

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

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

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

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

See also strftime(3) and strptime.

Returns:

  • (String)

6971
6972
6973
6974
6975
6976
# File 'date_core.c', line 6971

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

#nextObject

Returns a date object denoting the following day.


5939
5940
5941
5942
5943
# File 'date_core.c', line 5939

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)

Returns:

  • (Boolean)

4998
4999
5000
5001
5002
5003
# File 'date_core.c', line 4998

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)

Returns:

  • (Boolean)

5050
5051
5052
5053
5054
5055
# File 'date_core.c', line 5050

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

#to_dateself

Returns self;

Returns:

  • (self)

8617
8618
8619
8620
8621
# File 'date_core.c', line 8617

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

#to_datetimeObject

Returns a DateTime object which denotes self.


8629
8630
8631
8632
8633
8634
8635
8636
8637
8638
8639
8640
8641
8642
8643
8644
8645
8646
8647
8648
8649
8650
8651
8652
8653
8654
8655
8656
8657
8658
8659
8660
8661
# File 'date_core.c', line 8629

static VALUE
date_to_datetime(VALUE self)
{
    get_d1a(self);

    if (simple_dat_p(adat)) {
  VALUE new = d_lite_s_alloc_simple(cDateTime);
  {
      get_d1b(new);
      bdat->s = adat->s;
      return new;
  }
    }
    else {
  VALUE new = d_lite_s_alloc_complex(cDateTime);
  {
      get_d1b(new);
      bdat->c = adat->c;
      bdat->c.df = 0;
      bdat->c.sf = INT2FIX(0);
#ifndef USE_PACK
      bdat->c.hour = 0;
      bdat->c.min = 0;
      bdat->c.sec = 0;
#else
      bdat->c.pc = PACK5(EX_MON(adat->c.pc), EX_MDAY(adat->c.pc),
             0, 0, 0);
      bdat->c.flags |= HAVE_DF | HAVE_TIME;
#endif
      return new;
  }
    }
}

#to_sString

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)

6507
6508
6509
6510
6511
# File 'date_core.c', line 6507

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

#to_timeTime

Returns a Time object which denotes self.

Returns:

  • (Time)

8600
8601
8602
8603
8604
8605
8606
8607
8608
8609
# File 'date_core.c', line 8600

static VALUE
date_to_time(VALUE self)
{
    get_d1(self);

    return f_local3(rb_cTime,
        m_real_year(dat),
        INT2FIX(m_mon(dat)),
        INT2FIX(m_mday(dat)));
}

#tuesday?Boolean

Returns true if the date is Tuesday.

Returns:

  • (Boolean)

Returns:

  • (Boolean)

5024
5025
5026
5027
5028
5029
# File 'date_core.c', line 5024

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)

6141
6142
6143
6144
6145
6146
6147
6148
6149
6150
6151
6152
6153
6154
# File 'date_core.c', line 6141

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

#wdayFixnum

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

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

Returns:

  • (Fixnum)

4985
4986
4987
4988
4989
4990
# File 'date_core.c', line 4985

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)

Returns:

  • (Boolean)

5037
5038
5039
5040
5041
5042
# File 'date_core.c', line 5037

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

#iso8601String #xmlschemaString

This method is equivalent to strftime('%F').

Overloads:

  • #iso8601String

    Returns:

    • (String)
  • #xmlschemaString

    Returns:

    • (String)

7017
7018
7019
7020
7021
# File 'date_core.c', line 7017

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

#ydayFixnum

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

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

Returns:

  • (Fixnum)

4859
4860
4861
4862
4863
4864
# File 'date_core.c', line 4859

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

#yearInteger

Returns the year.

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

Returns:

  • (Integer)

4844
4845
4846
4847
4848
4849
# File 'date_core.c', line 4844

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