Class: DateTime

Inherits:

Date

• Object
• Date
• DateTime

Defined in:

ext/date/date_core.c

Constant Summary

Constants inherited from Date

Date::ABBR_DAYNAMES, Date::ABBR_MONTHNAMES, Date::DAYNAMES, Date::ENGLAND, Date::GREGORIAN, Date::ITALY, Date::JULIAN, Date::MONTHNAMES

Class Method Summary

• ._strptime(string[, format = '%FT%T%z']) ⇒ Hash

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

• .civil(*args) ⇒ Object

  Creates a DateTime object denoting the given calendar date.

• .commercial([cwyear = -4712[, cweek=1[, cwday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]]) ⇒ Object

  Creates a DateTime object denoting the given week date.

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

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

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

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

• .jd([jd = 0[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]) ⇒ Object

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

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

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

• .new(*args) ⇒ Object

  Creates a DateTime object denoting the given calendar date.

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

  Creates a DateTime object denoting the present time.

• .nth_kday(*args) ⇒ Object
• .ordinal([year = -4712[, yday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]) ⇒ Object

  Creates a DateTime object denoting the given ordinal date.

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

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

• .rfc2822(*args) ⇒ Object

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

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

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

• .rfc822(*args) ⇒ Object

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

• .strptime([string = '-4712-01-01T00:00:00+00:00'[, format='%FT%T%z'[ ,start=Date::ITALY]]]) ⇒ Object

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

• .weeknum(*args) ⇒ Object
• .xmlschema(string = '-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ Object

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

Instance Method Summary

• #hour ⇒ Fixnum

  Returns the hour (0-23).

• #iso8601(*args) ⇒ Object

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

• #jisx0301([n = 0]) ⇒ String

  Returns a string in a JIS X 0301 format.

• #min ⇒ Object

  Returns the minute (0-59).

• #minute ⇒ Object

  Returns the minute (0-59).

• #new_offset([offset = 0]) ⇒ Object

  Duplicates self and resets its offset.

• #offset ⇒ Object

  Returns the offset.

• #rfc3339([n = 0]) ⇒ String

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

• #sec ⇒ Object

  Returns the second (0-59).

• #sec_fraction ⇒ Object

  Returns the fractional part of the second.

• #second ⇒ Object

  Returns the second (0-59).

• #second_fraction ⇒ Object

  Returns the fractional part of the second.

• #strftime([format = '%FT%T%:z']) ⇒ String

  Formats date according to the directives in the given format string.

• #to_date ⇒ Object

  Returns a Date object which denotes self.

• #to_datetime ⇒ self

  Returns self.

• #to_s ⇒ String

  Returns a string in an ISO 8601 format.

• #to_time ⇒ Time

  Returns a Time object which denotes self.

• #xmlschema(*args) ⇒ Object

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

• #zone ⇒ String

  Returns the timezone.

Methods inherited from Date

#+, #-, #<<, #<=>, #===, #>>, _httpdate, _iso8601, _jisx0301, _load, _parse, _rfc2822, _rfc3339, _rfc822, _xmlschema, #ajd, #amjd, #asctime, #ctime, #cwday, #cweek, #cwyear, #day, #day_fraction, #downto, #england, #eql?, #fill, #friday?, #gregorian, #gregorian?, gregorian_leap?, #hash, #httpdate, #initialize, #initialize_copy, #inspect, #inspect_raw, #italy, #jd, #julian, #julian?, julian_leap?, #ld, #leap?, leap?, #marshal_dump, #marshal_dump_old, #marshal_load, #mday, #mjd, #mon, #monday?, #month, new!, #new_start, #next, #next_day, #next_month, #next_year, #nth_kday?, #prev_day, #prev_month, #prev_year, #rfc2822, #rfc822, #saturday?, #start, #step, #succ, #sunday?, test_all, test_civil, test_commercial, test_nth_kday, test_ordinal, test_unit_conv, test_weeknum, #thursday?, today, #tuesday?, #upto, valid_civil?, valid_commercial?, valid_date?, valid_jd?, valid_ordinal?, #wday, #wednesday?, #yday, #year

Constructor Details

This class inherits a constructor from Date

Class Method Details

._strptime(string[, format = '%FT%T%z']) ⇒ 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.

See also strptime(3) and #strftime.

Returns:

• (Hash)

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

static VALUE
datetime_s__strptime(int argc, VALUE *argv, VALUE klass)
{
    return date_s__strptime_internal(argc, argv, klass, "%FT%T%z");
}

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

Creates a DateTime object denoting the given calendar date.

DateTime.new(2001,2,3)  #=> #<DateTime: 2001-02-03T00:00:00+00:00 ...>
DateTime.new(2001,2,3,4,5,6,'+7')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

DateTime.new(2001,-11,-26,-20,-55,-54,'+7')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

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

static VALUE
datetime_s_civil(int argc, VALUE *argv, VALUE klass)
{
    return datetime_initialize(argc, argv, d_lite_s_alloc_complex(klass));
}

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

Creates a DateTime object denoting the given week date.

DateTime.commercial(2001) #=> #<DateTime: 2001-01-01T00:00:00+00:00 ...>
DateTime.commercial(2002) #=> #<DateTime: 2001-12-31T00:00:00+00:00 ...>
DateTime.commercial(2001,5,6,4,5,6,'+7')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

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

static VALUE
datetime_s_commercial(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vw, vd, vh, vmin, vs, vof, vsg, y, fr, fr2, ret;
    int w, d, h, min, s, rof;
    double sg;

    rb_scan_args(argc, argv, "08", &vy, &vw, &vd, &vh, &vmin, &vs, &vof, &vsg);

    y = INT2FIX(-4712);
    w = 1;
    d = 1;

    h = min = s = 0;
    fr2 = INT2FIX(0);
    rof = 0;
    sg = DEFAULT_SG;

    switch (argc) {
      case 8:
  val2sg(vsg, sg);
      case 7:
  val2off(vof, rof);
      case 6:
  num2int_with_frac(s, positive_inf);
      case 5:
  num2int_with_frac(min, 5);
      case 4:
  num2int_with_frac(h, 4);
      case 3:
  num2int_with_frac(d, 3);
      case 2:
  w = NUM2INT(vw);
      case 1:
  y = vy;
    }

    {
  VALUE nth;
  int ry, rw, rd, rh, rmin, rs, rjd, rjd2, ns;

  if (!valid_commercial_p(y, w, d, sg,
        &nth, &ry,
        &rw, &rd, &rjd,
        &ns))
      rb_raise(rb_eArgError, "invalid date");
  if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs))
      rb_raise(rb_eArgError, "invalid date");
  canon24oc();

  rjd2 = jd_local_to_utc(rjd,
             time_to_df(rh, rmin, rs),
             rof);

  ret = d_complex_new_internal(klass,
             nth, rjd2,
             0, INT2FIX(0),
             rof, sg,
             0, 0, 0,
             rh, rmin, rs,
             HAVE_JD | HAVE_TIME);
    }
    add_frac();
    return ret;
}

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

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

DateTime.httpdate('Sat, 03 Feb 2001 04:05:06 GMT')

#=> #<DateTime: 2001-02-03T04:05:06+00:00 …>

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

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

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

    rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
    if (!NIL_P(opt)) argc--;

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

    {
        int argc2 = 1;
        VALUE argv2[2];
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
  VALUE hash = date_s__httpdate(argc2, argv2, klass);
  return dt_new_by_frags(klass, hash, sg);
    }
}

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

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

DateTime.iso8601('2001-02-03T04:05:06+07:00')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

DateTime.iso8601('20010203T040506+0700')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

DateTime.iso8601('2001-W05-6T04:05:06+07:00')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

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

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

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

    rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
    if (!NIL_P(opt)) argc--;

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

    {
        int argc2 = 1;
        VALUE argv2[2];
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2--;
  VALUE hash = date_s__iso8601(argc2, argv2, klass);
  return dt_new_by_frags(klass, hash, sg);
    }
}

