Class: Date

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

Direct Known Subclasses

DateTime

Defined Under Namespace

Classes: Infinity

Constant Summary collapse

MONTHNAMES =

An array of strings of full month names in English. The first element is nil.

mk_ary_of_str(13, monthnames)
ABBR_MONTHNAMES =

An array of strings of abbreviated month names in English. The first element is nil.

mk_ary_of_str(13, abbr_monthnames)
DAYNAMES =

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

mk_ary_of_str(7, daynames)
ABBR_DAYNAMES =

An array of strings of abbreviated day names in English. The first is “Sun”.

mk_ary_of_str(7, abbr_daynames)
ITALY =

The Julian day number of the day of calendar reform for Italy and some catholic countries.

INT2FIX(ITALY)
ENGLAND =

The Julian day number of the day of calendar reform for England and her colonies.

INT2FIX(ENGLAND)
JULIAN =

The Julian day number of the day of calendar reform for the proleptic Julian calendar.

DBL2NUM(JULIAN)
GREGORIAN =

The Julian day number of the day of calendar reform for the proleptic Gregorian calendar.

DBL2NUM(GREGORIAN)

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

._httpdate(string) ⇒ Hash

Returns a hash of parsed elements.

Returns:

  • (Hash) 


4564
4565
4566
4567
4568
 
# File 'ext/date/date_core.c', line 4564

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

._iso8601(string) ⇒ Hash

Returns a hash of parsed elements.

Returns:

  • (Hash) 


4395
4396
4397
4398
4399
 
# File 'ext/date/date_core.c', line 4395

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

._jisx0301(string) ⇒ Hash

Returns a hash of parsed elements.

Returns:

  • (Hash) 


4606
4607
4608
4609
4610
 
# File 'ext/date/date_core.c', line 4606

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

._load(s) ⇒ Object

:nodoc:



7189
7190
7191
7192
7193
7194
7195
7196
7197
 
# File 'ext/date/date_core.c', line 7189

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) 


4335
4336
4337
4338
4339
 
# File 'ext/date/date_core.c', line 4335

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) 


4521
4522
4523
4524
4525
 
# File 'ext/date/date_core.c', line 4521

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

._rfc3339(string) ⇒ Hash

Returns a hash of parsed elements.

Returns:

  • (Hash) 


4438
4439
4440
4441
4442
 
# File 'ext/date/date_core.c', line 4438

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) 


4521
4522
4523
4524
4525
 
# File 'ext/date/date_core.c', line 4521

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) 


4241
4242
4243
4244
4245
 
# File 'ext/date/date_core.c', line 4241

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) 


4479
4480
4481
4482
4483
 
# File 'ext/date/date_core.c', line 4479

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.



3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
 
# File 'ext/date/date_core.c', line 3385

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.



3462
3463
3464
3465
3466
3467
3468
3469
3470
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484
3485
3486
3487
3488
3489
3490
3491
3492
3493
3494
3495
3496
3497
3498
3499
3500
3501
3502
3503
3504
3505
3506
 
# File 'ext/date/date_core.c', line 3462

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) 


2923
2924
2925
2926
2927
2928
2929
2930
2931
 
# File 'ext/date/date_core.c', line 2923

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=Date::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 …>



4580
4581
4582
4583
4584
4585
4586
4587
4588
4589
4590
4591
4592
4593
4594
4595
4596
4597
4598
 
# File 'ext/date/date_core.c', line 4580

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=Date::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 ...>



4412
4413
4414
4415
4416
4417
4418
4419
4420
4421
4422
4423
4424
4425
4426
4427
4428
4429
4430
 
# File 'ext/date/date_core.c', line 4412

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.



3267
3268
3269
3270
3271
3272
3273
3274
3275
3276
3277
3278
3279
3280
3281
3282
3283
3284
3285
3286
3287
3288
3289
3290
3291
3292
3293
3294
3295
3296
3297
3298
3299
 
# File 'ext/date/date_core.c', line 3267

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=Date::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 ...>



