Class: Time

Inherits:

Object

• Object
• Time

Includes:

Comparable

Defined in:

opal/opal/corelib/time.rb

Class Method Summary

• ._parse_offset(utc_offset) ⇒ Object
• .at(seconds, frac = undefined) ⇒ Object
• .gm(year, month = nil, day = nil, hour = nil, min = nil, sec = nil, millisecond = nil, _dummy1 = nil, _dummy2 = nil, _dummy3 = nil) ⇒ Object (also: utc)
• .local(year, month = nil, day = nil, hour = nil, min = nil, sec = nil, millisecond = nil, _dummy1 = nil, _dummy2 = nil, _dummy3 = nil) ⇒ Object (also: mktime)
• .new(year = undefined, month = nil, day = nil, hour = nil, min = nil, sec = nil, utc_offset = nil) ⇒ Object
• .now ⇒ Object

Instance Method Summary

• #+(other) ⇒ Object
• #-(other) ⇒ Object
• #<=>(other) ⇒ Object
• #==(other) ⇒ Object
• #asctime ⇒ Object (also: #ctime)
• #cweek_cyear ⇒ Object
• #dup ⇒ Object
• #eql?(other) ⇒ Boolean
• #getgm ⇒ Object (also: #getutc)
• #gmt? ⇒ Boolean (also: #utc?)
• #gmt_offset ⇒ Object (also: #gmtoff, #utc_offset)
• #gmtime ⇒ Object (also: #utc)
• #hash ⇒ Object
• #inspect ⇒ Object (also: #to_s)
• #isdst ⇒ Object (also: #dst?)
• #strftime(format) ⇒ Object
• #succ ⇒ Object
• #to_a ⇒ Object
• #to_f ⇒ Object
• #to_i ⇒ Object (also: #tv_sec)
• #usec ⇒ Object (also: #tv_usec)
• #yday ⇒ Object
• #zone ⇒ Object

Methods included from Comparable

#<, #<=, #>, #>=, #between?, #clamp

Class Method Details

._parse_offset(utc_offset) ⇒ Object

# File 'opal/opal/corelib/time.rb', line 174

def self._parse_offset(utc_offset)
  %x{
    var timezone;
    if (utc_offset.$$is_string) {
      if (utc_offset == 'UTC') {
        timezone = 0;
      }
      else if(/^[+-]\d\d:[0-5]\d$/.test(utc_offset)) {
        var sign, hours, minutes;
        sign = utc_offset[0];
        hours = +(utc_offset[1] + utc_offset[2]);
        minutes = +(utc_offset[4] + utc_offset[5]);

        timezone = (sign == '-' ? -1 : 1) * (hours + minutes / 60);
      }
      else {
        // Unsupported: "A".."I","K".."Z"
        #{::Kernel.raise ::ArgumentError, %'"+HH:MM", "-HH:MM", "UTC" expected for utc_offset: #{utc_offset}'}
      }
    }
    else if (utc_offset.$$is_number) {
      timezone = utc_offset / 3600;
    }
    else {
      #{::Kernel.raise ::ArgumentError, "Opal doesn't support other types for a timezone argument than Integer and String"}
    }
    return timezone;
  }
end

.at(seconds, frac = undefined) ⇒ Object

# File 'opal/opal/corelib/time.rb', line 15

def self.at(seconds, frac = undefined)
  %x{
    var result;

    if (#{::Time === seconds}) {
      if (frac !== undefined) {
        #{::Kernel.raise ::TypeError, "can't convert Time into an exact number"}
      }
      result = new Date(seconds.getTime());
      result.timezone = seconds.timezone;
      return result;
    }

    if (!seconds.$$is_number) {
      seconds = #{::Opal.coerce_to!(seconds, ::Integer, :to_int)};
    }

    if (frac === undefined) {
      return new Date(seconds * 1000);
    }

    if (!frac.$$is_number) {
      frac = #{::Opal.coerce_to!(frac, ::Integer, :to_int)};
    }

    return new Date(seconds * 1000 + (frac / 1000));
  }