.jd([jd = 0[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]) ⇒ Object

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

DateTime.jd(2451944)  #=> #<DateTime: 2001-02-03T00:00:00+00:00 ...>
DateTime.jd(2451945)  #=> #<DateTime: 2001-02-04T00:00:00+00:00 ...>
DateTime.jd(Rational('0.5'))

#=> #<DateTime: -4712-01-01T12:00:00+00:00 …>

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

static VALUE
datetime_s_jd(int argc, VALUE *argv, VALUE klass)
{
    VALUE vjd, vh, vmin, vs, vof, vsg, jd, fr, fr2, ret;
    int h, min, s, rof;
    double sg;

    rb_scan_args(argc, argv, "06", &vjd, &vh, &vmin, &vs, &vof, &vsg);

    jd = INT2FIX(0);

    h = min = s = 0;
    fr2 = INT2FIX(0);
    rof = 0;
    sg = DEFAULT_SG;

    switch (argc) {
      case 6:
  val2sg(vsg, sg);
      case 5:
  val2off(vof, rof);
      case 4:
  num2int_with_frac(s, positive_inf);
      case 3:
  num2int_with_frac(min, 3);
      case 2:
  num2int_with_frac(h, 2);
      case 1:
  num2num_with_frac(jd, 1);
    }

    {
  VALUE nth;
  int rh, rmin, rs, rjd, rjd2;

  if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs))
      rb_raise(rb_eArgError, "invalid date");
  canon24oc();

  decode_jd(jd, &nth, &rjd);
  rjd2 = jd_local_to_utc(rjd,
             time_to_df(rh, rmin, rs),
             rof);

  ret = d_complex_new_internal(klass,
             nth, rjd2,
             0, INT2FIX(0),
             rof, sg,
             0, 0, 0,
             rh, rmin, rs,
             HAVE_JD | HAVE_TIME);
    }
    add_frac();
    return ret;
}

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

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