4621
4622
4623
4624
4625
4626
4627
4628
4629
4630
4631
4632
4633
4634
4635
4636
4637
4638
4639
 
# File 'ext/date/date_core.c', line 4621

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) 


2902
2903
2904
2905
2906
2907
2908
2909
2910
 
# File 'ext/date/date_core.c', line 2902

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) 


2923
2924
2925
2926
2927
2928
2929
2930
2931
 
# File 'ext/date/date_core.c', line 2923

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.



3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
 
# File 'ext/date/date_core.c', line 3385

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.



3317
3318
3319
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
 
# File 'ext/date/date_core.c', line 3317

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=Date::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 ...>



4356
4357
4358
4359
4360
4361
4362
4363
4364
4365
4366
4367
4368
4369
4370
4371
4372
4373
4374
4375
4376
4377
4378
4379
4380
 
# File 'ext/date/date_core.c', line 4356

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=Date::ITALY]) ⇒ Object .rfc822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::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 …>



4538
4539
4540
4541
4542
4543
4544
4545
4546
4547
4548
4549
4550
4551
4552
4553
4554
4555
4556
 
# File 'ext/date/date_core.c', line 4538

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=Date::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 ...>



4453
4454
4455
4456
4457
4458
4459
4460
4461
4462
4463
4464
4465
4466
4467
4468
4469
4470
4471
 
# File 'ext/date/date_core.c', line 4453

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=Date::ITALY]) ⇒ Object .rfc822(string = 'Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::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 …>



4538
4539
4540
4541
4542
4543
4544
4545
4546
4547
4548
4549
4550
4551
4552
4553
4554
4555
4556
 
# File 'ext/date/date_core.c', line 4538

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=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 ...>

See also strptime(3) and #strftime.



4265
4266
4267
4268
4269
4270
4271
4272
4273
4274
4275
4276
4277
4278
4279
4280
4281
4282
4283
4284
4285
4286
4287
4288
4289
 
# File 'ext/date/date_core.c', line 4265

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

Creates a date object denoting the present day.

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



3638
3639
3640
3641
3642
3643
3644
3645
3646
3647
3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676
 
# File 'ext/date/date_core.c', line 3638

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) 


2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
 
# File 'ext/date/date_core.c', line 2556

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) 


2719
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730
2731
2732
2733
2734
2735
2736
2737
2738
 
# File 'ext/date/date_core.c', line 2719

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) 


2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
 
# File 'ext/date/date_core.c', line 2556

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) 


2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
 
# File 'ext/date/date_core.c', line 2467

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) 


2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
2654
2655
 
# File 'ext/date/date_core.c', line 2637

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=Date::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 ...>



4494
4495
4496
4497
4498
4499
4500
4501
4502
4503
4504
4505
4506
4507
4508
4509
4510
4511
4512
 
# File 'ext/date/date_core.c', line 4494

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 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 …>



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
5801
5802
5803
5804
5805
5806
5807
5808
5809
5810
5811
5812
5813
5814
5815
5816
5817
5818
5819
5820
5821
5822
5823
5824
5825
5826
5827
 
