duration 0.0.2 → 0.0.3

data/lib/duration.rb

@@ -27,7 +27,10 @@
 # 	=> "2 w, 0 d, 0 h, 2 m, 30 s"
 #
 class Duration
-	attr_reader :total, :weeks, :days, :hours, :minutes, :seconds
+	include Comparable
+	include Enumerable
+
+	attr_reader :total, :weeks, :days, :hours, :minutes
 
 	WEEK    =  60 * 60 * 24 * 7
 	DAY     =  60 * 60 * 24
@@ -41,18 +44,23 @@ class Duration
 	#
 	# 	d = Duration.new(60 * 60 * 24 * 10 + 120 + 30)
 	# 	=> #<Duration: 1 week, 3 days, 2 minutes and 30 seconds>
-	#
 	# 	d = Duration.new(:weeks => 1, :days => 3, :minutes => 2, :seconds => 30)
 	# 	=> #<Duration: 1 week, 3 days, 2 minutes and 30 seconds>
 	#
-	def initialize(seconds_or_attr)
-		if (h = seconds_or_attr).kind_of? Hash
-			seconds =  0
-			seconds += h[:weeks]   * WEEK   if h.key? :weeks
-			seconds += h[:days]    * DAY    if h.key? :days
-			seconds += h[:hours]   * HOUR   if h.key? :hours
-			seconds += h[:minutes] * MINUTE if h.key? :minutes
-			seconds += h[:seconds] * SECOND if h.key? :seconds
+	def initialize(seconds_or_attr = 0)
+		if seconds_or_attr.kind_of? Hash
+			# Part->time map table.
+			h = {:weeks => WEEK, :days => DAY, :hours => HOUR, :minutes => MINUTE, :seconds => SECOND}
+
+			# Loop through each valid part, ignore all others.
+			seconds = seconds_or_attr.inject(0) do |sec, args|
+				# Grab the part of the duration (week, day, whatever) and the number of seconds for it.
+				part, time = args
+
+				# Map each part to their number of seconds and the given value.
+				# {:weeks => 2} maps to h[:weeks] -- so... weeks = WEEK * 2
+				if h.key?(prt = part.to_s.to_sym) then sec + time * h[prt] else 0 end
+			end
 		else
 			seconds = seconds_or_attr
 		end
@@ -69,12 +77,14 @@ class Duration
 	#
 	# *Identifiers*
 	#
-	# 	%w - Number of weeks
-	# 	%d - Number of days
-	# 	%h - Number of hours
-	# 	%m - Number of minutes
-	# 	%s - Number of seconds
-	# 	%% - Literal `%' character
+	# 	%w -- Number of weeks
+	# 	%d -- Number of days
+	# 	%h -- Number of hours
+	# 	%m -- Number of minutes
+	# 	%s -- Number of seconds
+	# 	%t -- Total number of seconds
+	# 	%x -- Duration#to_s
+	# 	%% -- Literal `%' character
 	#
 	# *Example*
 	#
@@ -89,36 +99,146 @@ class Duration
 		 'd' => @days   ,
 		 'h' => @hours  ,
 		 'm' => @minutes,
-		 's' => @seconds}
+		 's' => @seconds,
+		 't' => @total  ,
+		 'x' => to_s}
 
-		fmt.gsub(/%?%(w|d|h|m|s)/) do |match|
+		fmt.gsub(/%?%(w|d|h|m|s|t|x)/) do |match|
 			match.size == 3 ? match : h[match[1..1]]
 		end.gsub('%%', '%')
 	end
 
-	# Intercept certain attribute writers. Intercepts `weeks=', `days=', `hours=',
-	# `minutes=', `seconds=', and `total='
+	# Get the number of seconds of a given part, or simply just get the number of
+	# seconds.
 	#
 	# *Example*
 	#
-	# 	d = Duration.new(:days => 6)
-	# 	=> #<Duration: 6 days>
-	# 	d.days += 1; d
-	# 	=> #<Duration: 1 week>
-	#
-	def method_missing(method, *args)
-		case method
-		when :weeks=   then initialize(WEEK   * args[0] + (@total - WEEK   * @weeks  ))
-		when :days=    then initialize(DAY    * args[0] + (@total - DAY    * @days   ))
-		when :hours=   then initialize(HOUR   * args[0] + (@total - HOUR   * @hours  ))
-		when :minutes= then initialize(MINUTE * args[0] + (@total - MINUTE * @minutes))
-		when :seconds= then initialize(SECOND * args[0] + (@total - SECOND * @seconds))
-		when :total=   then initialize(args[0])
+	# 	d = Duration.new(:weeks => 1, :days => 1, :hours => 1, :seconds => 30)
+	# 	=> #<Duration: 1 week, 1 day, 1 hour and 30 seconds>
+	# 	d.seconds(:weeks)
+	# 	=> 604800
+	# 	d.seconds(:days)
+	# 	=> 86400
+	# 	d.seconds(:hours)
+	# 	=> 3600
+	# 	d.seconds
+	# 	=> 30
+	#
+	def seconds(part = nil)
+		# Table mapping
+		h = {:weeks => WEEK, :days => DAY, :hours => HOUR, :minutes => MINUTE}
+
+		if [:weeks, :days, :hours, :minutes].include? part
+			__send__(part) * h[part]
 		else
-			raise NoMethodError, "undefined method `#{method}' for #{inspect}"
+			@seconds
 		end
 	end
 