DateTime.jisx0301('H13.02.03T04:05:06+07:00')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

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

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

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

    rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
    if (!NIL_P(opt)) argc--;

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

    {
        int argc2 = 1;
        VALUE argv2[2];
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
  VALUE hash = date_s__jisx0301(argc2, argv2, klass);
  return dt_new_by_frags(klass, hash, sg);
    }
}

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

Creates a DateTime object denoting the given calendar date.

DateTime.new(2001,2,3)  #=> #<DateTime: 2001-02-03T00:00:00+00:00 ...>
DateTime.new(2001,2,3,4,5,6,'+7')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

DateTime.new(2001,-11,-26,-20,-55,-54,'+7')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

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

static VALUE
datetime_s_civil(int argc, VALUE *argv, VALUE klass)
{
    return datetime_initialize(argc, argv, d_lite_s_alloc_complex(klass));
}

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

Creates a DateTime object denoting the present time.

DateTime.now    #=> #<DateTime: 2011-06-11T21:20:44+09:00 ...>

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

static VALUE
datetime_s_now(int argc, VALUE *argv, VALUE klass)
{
    VALUE vsg, nth, ret;
    double sg;
#ifdef HAVE_CLOCK_GETTIME
    struct timespec ts;
#else
    struct timeval tv;
#endif
    time_t sec;
    struct tm tm;
    long sf, of;
    int y, ry, m, d, h, min, s;

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

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

#ifdef HAVE_CLOCK_GETTIME
    if (clock_gettime(CLOCK_REALTIME, &ts) == -1)
  rb_sys_fail("clock_gettime");
    sec = ts.tv_sec;
#else
    if (gettimeofday(&tv, NULL) == -1)
  rb_sys_fail("gettimeofday");
    sec = tv.tv_sec;
#endif
    tzset();
    if (!localtime_r(&sec, &tm))
  rb_sys_fail("localtime");

    y = tm.tm_year + 1900;
    m = tm.tm_mon + 1;
    d = tm.tm_mday;
    h = tm.tm_hour;
    min = tm.tm_min;
    s = tm.tm_sec;
    if (s == 60)
  s = 59;
#ifdef HAVE_STRUCT_TM_TM_GMTOFF
    of = tm.tm_gmtoff;
#elif defined(HAVE_TIMEZONE)
#ifdef HAVE_ALTZONE
    of = (long)-((tm.tm_isdst > 0) ? altzone : timezone);
#else
    of = (long)-timezone;
    if (tm.tm_isdst) {
  time_t sec2;

  tm.tm_isdst = 0;
  sec2 = mktime(&tm);
  of += (long)difftime(sec2, sec);
    }
#endif
#elif defined(HAVE_TIMEGM)
    {
  time_t sec2;

  sec2 = timegm(&tm);
  of = (long)difftime(sec2, sec);
    }
#else
    {
  struct tm tm2;
  time_t sec2;

  if (!gmtime_r(&sec, &tm2))
      rb_sys_fail("gmtime");
  tm2.tm_isdst = tm.tm_isdst;
  sec2 = mktime(&tm2);
  of = (long)difftime(sec, sec2);
    }
#endif
#ifdef HAVE_CLOCK_GETTIME
    sf = ts.tv_nsec;
#else
    sf = tv.tv_usec * 1000;
#endif

    if (of < -DAY_IN_SECONDS || of > DAY_IN_SECONDS) {
  of = 0;
  rb_warning("invalid offset is ignored");
    }

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

    ret = d_complex_new_internal(klass,
         nth, 0,
         0, LONG2NUM(sf),
         (int)of, GREGORIAN,
         ry, m, d,
         h, min, s,
         HAVE_CIVIL | HAVE_TIME);
    {
  get_d1(ret);
  set_sg(dat, sg);
    }
    return ret;
}