end

.gm(year, month = nil, day = nil, hour = nil, min = nil, sec = nil, millisecond = nil, _dummy1 = nil, _dummy2 = nil, _dummy3 = nil) ⇒ Object Also known as: utc

# File 'opal/opal/corelib/time.rb', line 235

def self.gm(year, month = nil, day = nil, hour = nil, min = nil, sec = nil, millisecond = nil, _dummy1 = nil, _dummy2 = nil, _dummy3 = nil)
  # The _dummy args are there only because the MRI version accepts up to 10 arguments
  %x{
    var args, result;

    if (arguments.length === 10) {
      args  = $slice.call(arguments);
      year  = args[5];
      month = args[4];
      day   = args[3];
      hour  = args[2];
      min   = args[1];
      sec   = args[0];
    }

    args  = time_params(year, month, day, hour, min, sec);
    year  = args[0];
    month = args[1];
    day   = args[2];
    hour  = args[3];
    min   = args[4];
    sec   = args[5];

    result = new Date(Date.UTC(year, month, day, hour, min, 0, sec * 1000));
    if (year < 100) {
      result.setUTCFullYear(year);
    }
    result.timezone = 0;
    return result;
  }
end

.local(year, month = nil, day = nil, hour = nil, min = nil, sec = nil, millisecond = nil, _dummy1 = nil, _dummy2 = nil, _dummy3 = nil) ⇒ Object Also known as: mktime

# File 'opal/opal/corelib/time.rb', line 204

def self.local(year, month = nil, day = nil, hour = nil, min = nil, sec = nil, millisecond = nil, _dummy1 = nil, _dummy2 = nil, _dummy3 = nil)
  # The _dummy args are there only because the MRI version accepts up to 10 arguments
  %x{
    var args, result;

    if (arguments.length === 10) {
      args  = $slice.call(arguments);
      year  = args[5];
      month = args[4];
      day   = args[3];
      hour  = args[2];
      min   = args[1];
      sec   = args[0];
    }

    args  = time_params(year, month, day, hour, min, sec);
    year  = args[0];
    month = args[1];
    day   = args[2];
    hour  = args[3];
    min   = args[4];
    sec   = args[5];

    result = new Date(year, month, day, hour, min, 0, sec * 1000);
    if (year < 100) {
      result.setFullYear(year);
    }
    return result;
  }
end

.new(year = undefined, month = nil, day = nil, hour = nil, min = nil, sec = nil, utc_offset = nil) ⇒ Object

# File 'opal/opal/corelib/time.rb', line 136

def self.new(year = undefined, month = nil, day = nil, hour = nil, min = nil, sec = nil, utc_offset = nil)
  %x{
    var args, result, timezone, utc_date;

    if (year === undefined) {
      return new Date();
    }

    args  = time_params(year, month, day, hour, min, sec);
    year  = args[0];
    month = args[1];
    day   = args[2];
    hour  = args[3];
    min   = args[4];
    sec   = args[5];

    if (utc_offset === nil) {
      result = new Date(year, month, day, hour, min, 0, sec * 1000);
      if (year < 100) {
        result.setFullYear(year);
      }
      return result;
    }

    timezone = #{_parse_offset(utc_offset)};
    utc_date = new Date(Date.UTC(year, month, day, hour, min, 0, sec * 1000));
    if (year < 100) {
      utc_date.setUTCFullYear(year);
    }

    result = new Date(utc_date.getTime() - timezone * 3600000);
    result.timezone = timezone;

    return result;
  }
end

.now ⇒ Object

# File 'opal/opal/corelib/time.rb', line 267

def self.now
  new
end

Instance Method Details

#+(other) ⇒ Object

# File 'opal/opal/corelib/time.rb', line 271

def +(other)
  if ::Time === other
    ::Kernel.raise ::TypeError, 'time + time?'
  end

  %x{
    if (!other.$$is_number) {
      other = #{::Opal.coerce_to!(other, ::Integer, :to_int)};
    }
    var result = new Date(self.getTime() + (other * 1000));
    result.timezone = self.timezone;
    return result;
  }
