DZone Snippets: time code

Creating a timestamp in Ruby

jrobertson (James Robertson) — Wed, 08 Oct 2008 10:57:12 GMT



 # year + month + day + hour + minutes +seconds

 Time.now.strftime("%y%m%d%H%M%S") # => "081008115016"

References:
- The Perfect Timestamp - almost effortless [almosteffortless.com]

Additional code - Displaying a human friendly elapsed time



def time_ago_or_time_stamp(from_time, to_time = Time.now, include_seconds = true, detail = false)

  from_time = from_time.to_time if from_time.respond_to?(:to_time)

  to_time = to_time.to_time if to_time.respond_to?(:to_time)

  distance_in_minutes = (((to_time - from_time).abs)/60).round

  distance_in_seconds = ((to_time - from_time).abs).round

  case distance_in_minutes

    when 0..1           then time = (distance_in_seconds < 60) ? "#{distance_in_seconds} seconds ago" : '1 minute ago'

    when 2..59          then time = "#{distance_in_minutes} minutes ago"

    when 60..90         then time = "1 hour ago"

    when 90..1440       then time = "#{(distance_in_minutes.to_f / 60.0).round} hours ago"

    when 1440..2160     then time = '1 day ago' # 1-1.5 days

    when 2160..2880     then time = "#{(distance_in_minutes.to_f / 1440.0).round} days ago" # 1.5-2 days

    else time = from_time.strftime("%a, %d %b %Y")

  end

  return time_stamp(from_time) if (detail && distance_in_minutes > 2880)

  return time

end

input:
a = Time.now

output:
>> time_ago_or_time_stamp(a)
=> "45 seconds ago"
>> time_ago_or_time_stamp(a)
=> "1 minute ago"
>> time_ago_or_time_stamp(a)
=> "1 minute ago"
>> time_ago_or_time_stamp(a)
=> "2 minutes ago"

Comparing a DateTime object with Time.now

jrobertson (James Robertson) — Tue, 23 Sep 2008 14:03:31 GMT

this_evening = DateTime.parse('Tue Sep 23 20:35:37  +0100 2008')

t1 = Time.now

just_now = DateTime.parse(t1.to_s)

puts 'this evening has not happened yet.' if this_evening > just_now

Displaying the difference between times in Ruby

jrobertson (James Robertson) — Wed, 20 Aug 2008 21:48:20 GMT

This function converts the number of seconds into hours, minutes, and seconds.

require 'time'



def seconds_fraction_to_time(seconds)

  hours = mins = 0

  if seconds >=  60 then

    mins = (seconds / 60).to_i 

    seconds = (seconds % 60 ).to_i



    if mins >= 60 then

      hours = (mins / 60).to_i 

      mins = (mins % 60).to_i

    end

  end

  [hours,mins,seconds]

end



departed_house = Time.parse("07:34")

arrived_at_supermarket = Time.parse("09:10")

travel_duration_in_seconds =  arrived_at_supermarket - departed_house



hours, minutes, seconds = seconds_fraction_to_time(travel_duration_in_seconds)



puts "The journey from my home to the supermarket took #{hours} hour(s), #{minutes} minutes, and #{seconds} seconds."

Output:
The journey from my home to the supermarket took 1 hour(s), 36 minutes, and 0 seconds.

References:
- Class: Time [ruby-doc.org]
- Working with Dates and Times in Ruby [techotopia.com]
- Numbers in Ruby [rubylearning.com]

Making time for Ruby

jrobertson (James Robertson) — Wed, 20 Aug 2008 17:49:15 GMT

b = Time.parse("17:30")
=> Wed Aug 20 17:30:00 +0100 2008

Reference:
Class: Time [ruby-doc.org]

A user friendly elapsed time with Ruby

jrobertson (James Robertson) — Mon, 30 Jun 2008 09:37:08 GMT

This Ruby code outputs a user friendly elapsed time or a historical date if the event was more than 24 hours ago.



def didwhen(old_time)



  val = Time.now - old_time

  #puts val

  if val < 10 then

    result = 'just a moment ago'

  elsif val < 40  then

    result = 'less than ' + (val * 1.5).to_i.to_s.slice(0,1) + '0 seconds ago'

  elsif val < 60 then

    result = 'less than a minute ago'

  elsif val < 60 * 1.3  then

    result = "1 minute ago"

  elsif val < 60 * 50  then

    result = "#{(val / 60).to_i} minutes ago"

  elsif val < 60  * 60  * 1.4 then

    result = 'about 1 hour ago'

  elsif val < 60  * 60 * (24 / 1.02) then

    result = "about #{(val / 60 / 60 * 1.02).to_i} hours ago"

  else

    result = old_time.strftime("%H:%M %p %B %d, %Y")



  end

  result

end

Inspired by Twitter.

TimeLine //JavaScript Class

jonasraoni (Jonas Raoni Soares Silva) — Sun, 30 Mar 2008 16:49:21 GMT

Simulates the Adobe Flash timeline. You define the amount of frames, the speed in fps (frames per second) and, at each frame passage an event is called, useful for animations.