# File 'ext/date/date_core.c', line 5513

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

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

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

	    if (!t)
		jd = m_jd(dat);
	    else {
		jd = m_jd(dat) + (int)t;
		canonicalize_jd(nth, jd);
	    }

	    if (simple_dat_p(dat))
		return d_simple_new_internal(rb_obj_class(self),
					     nth, jd,
					     dat->s.sg,
					     0, 0, 0,
					     (dat->s.flags | HAVE_JD) &
					     ~HAVE_CIVIL);
	    else
		return d_complex_new_internal(rb_obj_class(self),
					      nth, jd,
					      dat->c.df, dat->c.sf,
					      dat->c.of, dat->c.sg,
					      0, 0, 0,
#ifndef USE_PACK
					      dat->c.hour,
					      dat->c.min,
					      dat->c.sec,
#else
					      EX_HOUR(dat->c.pc),
					      EX_MIN(dat->c.pc),
					      EX_SEC(dat->c.pc),
#endif
					      (dat->c.flags | HAVE_JD) &
					      ~HAVE_CIVIL);
	}
	break;
      case T_BIGNUM:
	{
	    VALUE nth;
	    int jd, s;

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

	    nth = f_idiv(other, INT2FIX(CM_PERIOD));
	    jd = FIX2INT(f_mod(other, INT2FIX(CM_PERIOD)));

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

	    if (!jd)
		jd = m_jd(dat);
	    else {
		jd = m_jd(dat) + jd;
		canonicalize_jd(nth, jd);
	    }

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

	    if (simple_dat_p(dat))
		return d_simple_new_internal(rb_obj_class(self),
					     nth, jd,
					     dat->s.sg,
					     0, 0, 0,
					     (dat->s.flags | HAVE_JD) &
					     ~HAVE_CIVIL);
	    else
		return d_complex_new_internal(rb_obj_class(self),
					      nth, jd,
					      dat->c.df, dat->c.sf,
					      dat->c.of, dat->c.sg,
					      0, 0, 0,
#ifndef USE_PACK
					      dat->c.hour,
					      dat->c.min,
					      dat->c.sec,
#else
					      EX_HOUR(dat->c.pc),
					      EX_MIN(dat->c.pc),
					      EX_SEC(dat->c.pc),
#endif
					      (dat->c.flags | HAVE_JD) &
					      ~HAVE_CIVIL);
	}
	break;
      case T_FLOAT:
	{
	    double jd, o, tmp;
	    int s, df;
	    VALUE nth, sf;

	    o = RFLOAT_VALUE(other);

	    if (o > 0)
		s = +1;
	    else {
		s = -1;
		o = -o;
	    }

	    o = modf(o, &tmp);

	    if (!floor(tmp / CM_PERIOD)) {
		nth = INT2FIX(0);
		jd = (int)tmp;
	    }
	    else {
		double i, f;

		f = modf(tmp / CM_PERIOD, &i);
		nth = f_floor(DBL2NUM(i));
		jd = (int)(f * CM_PERIOD);
	    }

	    o *= DAY_IN_SECONDS;
	    o = modf(o, &tmp);
	    df = (int)tmp;
	    o *= SECOND_IN_NANOSECONDS;
	    sf = INT2FIX((int)round(o));

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

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

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

	    if (!jd)
		jd = m_jd(dat);
	    else {
		jd = m_jd(dat) + jd;
		canonicalize_jd(nth, jd);
	    }

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

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

	    if (wholenum_p(other))
		return d_lite_plus(self, rb_rational_num(other));

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

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

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

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

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

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

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

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

	    if (!jd)
		jd = m_jd(dat);
	    else {
		jd = m_jd(dat) + jd;
		canonicalize_jd(nth, jd);
	    }

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

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

#-(other) ⇒ Object

Returns the difference between the two dates if the other is a date object. If the other is a numeric value, returns a date object pointing other days before self. If the other is 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)



5897
5898
5899
5900
5901
5902
5903
5904
5905
5906
5907
5908
5909
5910
5911
5912
5913
5914
5915
 
# File 'ext/date/date_core.c', line 5897

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



6049
6050
6051
6052
6053
6054
 
# File 'ext/date/date_core.c', line 6049

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

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

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

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

See also Comparable.

Returns:

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


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
 
# File 'ext/date/date_core.c', line 6323

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

    {
	get_d2(self, other);

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

	{
	    VALUE a_nth, b_nth;
	    int a_jd, b_jd;

	    m_canonicalize_jd(self, adat);
	    m_canonicalize_jd(other, bdat);
	    a_nth = m_nth(adat);
	    b_nth = m_nth(bdat);
	    if (f_eqeq_p(a_nth, b_nth)) {
		a_jd = m_jd(adat);
		b_jd = m_jd(bdat);
		if (a_jd == b_jd) {
		    return INT2FIX(0);
		}
		else if (a_jd < b_jd) {
		    return INT2FIX(-1);
		}
		else {
		    return INT2FIX(1);
		}
	    }
	    else if (f_lt_p(a_nth, b_nth)) {
		return INT2FIX(-1);
	    }
	    else {
		return INT2FIX(1);
	    }
	}
    }
}

