duration 0.0.4 → 0.1.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2007 Matthew Harris
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,152 @@
+= Project
+== Duration
+== http://rubyforge.org/projects/duration
+
+= Author
+Matthew Harris <matt@matthewharris.org>
+http://matthewharris.org
+
+= Synopsis
+Duration objects are simple mechanisms that allow you to operate on durations
+of time.
+
+They allow you to know how much time has passed since a certain
+point in time, or they can tell you how much time something is (when given as
+seconds) in different units of time measurement.
+
+Durations would particularly be useful for those scripts or applications that
+allow you to know the uptime of themselves or perhaps provide a countdown until
+a certain event.
+
+As of version 0.1.0, the duration library has been completely rewritten with
+better knowledge.
+
+= Features
+Duration is packed with many features and has plans for many more.
+
+=== Current features
+* Duck typing objects to work with Duration
+* Localization support of formatted strings (feel free to submit your own!)
+* Capability to compare durations to any object (duck typing)
+* Arithmetic operations from Duration instances are legal (duck typing)
+* Convenience methods for creating durations from Time objects
+
+=== Soon to come features
+* Collection of holiday-related methods (creating durations since/until a holiday)
+* A larger collection of locales
+* Definitely have to put more Rubyisms in there too!
+* ...and much more! (can't think of any yet)
+
+= Credits
+I want to thank everyone who downloaded duration, tried it, and sent me e-mails
+of appreciation, feedback, bug reports and suggestions.
+
+Your gratitude has motivated me to rework this almost-dead library and continue
+to maintain it.
+
+Thanks!
+
+= Usage
+Using the duration library is fairly simple and straight-forward.  The base
+class most of you will be using is the Duration class.
+
+=== Initialization
+There are two ways to initialize the Duration class.  One way is to pass an
+object capable of responding to the #to_i method.  That object is expected to
+return an integer or float that represents the number of seconds for the
+duration object.
+
+The second way to initialize the Duration class is to pass a key=>value paired
+Hash object.  The hash's keys will be scanned for units of measurement defiend
+in Duration::UNITS or (the keys of) Duration::MULTIPLES.
+
+Here's an example of using the formerly mentioned solution:
+    duration = Duration.new(Time.now)
+    => #<Duration: 1981 weeks, 3 hours, 50 minutes and 44 seconds>
+    
+As you can see, it gave us the duration since the UNIX epoch.  This works fine
+because Time objects respond to the #to_i method.  And Time#to_i returns a
+UNIX timestamp (which is the number of seconds that have passed since the UNIX
+epoch, January 1, 1970).
+
+Before I move on to demonstrating the second solution, I'd like to note that
+there are Time#to_duration, Time#duration and Duration.since_epoch for
+accomplishing similar tasks.
+
+Alright, the second solution is to pass in a Hash object, as previously
+mentioned.
+
+For example:
+    duration = Duration.new(:hours => 12, :minutes => 58, :days => 14)
+    => #<Duration: 2 weeks, 12 hours and 58 minutes>
+    
+So, it works.  But also notice that I gave it `:days => 14', but it spat out
+`2 weeks'.  Yes, Duration knows what it's doing.
+
+There are more keys you can pass.  Check all the keys available in the
+Duration::MULTIPLES hash to see.  All those keys are valid to pass.  Any
+duplicated multiples will merely be added to each other, so be careful if that's
+not the desired behavior.
+
+=== Formatting
+The Duration class provides Duration#format (alias: Duration#strftime) for
+formatting the time units into a string.
+
+For more information on the identifiers it supports, check out Duration#format.
+
+Here's an example of how to format the known minutes in the duration:
+    duration = Duration.since_epoch
+    duration.format('%~m passed: %m')
+    => "minutes passed: 4"
+    
+Now, this may look a bit tricky at first, but it's somewhat similar to the
+standard strftime() function you see in many lanuages, with the exception of the
+weird "%~m" type identifiers.  These identifiers are the correct terminology for
+the corresponding time unit.
+
+The identifiers are locale-sensitive and can be easily changed to another
+language.  Localization is done internally from the duration library, and does
+not use the system's locales.
+
+If you would like to write a locale for your language (if it doesn't exist),
+you can simply read the source code of the existing locales lying within the
+"duration/localizations" directory.  They are straight-forward 10-15 line
+modules and are not complex at all.
+
+=== Arithmetic
+Duration objects support arithmetic against any object that response to the
+#to_i method.  This is pretty self-explanatory.  What happens when you divide
+a duration by 2?
+
+    duration = Duration.since_epoch
+    => #<Duration: 1981 weeks, 4 hours, 12 minutes and 54 seconds>
+    
+    duration / 2
+    => #<Duration: 990 weeks, 3 days, 14 hours, 6 minutes and 27 seconds>
+    
+Pretty simple, right?
+
+=== Magical Methods
+Finally, Duration has a few magical methods that are handled through the
+#method_missing override.  Duration instances support all method calls to such
+methods as `round_<unit>_to_<unit>' and `<unit>_to_<unit>'.  These methods
+basically convert their <unit> to another <unit> and spit back the numbers.
+
+The `round_<unit>_to_<unit>' method rounds the converted unit.
+
+    Duration.since_epoch.weeks_to_days
+    => 13867.0
+    
+    Duration.since_epoch.round_weeks_to_days
+    => 13867
+    
+    Duration.since_epoch.weeks_to_days.round
+    => 13867
+    
+= Feedback
+Well, I hope you learned a lot from the above explanations.  Time for you to get
+creative on your own now!
+
+If you have any feedback, bug reports, suggestions or locale submissions, just
+e-mail me at matt@matthewharris.org or shugotenshi@gmail.com and I will be glad
+to answer you back.

data/lib/duration.rb

@@ -1,515 +1,204 @@
-# = Author
-#
-# Matthew Harris (mailto:shugotenshi@gmail.com)
-#
-# = Project
-#
-# http://www.rubyforge.org/projects/duration
-#
-# = Synopsis
-#
-# Duration is a simple class that provides ways of easily manipulating durations
-# (timespans) and formatting them as well.
-#
-# = Usage
-#
-# 	require 'duration'
-# 	=> true
-# 	d = Duration.new(60 * 60 * 24 * 10 + 120 + 30)
-# 	=> #<Duration: 1 week, 3 days, 2 minutes and 30 seconds>
-# 	d.to_s
-# 	=> "1 week, 3 days, 2 minutes and 30 seconds"
-# 	[d.weeks, d.days]
-# 	=> [1, 3]
-# 	d.days = 7; d
-# 	=> #<Duration: 2 weeks, 2 minutes and 30 seconds>
-# 	d.strftime('%w w, %d d, %h h, %m m, %s s')
-# 	=> "2 w, 0 d, 0 h, 2 m, 30 s"
-#
+require 'duration/version'
+require 'duration/numeric'
+require 'duration/time'
+require 'duration/localizations'
+Duration::Localizations.load_all
+
+# Duration objects are simple mechanisms that allow you to operate on durations
+# of time.  They allow you to know how much time has passed since a certain
+# point in time, or they can tell you how much time something is (when given as
+# seconds) in different units of time measurement.  Durations would particularly
+# be useful for those scripts or applications that allow you to know the uptime
+# of themselves or perhaps provide a countdown until a certain event.
 class Duration
-	include Comparable
-	include Enumerable
-
-	attr_reader :total, :weeks, :days, :hours, :minutes
-
-	WEEK    =  60 * 60 * 24 * 7
-	DAY     =  60 * 60 * 24
-	HOUR    =  60 * 60
-	MINUTE  =  60
-	SECOND  =  1
-
-	# Initialize Duration class.
-	#
-	# *Example*
-	#
-	# 	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 = 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
-
-		@total, array = seconds.to_f.round, []
-		@seconds = [WEEK, DAY, HOUR, MINUTE].inject(@total) do |left, part|
-			array << left / part; left % part
-		end
-
-		@weeks, @days, @hours, @minutes = array
-	end
-
-	# Format duration.
-	#
-	# *Identifiers*
-	#
-	# 	%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*
-	#
-	# 	d = Duration.new(:weeks => 10, :days => 7)
-	# 	=> #<Duration: 11 weeks>
-	# 	d.strftime("It's been %w weeks!")
-	# 	=> "It's been 11 weeks!"
-	#
-	def strftime(fmt)
-		h =\
-		{'w' => @weeks  ,
-		 'd' => @days   ,
-		 'h' => @hours  ,
-		 'm' => @minutes,
-		 's' => @seconds,
-		 't' => @total  ,
-		 'x' => to_s}
-
-		fmt.gsub(/%?%(w|d|h|m|s|t|x)/) do |match|
-			match.size == 3 ? match : h[match[1..1]]
-		end.gsub('%%', '%')
-	end
-
-	# Get the number of seconds of a given part, or simply just get the number of
-	# seconds.
-	#
-	# *Example*
-	#
-	# 	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
-			@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
+  include Comparable
+  include Enumerable
+  
+  # Unit multiples
+  MULTIPLES = {
+    :seconds => 1,
+    :minutes => 60,
+    :hours   => 3600,
+    :days    => 86400,
+    :weeks   => 604800,
+    :second  => 1,
+    :minute  => 60,
+    :hour    => 3600,
+    :day     => 86400,
+    :week    => 604800
+  }
+  
+  # Unit names
+  UNITS = [:seconds, :minutes, :hours, :days, :weeks]
+  
+  attr_reader :total, :seconds, :minutes, :hours, :days, :weeks
+  
+  # Change the locale Duration will use when converting itself to a string
+  def Duration.change_locale(locale)
+    @@locale = Localizations.locales[locale.to_sym] or raise LocaleError, "undefined locale '#{locale}'"
+  end
+  
+  # Load default locale
+  change_locale(Localizations::DEFAULT_LOCALE)
+  
+  # Constructs a Duration instance that represents the duration since the UNIX
+  # epoch (1970-01-01T00:00:00Z)
+  def Duration.since_epoch
+    new(Time.now)
+  end
+  
+  # Initialize a duration.  `args' can be a hash or anything else.  If a hash is
+  # passed, it will be scanned for a key=>value pair of time units such as those
+  # listed in the Duration::UNITS array or Duration::MULTIPLES hash.
+  #
+  # If anything else except a hash is passed, #to_i is invoked on that object
+  # and expects that it return the number of seconds desired for the duration.
+  def initialize(args = 0)
+    # Two types of arguments are accepted.  If it isn't a hash, it's converted
+    # to an integer.
+    if args.kind_of?(Hash)
+      @seconds = 0
+      MULTIPLES.each do |unit, multiple|
+        unit = unit.to_sym
+        @seconds += args[unit] * multiple if args.key?(unit)
+      end
+    else
+      @seconds = args.to_i
+    end
+    
+    # Calculate duration
+    calculate!
+  end
+  
+  # Calculates the duration from seconds and figures out what the actual
+  # durations are in specific units.  This method is called internally, and
+  # does not need to be called by user code.
+  def calculate!
+		multiples = [MULTIPLES[:weeks], MULTIPLES[:days], MULTIPLES[:hours], MULTIPLES[:minutes], MULTIPLES[:seconds]]
+		units     = []
+		@total    = @seconds.to_f.round
+		multiples.inject(@total) do |total, multiple|
+		  # Divide into largest unit
+			units << total / multiple
+			total % multiple # The remainder will be divided as the next largest
 		end
-	end
-
-	# Calls `<=>' on Duration#total.
-	#
-	# *Example*
-	#
-	# 	5.days == 24.hours * 5
-	# 	=> true
-	#
+		
+		# Gather the divided units
+		@weeks, @days, @hours, @minutes, @seconds = units
+  end
+  
+  # Compare this duration to another (or objects that respond to #to_i)
 	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*
-	#
-	# 	d = Duration.new(:seconds => 140)
-	# 	=> #<Duration: 2 minutes and 20 seconds>
-	# 	d.to_s
-	# 	=> "2 minutes and 20 seconds"
-	#
-	def to_s
-		str = ''
-
-		each do |part, time|
-			# Skip any zero times.
-			next if time.zero?
-
-			# Concatenate the part of the time and the time itself.
-			str << "#{time} #{time == 1 ? part[0..-2] : part}, "
-		end
-
-		str.chomp(', ').sub(/(.+), (.+)/, '\1 and \2')
-	end
-
-	# Inspection string--Similar to #to_s except that it has the class name.
-	#
-	# *Example*
-	#
-	# 	Duration.new(:seconds => 140)
-	# 	=> #<Duration: 2 minutes and 20 seconds>
-	#
+  
+  # Convenient iterator for going through each duration unit from lowest to
+  # highest.  (Goes from seconds...weeks)
+  def each
+    UNITS.each { |unit| yield unit, __send__(unit) }
+  end
+  
+  # Format a duration into a human-readable string.
+  #
+  #   %w  => weeks
+  #   %d  => days
+  #   %h  => hours
+  #   %m  => minutes
+  #   %s  => seconds
+  #   %t  => total seconds
+  #   %H  => zero-padded hours
+  #   %M  => zero-padded minutes
+  #   %S  => zero-padded seconds
+  #   %~s => locale-dependent "seconds" terminology
+  #   %~m => locale-dependent "minutes" terminology
+  #   %~h => locale-dependent "hours" terminology
+  #   %~d => locale-dependent "days" terminology
+  #   %~w => locale-dependent "weeks" terminology
+  #   
+  def format(format_str)
+    identifiers = {
+      'w'  => @weeks,
+      'd'  => @days,
+      'h'  => @hours,
+      'm'  => @minutes,
+      's'  => @seconds,
+      't'  => @total,
+      'H'  => @hours.to_s.rjust(2, '0'),
+      'M'  => @minutes.to_s.rjust(2, '0'),
+      'S'  => @seconds.to_s.rjust(2, '0'),
+      '~s' => @seconds == 1 ? @@locale.singulars[0] : @@locale.plurals[0],
+      '~m' => @minutes == 1 ? @@locale.singulars[1] : @@locale.plurals[1],
+      '~h' => @hours   == 1 ? @@locale.singulars[2] : @@locale.plurals[2],
+      '~d' => @days    == 1 ? @@locale.singulars[3] : @@locale.plurals[3],
+      '~w' => @weeks   == 1 ? @@locale.singulars[4] : @@locale.plurals[4]
+    }
+
+		format_str.gsub(/%?%(w|d|h|m|s|t|H|M|S|~(?:s|m|h|d|w))/) do |match|
+			match['%%'] ? match : identifiers[match[1..-1]]
+		end.gsub('%%', '%')
+  end
+  
+  def method_missing(m, *args, &block)
+    units = UNITS.join('|')
+    match = /(round_)?(#{units})_to_(#{units})$/.match(m.to_s)
+    if match
+      seconds = ((__send__(match[2].to_sym) * MULTIPLES[match[2].to_sym]) / MULTIPLES[match[3].to_sym].to_f)
+      match[1] ? seconds.round : seconds
+    else
+      super
+    end
+  end
+  
+  # String representation of the Duration object.
+  def to_s
+    @@locale.format.call(self)
+  end
+  
+  # Inspect Duration object.
 	def inspect
 		"#<#{self.class}: #{(s = to_s).empty? ? '...' : s}>"
 	end
-
-	# Add to Duration.
-	#
-	# *Example*
-	#
-	# 	d = Duration.new(30)
-	# 	=> #<Duration: 30 seconds>
-	# 	d + 30
-	# 	=> #<Duration: 1 minute>
-	#
+	
 	def +(other)
-		self.class.new(@total + other.to_i)
+		Duration.new(@total + other.to_i)
 	end
-
-	# Subtract from Duration.
-	#
-	# *Example*
-	#
-	# 	d = Duration.new(30)
-	# 	=> #<Duration: 30 seconds>
-	# 	d - 15
-	# 	=> #<Duration: 15 seconds>
-	#
+	
 	def -(other)
-		self.class.new(@total - other.to_i)
+		Duration.new(@total - other.to_i)
 	end
-
-	# Multiply two Durations.
-	#
-	# *Example*
-	#
-	# 	d = Duration.new(30)
-	# 	=> #<Duration: 30 seconds>
-	# 	d * 2
-	# 	=> #<Duration: 1 minute>
-	#
+	
 	def *(other)
-		self.class.new(@total * other.to_i)
+		Duration.new(@total * other.to_i)
 	end
-
-	# Divide two Durations.
-	#
-	# *Example*
-	#
-	# 	d = Duration.new(30)
-	# 	=> #<Duration: 30 seconds>
-	# 	d / 2
-	# 	=> #<Duration: 15 seconds>
-	#
+	
 	def /(other)
-		self.class.new(@total / other.to_i)
-	end
-
-	alias to_i total
-end
-
-# BigDuration is a variant of Duration that supports years and months. Support
-# for months is not accurate, as a month is assumed to be 30 days so use at your
-# own risk.
-#
-class BigDuration < Duration
-	attr_reader :years, :months
-
-	YEAR   =  60 * 60 * 24 * 30 * 12
-	MONTH  =  60 * 60 * 24 * 30
-
-	# Similar to Duration.new except that BigDuration.new supports `:years' and
-	# `:months' and will also handle years and months correctly when breaking down
-	# the seconds.
-	#
-	def initialize(seconds_or_attr = 0)
-		if seconds_or_attr.kind_of? Hash
-			# Part->time map table.
-			h =\
-			{:years    =>  YEAR  ,
-			 :months   =>  MONTH ,
-			 :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
-
-		@total, array = seconds.to_f.round, []
-		@seconds = [YEAR, MONTH, WEEK, DAY, HOUR, MINUTE].inject(@total) do |left, part|
-			array << left / part; left % part
-		end
-
-		@years, @months, @weeks, @days, @hours, @minutes = array
-	end
-
-	# BigDuration variant of Duration#strftime.
-	#
-	# *Identifiers: BigDuration*
-	#
-	# 	%y -- Number of years
-	# 	%m -- Number of months
-	#
-	def strftime(fmt)
-		h = {'y' => @years, 'M' => @months}
-		super(fmt.gsub(/%?%(y|M)/) { |match| match.size == 3 ? match : h[match[1..1]] })
-	end
-
-	# Similar to Duration#each except includes years and months in the interation.
-	#
-	def each
-		[['years'   ,  @years  ],
-		 ['months'  ,  @months ],
-		 ['weeks'   ,  @weeks  ],
-		 ['days'    ,  @days   ],
-		 ['hours'   ,  @hours  ],
-		 ['minutes' ,  @minutes],
-		 ['seconds' ,  @seconds]].each do |part, time|
-		 	# Yield to block
-			yield part, time
-		end
-	end
-
-	# Derived from Duration#seconds, but supports `:years' and `:months' as well.
-	#
-	def seconds(part = nil)
-		h = {:years => YEAR, :months => MONTH}
-		if [:years, :months].include? part
-			__send__(part) * h[part]
-		else
-			super(part)
-		end
-	end
-
-	# Set the number of years in the BigDuration.
-	#
-	def years=(n)
-		initialize(:years => n, :seconds => @total - seconds(:years))
-	end
-
-	# Set the number of months in the BigDuration.
-	#
-	def months=(n)
-		initialize(:months => n, :seconds => @total - seconds(:months))
-	end
-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
-#
-# BigDuration support:
-#
-# 	Numeric#years   -- Create a BigDuration object with given years
-# 	Numeric#months  -- Create a BigDuration object with given months
-#
-# BigDuration objects can be created from regular weeks, days, hours, etc by
-# providing `:big' as an argument to the above Numeric methods.
-#
-class Numeric
-	alias __numeric_old_method_missing method_missing
-
-	# Create a Duration object using self where self could represent weeks, days,
-	# hours, minutes, and seconds.
-	#
-	# *Example*
-	#
-	# 	10.duration(:weeks)
-	# 	=> #<Duration: 10 weeks>
-	# 	10.duration
-	# 	=> #<Duration: 10 seconds>
-	#
-	def duration(part = nil, klass = Duration)
-		if [:years, :months, :weeks, :days, :hours, :minutes, :seconds].include? part
-			klass.new(part => self)
-		else
-			klass.new(self)
-		end
-	end
-
-	# 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. If these methods don't get captured, then alternatively
-	# Numeric#duration can be used.
-	#
-	# BigDuration methods include .years and .months, also BigDuration objects
-	# can be created from any time such as weeks or minutes and even seconds.
-	#
-	# *Example: BigDuration*
-	#
-	# 	5.years
-	# 	=> #<BigDuration: 5 years>
-	# 	10.minutes(:big)
-	# 	=> #<BigDuration: 10 minutes>
-	#
-	# *Example*
-	#
-	# 	140.seconds
-	# 	=> #<Duration: 2 minutes and 20 seconds>
-	#
-	def method_missing(method, *args)
-		if [:weeks, :days, :hours, :minutes, :seconds].include? method
-			if args.size > 0 && args[0] == :big
-				duration(method, BigDuration)
-			else
-				duration(method)
-			end
-		elsif [:years, :months].include? method
-			duration(method, BigDuration)
-		else
-			__numeric_old_method_missing(method, *args)
-		end
-	end
-end
-
-# Time#duration has been added to convert the UNIX timestamp into a Duration.
-# See Time#duration for an example.
-#
-class Time
-	# Create a Duration object from the UNIX timestamp.
-	#
-	# *Example*
-	#
-	# 	Time.now.duration
-	# 	=> #<Duration: 1898 weeks, 6 days, 1 hour, 12 minutes and 1 second>
-	#
-	def duration(type = nil)
-		if type == :big then BigDuration.new(to_i) else Duration.new(to_i) end
-	end
+		Duration.new(@total / other.to_i)
+	end
+	
+	def %(other)
+		Duration.new(@total % other.to_i)
+	end
+  
+  def seconds=(seconds)
+    initialize :seconds => (@total + seconds) - @seconds
+  end
+  
+  def minutes=(minutes)
+    initialize :seconds => @total - minutes_to_seconds, :minutes => minutes
+  end
+  
+  def hours=(hours)
+    initialize :seconds => @total - hours_to_seconds, :hours => hours
+  end
+  
+  def days=(days)
+    initialize :seconds => @total - days_to_seconds, :days => days
+  end
+  
+  def weeks=(weeks)
+    initialize :seconds => @total - weeks_to_seconds, :weeks => weeks
+  end
+  
+  alias_method :to_i, :total
+  alias_method :strftime, :format
 end

data/lib/duration/holidays.rb

@@ -0,0 +1,3 @@
+class Duration
+  # Holiday durations shall go here.
+end

data/lib/duration/locale.rb

@@ -0,0 +1,3 @@
+class Duration
+  Locale = Struct.new(:name, :plurals, :singulars, :format)
+end

data/lib/duration/localizations.rb

@@ -0,0 +1,42 @@
+require 'duration/locale'
+require 'duration/localizations/english'
+require 'duration/localizations/korean'
+
+class Duration
+  # Contains localizations for the time formatters.  Standard locales cannot be
+  # used because they don't define time units.
+  module Localizations
+    # Default locale
+    DEFAULT_LOCALE = :english
+    @@locales = {}
+    
+    # Load all locales.  This is invoked automatically upon loading Duration.
+    def Localizations.load_all
+      locales = []
+      constants.each do |constant|
+        mod = const_get(constant)
+        next unless mod.kind_of?(Module) and mod.const_defined?('LOCALE')
+        
+        locale    = mod.const_get('LOCALE').to_sym  # Locale name
+        plurals   = mod.const_defined?('PLURALS') ? mod.const_get('PLURALS') : DEFAULT_LOCALE # Unit plurals
+        singulars = mod.const_defined?('SINGULARS') ? mod.const_get('SINGULARS') : DEFAULT_LOCALE # Unit singulars
+        
+        if mod.const_defined? 'FORMAT'
+          format = mod.const_get 'FORMAT'
+          format = format.kind_of?(Proc) ? format : proc { |duration| duration.format(format.to_s) }
+        end
+        
+        # Add valid locale to the collection.
+        @@locales[locale] = Locale.new(locale, plurals, singulars, format)
+      end
+    end
+    
+    # Collection of locales
+    def Localizations.locales
+      @@locales
+    end
+  end
+  
+  class LocaleError < StandardError
+  end
+end

data/lib/duration/localizations/english.rb

@@ -0,0 +1,14 @@
+class Duration
+  module Localizations
+    # English localization
+    module English
+      LOCALE    = :english
+      PLURALS   = %w(seconds minutes hours days weeks)
+      SINGULARS = %w(second minute hour day week)
+      FORMAT    = proc do |duration|
+    		str = duration.format('%w %~w, %d %~d, %h %~h, %m %~m, %s %~s')
+    		str.sub(/^0 [a-z]+,?/i, '').gsub(/ 0 [a-z]+,?/i, '').chomp(',').sub(/, (\d+ [a-z]+)$/i, ' and \1').strip
+    	end
+    end
+  end
+end

data/lib/duration/localizations/korean.rb

@@ -0,0 +1,14 @@
+class Duration
+  module Localizations
+    # Korean localization
+    module Korean
+      LOCALE    = :korean
+      PLURALS   = %w(초 분 시간 일 주)
+      SINGULARS = %w(초 분 시간 일 주)
+      FORMAT    = proc do |duration|
+    		str = duration.format('%w%~w, %d%~d, %h%~h, %m%~m, %s%~s')
+    		str.sub(/^0[^\d+,]+,?/i, '').gsub(/ 0[^\d+,]+,?/i, '').chomp(',').strip
+    	end
+    end
+  end
+end

data/lib/duration/numeric.rb

@@ -0,0 +1,63 @@
+# Additional methods added to numeric objects allow the developer to construct
+# a calculated number of seconds through human-readable methods.
+#
+#   60.seconds #=> 60
+#   60.minutes #=> 3600
+#   ... and so on
+#
+# Singular methods are also defined.
+#
+#   1.minute #=> 60
+#   1.hour   #=> 3600
+#   ... and so on
+class Numeric
+  # Number of seconds (equivalent to Numeric#to_i)
+  def seconds
+    to_i
+  end unless Numeric.instance_methods.include? 'seconds'
+  
+  # Number of seconds using the number as the base of minutes.
+  def minutes
+    to_i * 60
+  end unless Numeric.instance_methods.include? 'minutes'
+  
+  # Number of seconds using the number as the base of hours.
+  def hours
+    to_i * 3600
+  end unless Numeric.instance_methods.include? 'hours'
+  
+  # Number of seconds using the number as the base of days.
+  def days
+    to_i * 86400
+  end unless Numeric.instance_methods.include? 'days'
+  
+  # Number of seconds using the number as the base of weeks.
+  def week
+    to_i * 604800
+  end unless Numeric.instance_methods.include? 'weeks'
+  
+  # Number of seconds (singular form).
+  def second
+    to_i
+  end unless Numeric.instance_methods.include? 'second'
+  
+  # Number of seconds using the number as the base of minutes (singular form).
+  def minute
+    to_i * 60
+  end unless Numeric.instance_methods.include? 'minute'
+  
+  # Number of seconds using the number as the base of hours (singular form).
+  def hour
+    to_i * 3600
+  end unless Numeric.instance_methods.include? 'hour'
+  
+  # Number of seconds using the number as the base of days (singular form).
+  def day
+    to_i * 86400
+  end unless Numeric.instance_methods.include? 'day'
+  
+  # Number of seconds using the number as the base of weeks (singular form).
+  def week
+    to_i * 604800
+  end unless Numeric.instance_methods.include? 'week'
+end

data/lib/duration/time.rb

@@ -0,0 +1,7 @@
+class Time
+  def to_duration
+    Duration.new(self)
+  end
+  
+  alias_method :duration, :to_duration
+end

data/lib/duration/version.rb

@@ -0,0 +1,9 @@
+class Duration
+  # Duration library version number
+  VERSION = '0.1.0'
+
+  # Duration library version number
+  def Duration.version
+    VERSION
+  end
+end

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.4
 specification_version: 1
 name: duration
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
-date: 2006-05-24 00:00:00 +09:00
-summary: Duration is a package for manipulating time spans.
+  version: 0.1.0
+date: 2007-12-20 00:00:00 +09:00
+summary: Duration/timespan manipulation library
 require_paths: 
 - lib
-email: shugotenshi@gmail.com
+email: matt@matthewharris.org
 homepage: http://duration.rubyforge.org
 rubyforge_project: duration
-description: Duration is a simple class that provides ways of easily manipulating durations (timespans) and formatting them as well.
-autorequire: 
+description: Duration is a library for manipulating timespans.  It can give you readable output for a timespan as well as manipulate the timespan itself.  With this it is possible to make "countdowns" or "time passed since" type objects.
+autorequire: duration
 default_executable: 
 bindir: bin
 has_rdoc: true
@@ -25,16 +25,32 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Matthew Harris
 files: 
+- lib/duration/holidays.rb
+- lib/duration/locale.rb
+- lib/duration/localizations/english.rb
+- lib/duration/localizations/korean.rb
+- lib/duration/localizations.rb
+- lib/duration/numeric.rb
+- lib/duration/time.rb
+- lib/duration/version.rb
 - lib/duration.rb
+- README
+- LICENSE
 test_files: []
 
-rdoc_options: []
-
-extra_rdoc_files: []
-
+rdoc_options: 
+- --title
+- Duration -- The Timespan Library
+- --main
+- README
+- --line-numbers
+extra_rdoc_files: 
+- README
+- LICENSE
 executables: []
 
 extensions: []