.nth_kday(*args) ⇒ Object

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

static VALUE
datetime_s_nth_kday(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vm, vn, vk, vh, vmin, vs, vof, vsg, y, fr, fr2, ret;
    int m, n, k, h, min, s, rof;
    double sg;

    rb_scan_args(argc, argv, "09", &vy, &vm, &vn, &vk,
     &vh, &vmin, &vs, &vof, &vsg);

    y = INT2FIX(-4712);
    m = 1;
    n = 1;
    k = 1;

    h = min = s = 0;
    fr2 = INT2FIX(0);
    rof = 0;
    sg = DEFAULT_SG;

    switch (argc) {
      case 9:
  val2sg(vsg, sg);
      case 8:
  val2off(vof, rof);
      case 7:
  num2int_with_frac(s, positive_inf);
      case 6:
  num2int_with_frac(min, 6);
      case 5:
  num2int_with_frac(h, 5);
      case 4:
  num2int_with_frac(k, 4);
      case 3:
  n = NUM2INT(vn);
      case 2:
  m = NUM2INT(vm);
      case 1:
  y = vy;
    }

    {
  VALUE nth;
  int ry, rm, rn, rk, rh, rmin, rs, rjd, rjd2, ns;

  if (!valid_nth_kday_p(y, m, n, k, sg,
            &nth, &ry,
            &rm, &rn, &rk, &rjd,
            &ns))
      rb_raise(rb_eArgError, "invalid date");
  if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs))
      rb_raise(rb_eArgError, "invalid date");
  canon24oc();

  rjd2 = jd_local_to_utc(rjd,
             time_to_df(rh, rmin, rs),
             rof);
  ret = d_complex_new_internal(klass,
             nth, rjd2,
             0, INT2FIX(0),
             rof, sg,
             0, 0, 0,
             rh, rmin, rs,
             HAVE_JD | HAVE_TIME);
    }
    add_frac();
    return ret;
}