#===(other) ⇒ Boolean

Returns true if they are the same day.

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

#=> true

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

#=> false

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

#=> true

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

#=> true

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

#=> false

Returns:

  • (Boolean) 


6396
6397
6398
6399
6400
6401
6402
6403
6404
6405
6406
6407
6408
6409
6410
6411
6412
6413
6414
6415
6416
6417
6418
6419
6420
6421
6422
6423
6424
 
# File 'ext/date/date_core.c', line 6396

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



5987
5988
5989
5990
5991
5992
5993
5994
5995
5996
5997
5998
5999
6000
6001
6002
6003
6004
6005
6006
6007
6008
6009
6010
6011
6012
6013
6014
6015
6016
6017
6018
6019
6020
6021
6022
6023
6024
 
# File 'ext/date/date_core.c', line 5987

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

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

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

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

#ajd ⇒ Object

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)



4818
4819
4820
4821
4822
4823
 
# File 'ext/date/date_core.c', line 4818

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)



4835
4836
4837
4838
4839
4840
 
# File 'ext/date/date_core.c', line 4835

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

#asctime ⇒ String #ctime ⇒ String

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

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

Overloads:

  • #asctime ⇒ String

    Returns:

    • (String)
  • #ctime ⇒ String

    Returns:

    • (String) 


6939
6940
6941
6942
6943
 
# File 'ext/date/date_core.c', line 6939

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

#asctime ⇒ String #ctime ⇒ String

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

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

Overloads:

  • #asctime ⇒ String

    Returns:

    • (String)
  • #ctime ⇒ String

    Returns:

    • (String) 


6939
6940
6941
6942
6943
 
# File 'ext/date/date_core.c', line 6939

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

#cwday ⇒ Fixnum

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

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

Returns:

  • (Fixnum) 


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

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) 


4996
4997
4998
4999
5000
5001
 
# File 'ext/date/date_core.c', line 4996

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) 


4981
4982
4983
4984
4985
4986
 
# File 'ext/date/date_core.c', line 4981

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) 


4948
4949
4950
4951
4952
4953
 
# File 'ext/date/date_core.c', line 4948

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)



4963
4964
4965
4966
4967
4968
4969
4970
 
# File 'ext/date/date_core.c', line 4963

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) 


6223
6224
6225
6226
6227
6228
6229
6230
6231
6232
6233
6234
6235
6236
 
# File 'ext/date/date_core.c', line 6223

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



5421
5422
5423
5424
5425
 
# File 'ext/date/date_core.c', line 5421

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

#eql?(other) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


6427
6428
6429
6430
6431
6432
6433
 
# File 'ext/date/date_core.c', line 6427

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) 


5120
5121
5122
5123
5124
5125
 
# File 'ext/date/date_core.c', line 5120

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



5445
5446
5447
5448
5449
 
# File 'ext/date/date_core.c', line 5445

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) 


5278
5279
5280
5281
5282
5283
 
# File 'ext/date/date_core.c', line 5278

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

#hash ⇒ Object

:nodoc:



6436
6437
6438
6439
6440
6441
6442
6443
6444
6445
6446
6447
6448
 
# File 'ext/date/date_core.c', line 6436

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) 


6990
6991
6992
6993
6994
6995
 
# File 'ext/date/date_core.c', line 6990

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

#initialize_copy(date) ⇒ Object

:nodoc:



4762
4763
4764
4765
4766
4767
4768
4769
4770
4771
4772
4773
4774
4775
4776
4777
4778
4779
4780
4781
4782
4783
4784
4785
4786
 
