Class Time
In: lib/facets/core/facets/time/stamp.rb
lib/facets/core/facets/time/elapse.rb
lib/facets/core/facets/time/future.rb
lib/facets/core/facets/time/set.rb
lib/facets/core/facets/time/dst_adjustment.rb
lib/facets/core/facets/time/trunc.rb
lib/facets/core/facets/time/shift.rb
lib/facets/core/facets/time/to_time.rb
lib/facets/core/facets/time/change.rb
lib/facets/core/facets/time/round_to.rb
Parent: Object

Methods

ago   change   dst_adjustment   elapse   future?   hence   in   less   past?   round_to   set   shift   stamp   stamp   to_time   trunc  

Constants

FORMAT = { :db => "%Y-%m-%d %H:%M:%S", :dbase => "%Y-%m-%d %H:%M:%S", :datbase => "%Y-%m-%d %H:%M:%S", :utc => "%Y-%m-%d %H:%M:%S", :number => "%Y%m%d%H%M%S", :short => "%d %b %H:%M", :time => "%H:%M", :long => "%B %d, %Y %H:%M", :day1st => "%d-%m-%Y %H:%M", :dmYHM => "%d-%m-%Y %H:%M", :rfc822 => "%a, %d %b %Y %H:%M:%S %z", nil => "%a %b %d %H:%M:%S %Z %Y"

Public Class methods

Tracks the elapse time of a code block.

  e = Time.elapse { sleep 1 }

  e.assert > 1

CREDIT: Hal Fulton

[Source]

# File lib/facets/core/facets/time/elapse.rb, line 11
  def self.elapse
    raise "Need block" unless block_given?
    t0 = now.to_f
    yield
    now.to_f - t0
  end

Produce time stamp for Time.now. See stamp.

CREDIT: Trans

[Source]

# File lib/facets/core/facets/time/stamp.rb, line 24
  def self.stamp(*args)
    now.stamp(*args)
  end

Public Instance methods

ago(*time_units)

Alias for less

Returns a new Time where one or more of the elements have been changed according to the options parameter. The time options (hour, minute, sec, usec) reset cascadingly, so if only the hour is passed, then minute, sec, and usec is set to 0. If the hour and minute is passed, then sec and usec is set to 0.

  t1 = Time.at(10000)
  t1.ctime   #=> "Wed Dec 31 21:46:40 1969"

  t2 = t1.change(:hour => 11)
  t2.ctime   #=> "Wed Dec 31 11:00:00 1969"

[Source]

# File lib/facets/core/facets/time/change.rb, line 16
  def change(options)
    opts=options; #{}; options.each_pair{ |k,v| opts[k] = v.to_i }
    self.class.send(
      self.utc? ? :utc : :local,
      opts[:year]  || self.year,
      opts[:month] || self.month,
      opts[:day]   || self.day,
      opts[:hour]  || self.hour,
      opts[:min]   || (opts[:hour] ? 0 : self.min),
      opts[:sec]   || ((opts[:hour] || opts[:min]) ? 0 : self.sec),
      opts[:usec]  || ((opts[:hour] || opts[:min] || opts[:sec]) ? 0 : self.usec)
    )
  end

Adjust DST

TODO: Can‘t seem to get this to pass ActiveSupport tests, even though it is essentially identical to the ActiveSupport code (see Time#since in time/calculations.rb). It handles all but 4 tests.

[Source]

# File lib/facets/core/facets/time/dst_adjustment.rb, line 11
    def dst_adjustment(time)
      self_dst = self.dst? ? 1 : 0
      time_dst = time.dst? ? 1 : 0
      seconds  = (self - time).abs
      if (seconds >= 86400 && self_dst != time_dst)
        time + ((self_dst - time_dst) * 60 * 60)
      else
        time
      end
    end

[Source]

# File lib/facets/core/facets/time/future.rb, line 9
  def future?(other=nil)
    self > (other || ::Time.now)
  end
hence(*time_units)

Alias for shift

in(*time_units)

Alias for shift

Returns a new Time representing the time a number of time-units ago. This is just like shift, but reverses the direction.

  t = Time.utc(2010,10,10,0,0,0)

  t.less(4, :days)             #=>  Time.utc(2010,10,6,0,0,0)

[Source]

# File lib/facets/core/facets/time/shift.rb, line 77
  def less(*time_units)
    time_hash  = Hash===time_units.last ? time_units.pop : {}
    time_units = time_units.flatten

    time_units << :seconds if time_units.size % 2 == 1

    time_hash.each{ |units, number| time_units << number; time_units << units }

    neg_times = []
    time_units.each_slice(2){ |number, units| neg_times << -number; neg_times << units }

    shift(*neg_times)
  end

[Source]

# File lib/facets/core/facets/time/future.rb, line 4
  def past?(other=nil)
    self < (other || ::Time.now)
  end

Round time at the nearest range (in seconds).

  t1 = Time.now
  t2 = t1.round_to(60*60)
  t2.min #=> 0
  t2.sec #=> 0

TODO: What about `round(:minute)`?

TODO: Fractional seconds should round the usec.

[Source]

# File lib/facets/core/facets/time/round_to.rb, line 16
  def round_to(seconds)
    (self + seconds / 2.0).trunc(seconds)
  end

Like change but does not reset earlier times.

NOTE: It would be better, probably if this were called "change". and that change were called "reset".

[Source]

# File lib/facets/core/facets/time/set.rb, line 8
  def set(options)
    opts={}
    options.each_pair do |k,v| 
      k = :min if k.to_s =~ /^min/
      k = :sec if k.to_s =~ /^sec/
      opts[k] = v.to_i 
    end
    self.class.send(
      self.utc? ? :utc : :local,
      opts[:year]  || self.year,
      opts[:month] || self.month,
      opts[:day]   || self.day,
      opts[:hour]  || self.hour,
      opts[:min]   || self.min,
      opts[:sec]   || self.sec,
      opts[:usec]  || self.usec
    )
  end

Returns a new Time representing the time shifted by the time-units given. Positive number shift the time forward, negative number shift the time backward.

  t = Time.utc(2010,10,10,0,0,0)
  t.shift( 4, :days)            #=>  Time.utc(2010,10,14,0,0,0)
  t.shift(-4, :days)            #=>  Time.utc(2010,10,6,0,0,0)

More than one unit of time can be given.

  t.shift(4, :days, 3, :hours)  #=>  Time.utc(2010,10,14,3,0,0)

The shift method can also take a hash.

  t.shift(:days=>4, :hours=>3)  #=>  Time.utc(2010,10,14,3,0,0)

[Source]

# File lib/facets/core/facets/time/shift.rb, line 22
  def shift(*time_units)
    time_hash = Hash===time_units.last ? time_units.pop : {}
    time_units = time_units.flatten
    time_units << :seconds if time_units.size % 2 == 1
    time_hash.each{ |units, number| time_units << number; time_units << units }

    time = self
    time_units.each_slice(2) do |number, units|
      #next time = time.ago(-number, units) if number < 0
      time = (
        case units.to_s.downcase.to_sym
        when :years, :year
          time.set( :year=>(year + number) )
        when :months, :month
          if number > 0
            new_month = ((month + number - 1) % 12) + 1
            y = (number / 12) + (new_month < month ? 1 : 0)
            time.set(:year => (year + y), :month => new_month)
          else
            number = -number
            new_month = ((month - number - 1) % 12) + 1
            y = (number / 12) + (new_month > month ? 1 : 0)
            time.set(:year => (year - y), :month => new_month)
          end
        when :weeks, :week
          time + (number * 604800)
        when :days, :day
          time + (number * 86400)
        when :hours, :hour
          time + (number * 3600)
        when :minutes, :minute, :mins, :min
          time + (number * 60)
        when :seconds, :second, :secs, :sec, nil
          time + number
        else
          raise ArgumentError, "unrecognized time units -- #{units}"
        end
      )
    end
    dst_adjustment(time)
  end

Create a time stamp.

  t = Time.at(10000)
  t.stamp(:short)    #=> "31 Dec 21:46"

Supported formats come from the Time::FORMAT constant.

CREDIT: Trans

[Source]

# File lib/facets/core/facets/time/stamp.rb, line 37
  def stamp(fmt = nil)
    unless String === fmt
      fmt = FORMAT[fmt]
    end
    strftime(fmt).strip
  end

To be able to keep Dates and Times interchangeable on conversions.

[Source]

# File lib/facets/core/facets/time/to_time.rb, line 8
    def to_time
      getlocal 
    end

Truncate time at give range (in seconds).

  t = Time.now
  t = t.trunc(60*60)
  t.min #=> 0
  t.sec #=> 0

[Source]

# File lib/facets/core/facets/time/trunc.rb, line 10
  def trunc(amount)
    self - (self.to_i % amount)
  end

[Validate]