end

#-(other) ⇒ Object

# File 'opal/opal/corelib/time.rb', line 286

def -(other)
  if ::Time === other
    return `(self.getTime() - other.getTime()) / 1000`
  end

  %x{
    if (!other.$$is_number) {
      other = #{::Opal.coerce_to!(other, ::Integer, :to_int)};
    }
    var result = new Date(self.getTime() - (other * 1000));
    result.timezone = self.timezone;
    return result;
  }
end

#<=>(other) ⇒ Object

# File 'opal/opal/corelib/time.rb', line 301

def <=>(other)
  if ::Time === other
    to_f <=> other.to_f
  else
    r = other <=> self
    if r.nil?
      nil
    elsif r > 0
      -1
    elsif r < 0
      1
    else
      0
    end
  end
end

#==(other) ⇒ Object

# File 'opal/opal/corelib/time.rb', line 318

def ==(other)
  ::Time === other && `#{to_f} === #{other.to_f}`
end

#asctime ⇒ Object Also known as: ctime

# File 'opal/opal/corelib/time.rb', line 322

def asctime
  strftime '%a %b %e %H:%M:%S %Y'
end

#cweek_cyear ⇒ Object

# File 'opal/opal/corelib/time.rb', line 735

def cweek_cyear
  jan01 = ::Time.new(year, 1, 1)
  jan01_wday = jan01.wday
  first_monday = 0
  year = self.year
  if jan01_wday <= 4 && jan01_wday != 0
    # Jan 01 is in the first week of the year
    offset = jan01_wday - 1
  else
    # Jan 01 is in the last week of the previous year
    offset = jan01_wday - 7 - 1
    offset = -1 if offset == -8 # Adjust if Jan 01 is a Sunday
  end

  week = ((yday + offset) / 7.00).ceil

  if week <= 0
    # Get the last week of the previous year
    return ::Time.new(self.year - 1, 12, 31).cweek_cyear
  elsif week == 53
    # Find out whether this is actually week 53 or already week 01 of the following year
    dec31 = ::Time.new(self.year, 12, 31)
    dec31_wday = dec31.wday
    if dec31_wday <= 3 && dec31_wday != 0
      week = 1
      year += 1
    end
  end

  [week, year]
end

#dup ⇒ Object

# File 'opal/opal/corelib/time.rb', line 363

def dup
  copy = `new Date(self.getTime())`

  copy.copy_instance_variables(self)
  copy.initialize_dup(self)

  copy
end

#eql?(other) ⇒ Boolean

Returns:

• (Boolean)

# File 'opal/opal/corelib/time.rb', line 372

def eql?(other)
  other.is_a?(::Time) && (self <=> other).zero?
end

#getgm ⇒ Object Also known as: getutc

# File 'opal/opal/corelib/time.rb', line 438

def getgm
  %x{
    var result = new Date(self.getTime());
    result.timezone = 0;
    return result;
  }
end

#gmt? ⇒ Boolean Also known as: utc?

Returns:

• (Boolean)

# File 'opal/opal/corelib/time.rb', line 453

def gmt?
  `self.timezone === 0`
end

#gmt_offset ⇒ Object Also known as: gmtoff, utc_offset

# File 'opal/opal/corelib/time.rb', line 457

def gmt_offset
  `(self.timezone != null) ? self.timezone * 60 : -self.getTimezoneOffset() * 60`
end

#gmtime ⇒ Object Also known as: utc

# File 'opal/opal/corelib/time.rb', line 446

def gmtime
  %x{
    self.timezone = 0;
    return self;
  }
end

#hash ⇒ Object

# File 'opal/opal/corelib/time.rb', line 390

def hash
  `'Time:' + self.getTime()`
end

#inspect ⇒ Object Also known as: to_s

# File 'opal/opal/corelib/time.rb', line 394

def inspect
  if utc?
    strftime '%Y-%m-%d %H:%M:%S UTC'
  else
    strftime '%Y-%m-%d %H:%M:%S %z'
  end