# File 'ext/date/date_core.c', line 4762

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

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

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

#inspect ⇒ String

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) 


6550
6551
6552
6553
6554
6555
 
# File 'ext/date/date_core.c', line 6550

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

#iso8601 ⇒ String #xmlschema ⇒ String

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

Overloads:

  • #iso8601 ⇒ String

    Returns:

    • (String)
  • #xmlschema ⇒ String

    Returns:

    • (String) 


6952
6953
6954
6955
6956
 
# File 'ext/date/date_core.c', line 6952

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



5409
5410
5411
5412
5413
 
# File 'ext/date/date_core.c', line 5409

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) 


4852
4853
4854
4855
4856
4857
 
# File 'ext/date/date_core.c', line 4852

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) 


7041
7042
7043
7044
7045
7046
7047
7048
7049
7050
7051
7052
 
# File 'ext/date/date_core.c', line 7041

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



5433
5434
5435
5436
5437
 
# File 'ext/date/date_core.c', line 5433

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) 


5262
5263
5264
5265
5266
5267
 
# File 'ext/date/date_core.c', line 5262

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) 


4885
4886
4887
4888
4889
4890
 
# File 'ext/date/date_core.c', line 4885

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) 


5294
5295
5296
5297
5298
5299
5300
5301
5302
5303
5304
5305
5306
5307
 
# File 'ext/date/date_core.c', line 5294

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:



7077
7078
7079
7080
7081
7082
7083
7084
7085
7086
7087
7088
7089
7090
7091
7092
7093
7094
7095
7096
7097
7098
 
# File 'ext/date/date_core.c', line 7077

static VALUE
d_lite_marshal_dump(VALUE self)
{
    VALUE a;

    get_d1(self);

    a = rb_ary_new3(6,
		    m_nth(dat),
		    INT2FIX(m_jd(dat)),
		    INT2FIX(m_df(dat)),
		    m_sf(dat),
		    INT2FIX(m_of(dat)),
		    DBL2NUM(m_sg(dat)));

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

    return a;
}

#marshal_load(a) ⇒ Object

:nodoc:



7101
7102
7103
7104
7105
7106
7107
7108
7109
7110
7111
7112
7113
7114
7115
7116
7117
7118
7119
7120
7121
7122
7123
7124
7125
7126
7127
7128
7129
7130
7131
7132
7133
7134
7135
7136
7137
7138
7139
7140
7141
7142
7143
7144
7145
7146
7147
7148
7149
7150
7151
7152
7153
7154
7155
7156
7157
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
 
# File 'ext/date/date_core.c', line 7101

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

    rb_check_frozen(self);
    rb_check_trusted(self);

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

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


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

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

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

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

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

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

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

    return self;
}

#mday ⇒ Fixnum #day ⇒ Fixnum

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

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

Overloads:

  • #mday ⇒ Fixnum

    Returns:

    • (Fixnum)
  • #day ⇒ Fixnum

    Returns:

    • (Fixnum) 


4948
4949
4950
4951
4952
4953
 
# File 'ext/date/date_core.c', line 4948

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) 


4869
4870
4871
4872
4873
4874
 
# File 'ext/date/date_core.c', line 4869

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) 


4932
4933
4934
4935
4936
4937
 
# File 'ext/date/date_core.c', line 4932

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) 


5068
5069
5070
5071
5072
5073
 
# File 'ext/date/date_core.c', line 5068

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) 


4932
4933
4934
4935
4936
4937
 
# File 'ext/date/date_core.c', line 4932

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



5388
5389
5390
5391
5392
5393
5394
5395
5396
5397
5398
5399
5400
5401
 
# File 'ext/date/date_core.c', line 5388

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.



5958
5959
5960
5961
5962
 
# File 'ext/date/date_core.c', line 5958

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.



5923
5924
5925
5926
5927
5928
5929
5930
5931
5932
 
# File 'ext/date/date_core.c', line 5923

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.



6064
6065
6066
6067
6068
6069
6070
6071
6072
6073
 