.ordinal([year = -4712[, yday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]) ⇒ Object

Creates a DateTime object denoting the given ordinal date.

DateTime.ordinal(2001,34) #=> #<DateTime: 2001-02-03T00:00:00+00:00 ...>
DateTime.ordinal(2001,34,4,5,6,'+7')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

DateTime.ordinal(2001,-332,-20,-55,-54,'+7')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

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

static VALUE
datetime_s_ordinal(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vd, vh, vmin, vs, vof, vsg, y, fr, fr2, ret;
    int d, h, min, s, rof;
    double sg;

    rb_scan_args(argc, argv, "07", &vy, &vd, &vh, &vmin, &vs, &vof, &vsg);

    y = INT2FIX(-4712);
    d = 1;

    h = min = s = 0;
    fr2 = INT2FIX(0);
    rof = 0;
    sg = DEFAULT_SG;

    switch (argc) {
      case 7:
  val2sg(vsg, sg);
      case 6:
  val2off(vof, rof);
      case 5:
  num2int_with_frac(s, positive_inf);
      case 4:
  num2int_with_frac(min, 4);
      case 3:
  num2int_with_frac(h, 3);
      case 2:
  num2int_with_frac(d, 2);
      case 1:
  y = vy;
    }

    {
  VALUE nth;
  int ry, rd, rh, rmin, rs, rjd, rjd2, ns;

  if (!valid_ordinal_p(y, d, sg,
           &nth, &ry,
           &rd, &rjd,
           &ns))
      rb_raise(rb_eArgError, "invalid date");
  if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs))
      rb_raise(rb_eArgError, "invalid date");
  canon24oc();

  rjd2 = jd_local_to_utc(rjd,
             time_to_df(rh, rmin, rs),
             rof);

  ret = d_complex_new_internal(klass,
             nth, rjd2,
             0, INT2FIX(0),
             rof, sg,
             0, 0, 0,
             rh, rmin, rs,
             HAVE_JD | HAVE_TIME);
    }
    add_frac();
    return ret;
}

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

Parses the given representation of date and time, and creates a DateTime 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”, makes it full.

DateTime.parse('2001-02-03T04:05:06+07:00')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

DateTime.parse('20010203T040506+0700')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

DateTime.parse('3rd Feb 2001 04:05:06 PM')

#=> #<DateTime: 2001-02-03T16:05:06+00:00 …>

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

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

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

    rb_scan_args(argc, argv, "03:", &str, &comp, &sg, &opt);
    if (!NIL_P(opt)) argc--;

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

    {
        int argc2 = 2;
        VALUE argv2[3];
        argv2[0] = str;
        argv2[1] = comp;
        argv2[2] = opt;
        if (!NIL_P(opt)) argc2++;
  VALUE hash = date_s__parse(argc2, argv2, klass);
  return dt_new_by_frags(klass, hash, sg);
    }
}

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

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

DateTime.rfc2822('Sat, 3 Feb 2001 04:05:06 +0700')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

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

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

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

    rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
    if (!NIL_P(opt)) argc--;

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

    {
        int argc2 = 1;
        VALUE argv2[2];
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
  VALUE hash = date_s__rfc2822(argc2, argv2, klass);
  return dt_new_by_frags(klass, hash, sg);
    }
}

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

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

DateTime.rfc3339('2001-02-03T04:05:06+07:00')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

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

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

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

    rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
    if (!NIL_P(opt)) argc--;

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

    {
        int argc2 = 1;
        VALUE argv2[2];
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
  VALUE hash = date_s__rfc3339(argc2, argv2, klass);
  return dt_new_by_frags(klass, hash, sg);
    }
}

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

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

DateTime.rfc2822('Sat, 3 Feb 2001 04:05:06 +0700')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

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

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

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

    rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
    if (!NIL_P(opt)) argc--;

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

    {
        int argc2 = 1;
        VALUE argv2[2];
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
  VALUE hash = date_s__rfc2822(argc2, argv2, klass);
  return dt_new_by_frags(klass, hash, sg);
    }
}

.strptime([string = '-4712-01-01T00:00:00+00:00'[, format='%FT%T%z'[ ,start=Date::ITALY]]]) ⇒ Object

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

DateTime.strptime('2001-02-03T04:05:06+07:00', '%Y-%m-%dT%H:%M:%S%z')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

DateTime.strptime('03-02-2001 04:05:06 PM', '%d-%m-%Y %I:%M:%S %p')

#=> #<DateTime: 2001-02-03T16:05:06+00:00 …>

DateTime.strptime('2001-W05-6T04:05:06+07:00', '%G-W%V-%uT%H:%M:%S%z')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