end

#isdst ⇒ Object Also known as: dst?

# File 'opal/opal/corelib/time.rb', line 355

def isdst
  %x{
    var jan = new Date(self.getFullYear(), 0, 1),
        jul = new Date(self.getFullYear(), 6, 1);
    return self.getTimezoneOffset() < Math.max(jan.getTimezoneOffset(), jul.getTimezoneOffset());
  }
end

#strftime(format) ⇒ Object

# File 'opal/opal/corelib/time.rb', line 461

def strftime(format)
  %x{
    return format.replace(/%([\-_#^0]*:{0,2})(\d+)?([EO]*)(.)/g, function(full, flags, width, _, conv) {
      var result = "", jd, c, s,
          zero   = flags.indexOf('0') !== -1,
          pad    = flags.indexOf('-') === -1,
          blank  = flags.indexOf('_') !== -1,
          upcase = flags.indexOf('^') !== -1,
          invert = flags.indexOf('#') !== -1,
          colons = (flags.match(':') || []).length;

      width = parseInt(width, 10);

      if (zero && blank) {
        if (flags.indexOf('0') < flags.indexOf('_')) {
          zero = false;
        }
        else {
          blank = false;
        }
      }

      switch (conv) {
        case 'Y':
          result += #{year};
          break;

        case 'C':
          zero    = !blank;
          result += Math.round(#{year} / 100);
          break;

        case 'y':
          zero    = !blank;
          result += (#{year} % 100);
          break;

        case 'm':
          zero    = !blank;
          result += #{mon};
          break;

        case 'B':
          result += long_months[#{mon} - 1];
          break;

        case 'b':
        case 'h':
          blank   = !zero;
          result += short_months[#{mon} - 1];
          break;

        case 'd':
          zero    = !blank
          result += #{day};
          break;

        case 'e':
          blank   = !zero
          result += #{day};
          break;

        case 'j':
          zero    = !blank;
          width   = isNaN(width) ? 3 : width;
          result += #{yday};
          break;

        case 'H':
          zero    = !blank;
          result += #{hour};
          break;

        case 'k':
          blank   = !zero;
          result += #{hour};
          break;

        case 'I':
          zero    = !blank;
          result += (#{hour} % 12 || 12);
          break;

        case 'l':
          blank   = !zero;
          result += (#{hour} % 12 || 12);
          break;

        case 'P':
          result += (#{hour} >= 12 ? "pm" : "am");
          break;

        case 'p':
          result += (#{hour} >= 12 ? "PM" : "AM");
          break;

        case 'M':
          zero    = !blank;
          result += #{min};
          break;

        case 'S':
          zero    = !blank;
          result += #{sec}
          break;

        case 'L':
          zero    = !blank;
          width   = isNaN(width) ? 3 : width;
          result += self.getMilliseconds();
          break;

        case 'N':
          width   = isNaN(width) ? 9 : width;
          result += #{`self.getMilliseconds().toString()`.rjust(3, '0')};
          result  = #{`result`.ljust(`width`, '0')};
          break;

        case 'z':
          var offset  = (self.timezone == null) ? self.getTimezoneOffset() : (-self.timezone * 60),
              hours   = Math.floor(Math.abs(offset) / 60),
              minutes = Math.abs(offset) % 60;

          result += offset < 0 ? "+" : "-";
          result += hours < 10 ? "0" : "";
          result += hours;

          if (colons > 0) {
            result += ":";
          }

          result += minutes < 10 ? "0" : "";
          result += minutes;

          if (colons > 1) {
            result += ":00";
          }

          break;

        case 'Z':
          result += #{zone};
          break;

        case 'A':
          result += days_of_week[#{wday}];
          break;

        case 'a':
          result += short_days[#{wday}];
          break;

        case 'u':
          result += (#{wday} + 1);
          break;

        case 'w':
          result += #{wday};
          break;

        case 'V':
          result += #{cweek_cyear[0].to_s.rjust(2, '0')};
          break;

        case 'G':
          result += #{cweek_cyear[1]};
          break;

        case 'g':
          result += #{cweek_cyear[1][-2..-1]};
          break;

        case 's':
          result += #{to_i};
          break;

        case 'n':
          result += "\n";
          break;

        case 't':
          result += "\t";
          break;

        case '%':
          result += "%";
          break;

        case 'c':
          result += #{strftime('%a %b %e %T %Y')};
          break;

        case 'D':
        case 'x':
          result += #{strftime('%m/%d/%y')};
          break;

        case 'F':
          result += #{strftime('%Y-%m-%d')};
          break;

        case 'v':
          result += #{strftime('%e-%^b-%4Y')};
          break;

        case 'r':
          result += #{strftime('%I:%M:%S %p')};
          break;

        case 'R':
          result += #{strftime('%H:%M')};
          break;

        case 'T':
        case 'X':
          result += #{strftime('%H:%M:%S')};
          break;

        // Non-standard: JIS X 0301 date format
        case 'J':
          jd = #{to_date.jd};
          if (jd < 2405160) {
            result += #{strftime('%Y-%m-%d')};
            break;
          }
          else if (jd < 2419614)
            c = 'M', s = 1867;
          else if (jd < 2424875)
            c = 'T', s = 1911;
          else if (jd < 2447535)
            c = 'S', s = 1925;
          else if (jd < 2458605)
            c = 'H', s = 1988;
          else
            c = 'R', s = 2018;

          result += #{format '%c%02d', `c`, year - `s`};
          result += #{strftime('-%m-%d')};
          break;

        default:
          return full;
      }

      if (upcase) {
        result = result.toUpperCase();
      }

      if (invert) {
        result = result.replace(/[A-Z]/, function(c) { c.toLowerCase() }).
                        replace(/[a-z]/, function(c) { c.toUpperCase() });
      }

      if (pad && (zero || blank)) {
        result = #{`result`.rjust(`isNaN(width) ? 2 : width`, `blank ? " " : "0"`)};
      }

      return result;
    });
  }
end

#succ ⇒ Object

# File 'opal/opal/corelib/time.rb', line 402

def succ
  %x{
    var result = new Date(self.getTime() + 1000);
    result.timezone = self.timezone;
    return result;
  }
end

#to_a ⇒ Object

# File 'opal/opal/corelib/time.rb', line 723

def to_a
  [sec, min, hour, day, month, year, wday, yday, isdst, zone]
end

#to_f ⇒ Object

# File 'opal/opal/corelib/time.rb', line 727

def to_f
  `self.getTime() / 1000`
end

#to_i ⇒ Object Also known as: tv_sec

# File 'opal/opal/corelib/time.rb', line 731

def to_i
  `parseInt(self.getTime() / 1000, 10)`
end

#usec ⇒ Object Also known as: tv_usec

# File 'opal/opal/corelib/time.rb', line 410

def usec
  `self.getMilliseconds() * 1000`
end

#yday ⇒ Object

# File 'opal/opal/corelib/time.rb', line 344

def yday
  # http://javascript.about.com/library/bldayyear.htm
  # also see moment.js implementation: http://git.io/vCKNE

  start_of_year = Time.new(year).to_i
  start_of_day  = Time.new(year, month, day).to_i
  one_day       = 86_400

  ((start_of_day - start_of_year) / one_day).round + 1
end

#zone ⇒ Object

# File 'opal/opal/corelib/time.rb', line 414

def zone
  %x{
    if (self.timezone === 0) return "UTC";
    else if (self.timezone != null) return nil;

    var string = self.toString(),
        result;

    if (string.indexOf('(') == -1) {
      result = string.match(/[A-Z]{3,4}/)[0];
    }
    else {
      result = string.match(/\((.+)\)(?:\s|$)/)[1]
    }

    if (result == "GMT" && /(GMT\W*\d{4})/.test(string)) {
      return RegExp.$1;
    }
    else {
      return result;
    }
  }
end