# File 'ext/date/date_core.c', line 6064

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

See also Date#>>.



6106
6107
6108
6109
6110
6111
6112
6113
6114
6115
 
# File 'ext/date/date_core.c', line 6106

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.



5940
5941
5942
5943
5944
5945
5946
5947
5948
5949
 
# File 'ext/date/date_core.c', line 5940

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.



6083
6084
6085
6086
6087
6088
6089
6090
6091
6092
 
# File 'ext/date/date_core.c', line 6083

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

See also Date#<<.



6129
6130
6131
6132
6133
6134
6135
6136
6137
6138
 
# File 'ext/date/date_core.c', line 6129

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

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

#rfc2822 ⇒ String #rfc822 ⇒ String

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

Overloads:

  • #rfc2822 ⇒ String

    Returns:

    • (String)
  • #rfc822 ⇒ String

    Returns:

    • (String) 


6977
6978
6979
6980
6981
 
# File 'ext/date/date_core.c', line 6977

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) 


6964
6965
6966
6967
6968
 
# File 'ext/date/date_core.c', line 6964

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) 


6977
6978
6979
6980
6981
 
# File 'ext/date/date_core.c', line 6977

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) 


5133
5134
5135
5136
5137
5138
 
# File 'ext/date/date_core.c', line 5133

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) 


5318
5319
5320
5321
5322
5323
 
# File 'ext/date/date_core.c', line 5318

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) 


6153
6154
6155
6156
6157
6158
6159
6160
6161
6162
6163
6164
6165
6166
6167
6168
6169
6170
6171
6172
6173
6174
6175
6176
6177
6178
6179
6180
6181
6182
6183
6184
6185
6186
6187
6188
6189
6190
6191
6192
 
# File 'ext/date/date_core.c', line 6153

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

See also strftime(3) and ::strptime.

Returns:

  • (String) 


6905
6906
6907
6908
6909
6910
 
# File 'ext/date/date_core.c', line 6905

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

#succ ⇒ Object #next ⇒ Object

Returns a date object denoting the following day.



5958
5959
5960
5961
5962
 
# File 'ext/date/date_core.c', line 5958

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) 


5055
5056
5057
5058
5059
5060
 
# File 'ext/date/date_core.c', line 5055

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) 


5107
5108
5109
5110
5111
5112
 
# File 'ext/date/date_core.c', line 5107

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) 


8548
8549
8550
8551
8552
 
# File 'ext/date/date_core.c', line 8548

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

#to_datetime ⇒ Object

Returns a DateTime object which denotes self.



8560
8561
8562
8563
8564
8565
8566
8567
8568
8569
8570
8571
8572
8573
8574
8575
8576
8577
8578
8579
8580
8581
8582
8583
8584
8585
8586
8587
8588
8589
8590
8591
8592
 
# File 'ext/date/date_core.c', line 8560

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) 


6464
6465
6466
6467
6468
 
# File 'ext/date/date_core.c', line 6464

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.

Returns:



8531
8532
8533
8534
8535
8536
8537
8538
8539
8540
 
# File 'ext/date/date_core.c', line 8531

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) 


5081
5082
5083
5084
5085
5086
 
# File 'ext/date/date_core.c', line 5081

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) 


6201
6202
6203
6204
6205
6206
6207
6208
6209
6210
6211
6212
6213
6214
 
# File 'ext/date/date_core.c', line 6201

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) 


5042
5043
5044
5045
5046
5047
 
# File 'ext/date/date_core.c', line 5042

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) 


5094
5095
5096
5097
5098
5099
 
# File 'ext/date/date_core.c', line 5094

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) 


6952
6953
6954
6955
6956
 
# File 'ext/date/date_core.c', line 6952

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) 


4916
4917
4918
4919
4920
4921
 
# File 'ext/date/date_core.c', line 4916

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) 


4901
4902
4903
4904
4905
4906
 
# File 'ext/date/date_core.c', line 4901

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