DateTime.strptime('2001 04 6 04 05 06 +7', '%Y %U %w %H %M %S %z')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

DateTime.strptime('2001 05 6 04 05 06 +7', '%Y %W %u %H %M %S %z')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

DateTime.strptime('-1', '%s')

#=> #<DateTime: 1969-12-31T23:59:59+00:00 …>

DateTime.strptime('-1000', '%Q')

#=> #<DateTime: 1969-12-31T23:59:59+00:00 …>

DateTime.strptime('sat3feb014pm+7', '%a%d%b%y%H%p%z')

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

See also strptime(3) and #strftime.

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

static VALUE
datetime_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-01T00:00:00+00:00");
      case 1:
  fmt = rb_str_new2("%FT%T%z");
      case 2:
  sg = INT2FIX(DEFAULT_SG);
    }

    {
  VALUE argv2[2], hash;

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

.weeknum(*args) ⇒ Object

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

static VALUE
datetime_s_weeknum(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vw, vd, vf, vh, vmin, vs, vof, vsg, y, fr, fr2, ret;
    int w, d, f, h, min, s, rof;
    double sg;

    rb_scan_args(argc, argv, "09", &vy, &vw, &vd, &vf,
     &vh, &vmin, &vs, &vof, &vsg);

    y = INT2FIX(-4712);
    w = 0;
    d = 1;
    f = 0;

    h = min = s = 0;
    fr2 = INT2FIX(0);
    rof = 0;
    sg = DEFAULT_SG;

    switch (argc) {
      case 9:
  val2sg(vsg, sg);
      case 8:
  val2off(vof, rof);
      case 7:
  num2int_with_frac(s, positive_inf);
      case 6:
  num2int_with_frac(min, 6);
      case 5:
  num2int_with_frac(h, 5);
      case 4:
  f = NUM2INT(vf);
      case 3:
  num2int_with_frac(d, 4);
      case 2:
  w = NUM2INT(vw);
      case 1:
  y = vy;
    }

    {
  VALUE nth;
  int ry, rw, rd, rh, rmin, rs, rjd, rjd2, ns;

  if (!valid_weeknum_p(y, w, d, f, sg,
           &nth, &ry,
           &rw, &rd, &rjd,
           &ns))
      rb_raise(rb_eArgError, "invalid date");
  if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs))
      rb_raise(rb_eArgError, "invalid date");
  canon24oc();

  rjd2 = jd_local_to_utc(rjd,
             time_to_df(rh, rmin, rs),
             rof);
  ret = d_complex_new_internal(klass,
             nth, rjd2,
             0, INT2FIX(0),
             rof, sg,
             0, 0, 0,
             rh, rmin, rs,
             HAVE_JD | HAVE_TIME);
    }
    add_frac();
    return ret;
}

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

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

DateTime.xmlschema('2001-02-03T04:05:06+07:00')

#=> #<DateTime: 2001-02-03T04:05:06+07:00 …>

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

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

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

    rb_scan_args(argc, argv, "02:", &str, &sg, &opt);
    if (!NIL_P(opt)) argc--;

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

    {
        int argc2 = 1;
        VALUE argv2[2];
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
  VALUE hash = date_s__xmlschema(argc2, argv2, klass);
  return dt_new_by_frags(klass, hash, sg);
    }
}

Instance Method Details

#hour ⇒ Fixnum

Returns the hour (0-23).

DateTime.new(2001,2,3,4,5,6).hour   #=> 4

Returns:

• (Fixnum)

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

static VALUE
d_lite_hour(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_hour(dat));
}

#iso8601([n = 0]) ⇒ String #xmlschema([n = 0]) ⇒ String

This method is equivalent to strftime(‘%FT%T%:z’). The optional argument n is the number of digits for fractional seconds.

DateTime.parse('2001-02-03T04:05:06.123456789+07:00').iso8601(9)

#=> “2001-02-03T04:05:06.123456789+07:00”

Overloads:

• #iso8601([n = 0]) ⇒ String

  Returns:

  • (String)
• #xmlschema([n = 0]) ⇒ String

  Returns:

  • (String)

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

