class Time

Constants

FORMAT

Public Class Methods

elapse() { || ... } click to toggle source

Tracks the elapse time of a code block.

e = Time.elapse { sleep 1 }

e.assert > 1

CREDIT: Hal Fulton

# File lib/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
stamp(*args) click to toggle source

Produce time stamp for Time.now. See stamp.

CREDIT: Trans

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

Public Instance Methods

ago(*time_units)

Alias for less

Alias for: less
change(options) click to toggle source

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"
# File lib/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
dst_adjustment(time) click to toggle source

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.

# File lib/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
future?(other=nil) click to toggle source
# File lib/facets/time/future.rb, line 9
def future?(other=nil)
  self > (other || ::Time.now)
end
hence(*time_units)

Alias for shift.

Alias for: shift
in(*time_units)

Alias for shift.

Alias for: shift
less(*time_units) click to toggle source

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)
# File lib/facets/time/shift.rb, line 79
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
Also aliased as: ago
past?(other=nil) click to toggle source
# File lib/facets/time/future.rb, line 4
def past?(other=nil)
  self < (other || ::Time.now)
end
round_to(seconds) click to toggle source

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.

# File lib/facets/time/round_to.rb, line 16
def round_to(seconds)
  (self + seconds / 2.0).trunc(seconds)
end
set(options) click to toggle source

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

# File lib/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
shift(*time_units) click to toggle source

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)
# File lib/facets/time/shift.rb, line 24
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
Also aliased as: in, hence
stamp(fmt = nil) click to toggle source

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

# File lib/facets/time/stamp.rb, line 39
def stamp(fmt = nil)
  unless String === fmt
    fmt = FORMAT[fmt]
  end
  strftime(fmt).strip
end
to_time() click to toggle source

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

# File lib/facets/time/to_time.rb, line 8
def to_time
  getlocal 
end
trunc(amount) click to toggle source

Truncate time at give range (in seconds).

t = Time.now
t = t.trunc(60*60)
t.min #=> 0
t.sec #=> 0
# File lib/facets/time/trunc.rb, line 10
def trunc(amount)
  self - (self.to_i % amount)
end