[UPDATED CODE AND HELP CAN BE FOUND HERE]



//+ Jonas Raoni Soares Silva

//@ http://jsfromhell.com/classes/timeline [v1.0]



TimeLine = function(fps, f){

	this.fps = fps, this.frames = f;

};

with({o: TimeLine, $: TimeLine.prototype}){

	o.timers = [];

	$.running = !!($.current = +(o.timer = $.time = null));

	o.run = function(){

		var o = this;

		o.timer || (o.timer = setInterval(function(){

			for(var h, d = +(new Date), t = o.timers, i = t.length; i--;){

				(!t[i].running || ((d - t[i].time) / (1e3 / t[i].fps) > t[i].current + 1 &&

				t[i].onframe(++t[i].current), t[i].current >= t[i].frames)) &&

				(h = t.splice(i, 1)[0], h.stop(1));

			}

		}, 1));

	};

	$.start = function(c){

		var o = this, t = TimeLine;

		if(o.running) return;

		o.running = true, o.current = c || 0;

		o.time = new Date, o.onstart && o.onstart();

		if(!o.onframe || o.frames <= 0 || o.fps <= 0)

			return o.stop(1);

		t.timers.push(this), t.run();

	};

	$.stop = function(){

		var o = this;

		o.running = false;

		if(!TimeLine.timers.length)

			TimeLine.timer = clearInterval(TimeLine.timer), null;

		arguments.length && o.onstop && o.onstop();

	};

}

Example





25 fps

12 fps



TimeLine working together with the ease in quad function.

Measuring the elapsed time

jrobertson (James Robertson) — Fri, 14 Mar 2008 08:47:16 GMT

This Ruby code measures how long it takes to display the message "hello world".



def test_method(statement)

  start_time = Time.now

  eval(statement)

  end_time = Time.now

  end_time - start_time

end



statement = "sleep 1.5; puts 'hello world'"

elapsed_time = test_method(statement)

puts "elapsed time : #{elapsed_time}"

output



hello world

elapsed time : 1.499266

Ruby Servlets

jrobertson (James Robertson) — Mon, 10 Mar 2008 23:17:53 GMT

This WEBrick example demonstrates a basic servlet which displays the current time. Source code copied from At the Forge - Getting Started with Ruby [linuxjournal.com].



#!/sw/bin/ruby

require 'webrick'

include WEBrick



# ---------------------------------------------

# Define a new class

class CurrentTimeServlet

  < WEBrick::HTTPServlet::AbstractServlet



  def do_GET(request, response)

    response['Content-Type'] = 'text/plain'

    response.status = 200

    response.body = Time.now.to_s + "\n"

  end

end



# ----------------------------------------------

# Create an HTTP server

s = HTTPServer.new(

  :Port            => 8000,

  :DocumentRoot    => "/usr/local/apache/htdocs/"

)



s.mount("/time", CurrentTimeServlet)



# When the server gets a control-C, kill it

trap("INT"){ s.shutdown }



# Start the server

s.start

e.g. http://localhost:8001/time
output



Mon Mar 10 23:06:58 +0000 2008

Reference: http://www.webrick.org/

Creating a DateTime object with Ruby

jrobertson (James Robertson) — Sat, 01 Mar 2008 21:53:38 GMT

This example creates a date and time variable which represents 22nd March 2008 4:30pm and 12 seconds.



d2 = DateTime.new(y=200,m=3,d=22, h=16,min=30,s=12)

or convert a date string into a DataTime object:



"17/03/2009 17:48:00"[/(\d+)\/(\d+)\/(\d+)\s(\d+):(\d+):(\d+)/]

d2 = DateTime.new(y=$3.to_i,m=$2.to_i,d=$1.to_i, h=$4.to_i,min=$5.to_i,s=$6.to_i)

or convert a date string into a Time object:



"22/03/2008 17:48:00"[/(\d+)\/(\d+)\/(\d+)\s(\d+):(\d+):(\d+)/]

iyear = $3.to_i; imonth = $2.to_i; iday = $1.to_i; ihour = $4.to_i; imin = $5.to_i; isec = $6.to_i

twork = Time.local(iyear,imonth,iday,ihour,imin,isec) 

puts 'we still have time to party' if Time.now < twork

Reference:
Class: DateTime [ruby-doc.org]
Class: Time [ruby-doc.org]

before? and after? - Ruby Time class mixin

JimCropcho (Jim Cropcho) — Mon, 21 Jan 2008 21:57:18 GMT

The mixin below allows comparison between two Time objects using the more intuitive and natural-sounding before? and after? methods.

Some examples (using Rails' ActiveSupport Time extensions or (preferred) the 'units' gem):

2.minutes.ago.after? Time.now # => false

Time.now.before? 2.hours.from_now # => true

module BeforeAndAfter



  LEFT_SIDE_LATER  = 1

  RIGHT_SIDE_LATER = -1

  

  def before?(input_time)

    (self <=> input_time) == RIGHT_SIDE_LATER

  end

  

  def after?(input_time)

    (self <=> input_time) == LEFT_SIDE_LATER

  end

end



Time.send :include , BeforeAndAfter