static VALUE
dt_lite_iso8601(int argc, VALUE *argv, VALUE self)
{
    long n = 0;

    rb_check_arity(argc, 0, 1);
    if (argc >= 1)
  n = NUM2LONG(argv[0]);

    return rb_str_append(strftimev("%Y-%m-%d", self, set_tmx),
       iso8601_timediv(self, n));
}

#jisx0301([n = 0]) ⇒ String

Returns a string in a JIS X 0301 format. The optional argument n is the number of digits for fractional seconds.

DateTime.parse('2001-02-03T04:05:06.123456789+07:00').jisx0301(9)

#=> “H13.02.03T04:05:06.123456789+07:00”

Returns:

• (String)

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

static VALUE
dt_lite_jisx0301(int argc, VALUE *argv, VALUE self)
{
    long n = 0;

    rb_check_arity(argc, 0, 1);
    if (argc >= 1)
  n = NUM2LONG(argv[0]);

    return rb_str_append(d_lite_jisx0301(self),
       iso8601_timediv(self, n));
}

#min ⇒ Fixnum #minute ⇒ Fixnum

Returns the minute (0-59).

DateTime.new(2001,2,3,4,5,6).min    #=> 5

Overloads:

• #min ⇒ Fixnum

  Returns:

  • (Fixnum)
• #minute ⇒ Fixnum

  Returns:

  • (Fixnum)

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

static VALUE
d_lite_min(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_min(dat));
}

#min ⇒ Fixnum #minute ⇒ Fixnum

Returns the minute (0-59).

DateTime.new(2001,2,3,4,5,6).min    #=> 5

Overloads:

• #min ⇒ Fixnum

  Returns:

  • (Fixnum)
• #minute ⇒ Fixnum

  Returns:

  • (Fixnum)

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

static VALUE
d_lite_min(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_min(dat));
}

#new_offset([offset = 0]) ⇒ Object

Duplicates self and resets its offset.

d = DateTime.new(2001,2,3,4,5,6,'-02:00')

#=> #<DateTime: 2001-02-03T04:05:06-02:00 …>

d.new_offset('+09:00')  #=> #<DateTime: 2001-02-03T15:05:06+09:00 ...>

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

static VALUE
d_lite_new_offset(int argc, VALUE *argv, VALUE self)
{
    VALUE vof;
    int rof;

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

    rof = 0;
    if (argc >= 1)
  val2off(vof, rof);

    return dup_obj_with_new_offset(self, rof);
}

#offset ⇒ Object

Returns the offset.

DateTime.parse('04pm+0730').offset  #=> (5/16)

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

static VALUE
d_lite_offset(VALUE self)
{
    get_d1(self);
    return m_of_in_day(dat);
}

#rfc3339([n = 0]) ⇒ String

This method is equivalent to strftime(‘%FT%T%:z’). The optional argument n is the number of digits for fractional seconds.

DateTime.parse('2001-02-03T04:05:06.123456789+07:00').rfc3339(9)

#=> “2001-02-03T04:05:06.123456789+07:00”

Returns:

• (String)

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

static VALUE
dt_lite_rfc3339(int argc, VALUE *argv, VALUE self)
{
    return dt_lite_iso8601(argc, argv, self);
}

#sec ⇒ Fixnum #second ⇒ Fixnum

Returns the second (0-59).

DateTime.new(2001,2,3,4,5,6).sec    #=> 6

Overloads:

• #sec ⇒ Fixnum

  Returns:

  • (Fixnum)
• #second ⇒ Fixnum

  Returns:

  • (Fixnum)

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

static VALUE
d_lite_sec(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_sec(dat));
}

#sec_fraction ⇒ Object #second_fraction ⇒ Object

Returns the fractional part of the second.

DateTime.new(2001,2,3,4,5,6.5).sec_fraction #=> (1/2)

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

static VALUE
d_lite_sec_fraction(VALUE self)
{
    get_d1(self);
    return m_sf_in_sec(dat);
}

#sec ⇒ Fixnum #second ⇒ Fixnum