+	# For iterating through the duration set of weeks, days, hours, minutes, and
+	# seconds.
+	#
+	# *Example*
+	#
+	# 	Duration.new(:weeks => 1, :seconds => 30).each do |part, time|
+	# 		puts "part: #{part}, time: #{time}"
+	# 	end
+	#
+	# _Output_
+	#
+	# 	part: weeks, time: 1
+	# 	part: days, time: 0
+	# 	part: hours, time: 0
+	# 	part: minutes, time: 0
+	# 	part: seconds, time: 30
+	#
+	def each
+		[['weeks'   ,  @weeks  ],
+		 ['days'    ,  @days   ],
+		 ['hours'   ,  @hours  ],
+		 ['minutes' ,  @minutes],
+		 ['seconds' ,  @seconds]].each do |part, time|
+		 	# Yield to block
+			yield part, time
+		end
+	end
+
+	# Calls `<=>' on Duration#total.
+	#
+	# *Example*
+	#
+	# 	5.days == 24.hours * 5
+	# 	=> true
+	#
+	def <=>(other)
+		@total <=> other.to_i
+	end
+
+	# Set the number of weeks.
+	#
+	# *Example*
+	#
+	# 	d = Duration.new(0)
+	# 	=> #<Duration: ...>
+	# 	d.weeks = 2; d
+	# 	=> #<Duration: 2 weeks>
+	#
+	def weeks=(n)
+		initialize(:weeks => n, :seconds => @total - seconds(:weeks))
+	end
+
+	# Set the number of days.
+	#
+	# *Example*
+	#
+	# 	d = Duration.new(0)
+	# 	=> #<Duration: ...>
+	# 	d.days = 5; d
+	# 	=> #<Duration: 5 days>
+	#
+	def days=(n)
+		initialize(:days => n, :seconds => @total - seconds(:days))
+	end
+
+	# Set the number of hours.
+	#
+	# *Example*
+	#
+	# 	d = Duration.new(0)
+	# 	=> #<Duration: ...>
+	# 	d.hours = 5; d
+	# 	=> #<Duration: 5 hours>
+	#
+	def hours=(n)
+		initialize(:hours => n, :seconds => @total - seconds(:hours))
+	end
+
+	# Set the number of minutes.
+	#
+	# *Example*
+	#
+	# 	d = Duration.new(0)
+	# 	=> #<Duration: ...>
+	# 	d.minutes = 30; d
+	# 	=> #<Duration: 30 minutes>
+	#
+	def minutes=(n)
+		initialize(:minutes => n, :seconds => @total - seconds(:minutes))
+	end
+
+	# Set the number of minutes.
+	#
+	# *Example*
+	#
+	# 	d = Duration.new(0)
+	# 	=> #<Duration: ...>
+	# 	d.seconds = 30; d
+	# 	=> #<Duration: 30 seconds>
+	#
+	def seconds=(n)
+		initialize(:seconds => (@total + n) - @seconds)
+	end
+
 	# Friendly, human-readable string representation of the duration.
 	#
 	# *Example*
@@ -131,12 +251,7 @@ class Duration
 	def to_s
 		str = ''
 
-		[['weeks'   ,  @weeks  ],
-		 ['days'    ,  @days   ],
-		 ['hours'   ,  @hours  ],
-		 ['minutes' ,  @minutes],
-		 ['seconds' ,  @seconds]].each do |part, time|
-
+		each do |part, time|
 			# Skip any zero times.
 			next if time.zero?
 
@@ -213,12 +328,20 @@ class Duration
 	alias to_i total
 end
 
+# The following important additions are made to Numeric:
+#
+# 	Numeric#weeks   -- Create a Duration object with given weeks
+# 	Numeric#days    -- Create a Duration object with given days
+# 	Numeric#hours   -- Create a Duration object with given hours
+# 	Numeric#minutes -- Create a Duration object with given minutes
+# 	Numeric#seconds -- Create a Duration object with given seconds
+#
 class Numeric
-	alias __Numeric_method_missing method_missing
+	alias __numeric_old_method_missing method_missing
 
-	# Intercept calls to #weeks, #days, #hours, #minutes, #seconds because Rails
-	# defines their own methods, so I'd like to prevent any redefining of Rails'
-	# methods.
+	# Intercept calls to .weeks, .days, .hours, .minutes and .seconds because
+	# Rails defines its own methods, so I'd like to prevent any redefining of
+	# Rails' methods.
 	#
 	# *Example*
 	#
@@ -226,14 +349,10 @@ class Numeric
 	# 	=> #<Duration: 2 minutes and 20 seconds>
 	#
 	def method_missing(method, *args)
-		case method
-		when :weeks   then Duration.new(Duration::WEEK   * self)
-		when :days    then Duration.new(Duration::DAY    * self)
-		when :hours   then Duration.new(Duration::HOUR   * self)
-		when :minutes then Duration.new(Duration::MINUTE * self)
-		when :seconds then Duration.new(Duration::SECOND * self)
+		if [:weeks, :days, :hours, :minutes, :seconds].include? method
+			Duration.new(method => self)
 		else
-			__Numeric_method_missing(method, *args)
+			__numeric_old_method_missing(method, *args)
 		end
 	end
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: duration
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
-date: 2006-05-23 00:00:00 +09:00
+  version: 0.0.3
+date: 2006-05-24 00:00:00 +09:00
 summary: Duration is a package for manipulating time spans.
 require_paths: 
 - lib