Returns the second (0-59).

DateTime.new(2001,2,3,4,5,6).sec    #=> 6

Overloads:

• #sec ⇒ Fixnum

  Returns:

  • (Fixnum)
• #second ⇒ Fixnum

  Returns:

  • (Fixnum)

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

static VALUE
d_lite_sec(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_sec(dat));
}

#sec_fraction ⇒ Object #second_fraction ⇒ Object

Returns the fractional part of the second.

DateTime.new(2001,2,3,4,5,6.5).sec_fraction #=> (1/2)

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

static VALUE
d_lite_sec_fraction(VALUE self)
{
    get_d1(self);
    return m_sf_in_sec(dat);
}

#strftime([format = '%FT%T%:z']) ⇒ 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.
:  use colons for %z.

The minimum field width specifies the minimum width.

The modifiers are “E” and “O”. They are ignored.

Format directives:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Examples:

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

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

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

Various ISO 8601 formats:

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

See also strftime(3) and ::strptime.

Returns:

• (String)

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

static VALUE
dt_lite_strftime(int argc, VALUE *argv, VALUE self)
{
    return date_strftime_internal(argc, argv, self,
          "%Y-%m-%dT%H:%M:%S%:z", set_tmx);
}

#to_date ⇒ Object

Returns a Date object which denotes self.

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

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

    if (simple_dat_p(adat)) {
  VALUE new = d_lite_s_alloc_simple(cDate);
  {
      get_d1b(new);
      bdat->s = adat->s;
      bdat->s.jd = m_local_jd(adat);
      return new;
  }
    }
    else {
  VALUE new = d_lite_s_alloc_simple(cDate);
  {
      get_d1b(new);
      copy_complex_to_simple(new, &bdat->s, &adat->c);
      bdat->s.jd = m_local_jd(adat);
      bdat->s.flags &= ~(HAVE_DF | HAVE_TIME | COMPLEX_DAT);
      return new;
  }
    }
}

#to_datetime ⇒ self

Returns self.

Returns:

• (self)

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

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

#to_s ⇒ String

Returns a string in an ISO 8601 format. (This method doesn’t use the expanded representations.)

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

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

Returns:

• (String)

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

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

#to_time ⇒ Time

Returns a Time object which denotes self.

Returns:

• (Time)

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

static VALUE
datetime_to_time(VALUE self)
{
    volatile VALUE dup = dup_obj(self);
    {
  VALUE t;

  get_d1(dup);

  t = rb_funcall(rb_cTime,
       rb_intern("new"),
                   7,
       m_real_year(dat),
       INT2FIX(m_mon(dat)),
       INT2FIX(m_mday(dat)),
       INT2FIX(m_hour(dat)),
       INT2FIX(m_min(dat)),
       f_add(INT2FIX(m_sec(dat)),
       m_sf_in_sec(dat)),
       INT2FIX(m_of(dat)));
  return t;
    }
}

#iso8601([n = 0]) ⇒ String #xmlschema([n = 0]) ⇒ String

This method is equivalent to strftime(‘%FT%T%:z’). The optional argument n is the number of digits for fractional seconds.

DateTime.parse('2001-02-03T04:05:06.123456789+07:00').iso8601(9)

#=> “2001-02-03T04:05:06.123456789+07:00”

Overloads:

• #iso8601([n = 0]) ⇒ String

  Returns:

  • (String)
• #xmlschema([n = 0]) ⇒ String

  Returns:

  • (String)

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

static VALUE
dt_lite_iso8601(int argc, VALUE *argv, VALUE self)
{
    long n = 0;

    rb_check_arity(argc, 0, 1);
    if (argc >= 1)
  n = NUM2LONG(argv[0]);

    return rb_str_append(strftimev("%Y-%m-%d", self, set_tmx),
       iso8601_timediv(self, n));
}

#zone ⇒ String

Returns the timezone.

DateTime.parse('04pm+0730').zone    #=> "+07:30"

Returns:

• (String)

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

static VALUE
d_lite_zone(VALUE self)
{
    get_d1(self);
    return m_zone(dat);
}