facets 2.4.5 → 2.5.0

data/lib/core/facets/time/stamp.rb

@@ -19,7 +19,7 @@ class Time
 
   # Produce time stamp for Time.now. See #stamp.
   #
-  #   CREDIT: Trans
+  # CREDIT: Trans
 
   def self.stamp(*args)
     now.stamp(*args)
@@ -31,7 +31,7 @@ class Time
   #
   # Supported formats come from the Time::FORMAT constant.
   #
-  #   CREDIT: Trans
+  # CREDIT: Trans
 
   def stamp(fmt = nil)
     unless String === fmt

data/lib/core/facets/to_hash.rb

@@ -15,7 +15,7 @@ class Array
   #
   #   array1.zip(array2).to_h
   #
-  #  CREDIT: Trans
+  # CREDIT: Trans
 
   def to_h(arrayed=nil)
     h = {}

data/lib/core/facets/unboundmethod/arguments.rb

@@ -16,7 +16,7 @@ class UnboundMethod
   #
   # When defaults are used the arguments must end in "*args".
   #
-  #   CREDIT: Trans
+  # CREDIT: Trans
 
   def arguments
     ar = arity

data/lib/core/facets/unboundmethod/name.rb

@@ -13,7 +13,7 @@ unless (RUBY_VERSION[0,3] == '1.9')
     #
     #   meth.name  #=> "foo"
     #
-    #   CREDIT: Trans
+    # CREDIT: Trans
 
     def name
       i = to_s.rindex('#')

data/lib/lore/facets/date.rb

@@ -84,7 +84,7 @@ class Date
   #
   #   Date.new(2004,2).days_in_month #=> 28
   #
-  #  CREDIT: Ken Kunz.
+  # CREDIT: Ken Kunz.
 
   def days_in_month
      Date.civil(year, month, -1).day
@@ -96,7 +96,7 @@ class Date
 
   # Get the month name for this date object
   #
-  #  CREDIT Benjamin Oakes
+  # CREDIT: Benjamin Oakes
 
   def month_name
     MONTHNAMES[self.month]

data/lib/lore/facets/enumerator.rb

@@ -0,0 +1,67 @@
+require 'enumerator'
+
+if RUBY_VERSION < "1.9"
+
+  module Enumerable
+
+    class Enumerator
+
+      alias :old_initialize :initialize
+
+      # Provides the ruby-1.9 block form of Enumerator, where you can write:
+      #
+      #    obj = Enumerator.new do |yielder|
+      #       .. do stuff
+      #       yielder.yield data      # or: yielder << data
+      #       .. etc
+      #    end
+      #
+      # When obj.each is called, the block is run once. It should call
+      # yielder.yield with each item it wishes to generate.
+      #
+      # Example:
+      #
+      #   fib = Enumerator.new { |y|
+      #     a = b = 1
+      #     loop {   
+      #       y << a
+      #       a, b = b, a + b
+      #     }
+      #   }  
+      #
+      #   assert_equal [1, 1, 2, 3, 5, 8, 13, 21, 34, 55], fib.take(10)
+                                                    
+      def initialize(*args, &block)
+        if block_given?
+          @body = block
+          old_initialize(self, :_start)
+        else
+          old_initialize(*args)
+        end
+      end
+
+      def _start(*args,&receiver) #:nodoc:
+        @body.call(Yielder.new(receiver), *args)
+      end
+
+      # Wrapper to allow yielder.yield(output) or yielder << output
+      # in the same way as ruby-1.9
+
+      class Yielder #:nodoc:
+        def initialize(proc)
+          @proc = proc
+        end
+        def yield(*args)
+          @proc[*args]
+        end
+        alias :<< :yield
+      end
+    end
+    
+  end
+
+  # For ruby-1.9 compatibility, define Enumerator class at top level
+  Enumerator = Enumerable::Enumerator unless defined? ::Enumerator
+
+end # if RUBY_VERSION
+

data/lib/lore/facets/ostruct.rb

@@ -53,9 +53,7 @@ class OpenStruct
   # A setter block versus a defualt block is determined by the arity of
   # the block. You can not provide both at the same time.
   #
-  #   CREDIT Noah Gibbs
-  #   CREDIT Gavin Sinclair
-  #   CREDIT 7rans
+  # CREDIT: Noah Gibbs, Gavin Sinclair
   #
   def initialize(hash=nil, &block)
     if block && block.arity==2
@@ -108,7 +106,7 @@ class OpenStruct
     @table[key]=val
   end
 
-  # CREDIT Robert J. Berger <rberger AT ibd.com>
+  # CREDIT: Robert J. Berger <rberger AT ibd.com>
   # Thanks for reporting issues that this method resolved.
 
   # Provides access to an OpenStruct's inner table.
@@ -200,9 +198,7 @@ class Hash
     OpenStruct.new(self)
   end
 
-  # CREDIT Alison Rowland
-  # CREDIT Jamie Macey
-  # CREDIT Mat Schaffer
+  # CREDIT Alison Rowland, Jamie Macey, Mat Schaffer
 
   #--
   # Special thanks to Alison Rowland, Jamie Macey and Mat Schaffer

data/lib/more/facets/attr.rb

@@ -3,7 +3,7 @@ class Module
   # Like attr_writer, but the writer method validates the
   # setting against the given block.
   #
-  #   CREDIT: ?
+  # CREDIT: ?
 
   def attr_validator(*symbols, &validator)
     made = []
@@ -48,7 +48,7 @@ class Module
   #     end
   #   end
   #
-  #  CREDIT: Trans
+  # CREDIT: Trans
 
   def attr_setter(*args)
     code, made = '', []
@@ -76,7 +76,7 @@ class Module
   #   x.b = 1
   #   x.a        #=> 1
   #
-  #  CREDIT: Trans
+  # CREDIT: Trans
 
   def alias_setter(*args)
     args = args - [orig]
@@ -102,7 +102,7 @@ class Module
   #     self
   #   end
   #
-  #  CREDIT: Trans
+  # CREDIT: Trans
 
   def attr_accessor!(*args)
     attr_reader!(*args) + attr_writer!(*args)
@@ -112,7 +112,7 @@ class Module
 
   # Create aliases for flag accessors.
   #
-  #  CREDIT: Trans
+  # CREDIT: Trans
 
   def alias_accessor!(*args)
     orig = args.last
@@ -135,7 +135,7 @@ class Module
   #   def a?
   #     @a ? true : @a
   #   end
-
+  #
   def attr_reader!(*args)
     code, made = '', []
     args.each do |a|
@@ -154,7 +154,7 @@ class Module
 
   # Create aliases for flag reader.
   #
-  #  CREDIT: Trans
+  # CREDIT: Trans
 
   def alias_reader!(*args)
     orig = args.last
@@ -177,7 +177,7 @@ class Module
   #     @a = value
   #     self
   #   end
-
+  #
   def attr_writer!(*args)
     code, made = '', []
     args.each do |a|
@@ -195,7 +195,7 @@ class Module
 
   # Create aliases for flag writer.
   #
-  #  CREDIT: Trans
+  # CREDIT: Trans
 
   def alias_writer!(*args)
     orig = args.last
@@ -206,3 +206,4 @@ class Module
   end
 
 end
+

data/lib/more/facets/consoleutils.rb

@@ -1,18 +1,4 @@
-# = Console Utilities
-#
-# ConsoleUtils provides methods that are
-# generally useful in the context of
-# creating console output.
-#
-# = Authors
-#
-# * Thomas Sawyer
-#
-# == Copying
-#
-# Copyright (c) 2006,2007 Thomas Sawyer
-# Ruby/GPL
-
+warn "WARNING: facets/consoleutils.rb will be deprecated. Use alternate solution, such as Clio, for future versions."
 
 # = ConsoleUtils
 #

data/lib/more/facets/dependency.rb

@@ -142,7 +142,7 @@ class Module
 
 end
 
-class RecursiveDependency < StandardError; end
+#class RecursiveDependency < StandardError; end
 
 
 #class Module

data/lib/more/facets/duration.rb

@@ -1,540 +1,286 @@
-# = Duration
-#
-# Duration is a simple class that provides ways of easily manipulating durations
-# (timespans) and formatting them as well.
-#
-#   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"
-#
-# == Author
-#
-# * Matthew Harris (mailto:shugotenshi@gmail.com)
-#
-# == Notes
-#
-# * This library comes from the orginal Duration project.
-#   See: http://www.rubyforge.org/projects/duration
-#
-# == Copying
-#
-# Copyright (c) 2006 Matthew Harris <shugotenshi at gmail.com>
-
-# = Duration
-#
-# Duration is a simple class that provides ways of easily manipulating durations
-# (timespans) and formatting them as well.
-#
-#     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"
-
 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('%%', '%')
+  include Comparable
+
+  SECOND =   1
+  MINUTE =  60 * SECOND
+  HOUR   =  60 * MINUTE
+  DAY    =  24 * HOUR
+  WEEK   =   7 * DAY
+  YEAR   = 365 * DAY
+
+  SEGMENTS = %w{years weeks days hours minutes seconds}.collect{ |s| s.to_sym }
+
+  #
+  def self.[](seconds, *segments)
+    new(seconds, *segments)
+  end
+
+  #
+  def initialize(seconds=0, *segments)
+    @seconds = seconds.to_i
+    reset_segments(*segments)
+  end
+
+  #
+  def segments; @segments; end
+
+  #
+  def reset_segments(*segments)
+    case segments.size
+    when 0
+      @segments = [:days, :hours, :minutes, :seconds]
+    when 1
+      case segments = segments[0]
+      when Array
+        @segments = segments.collect{ |p| (p.to_s.downcase.chomp('s') + 's').to_sym }
+        raise ArgumentError unless @segments.all?{ |s| SEGMENTS.include?(s) }
+      else
+        f = SEGMENTS.index(segments)
+        @segments = SEGMENTS[f..0]
+      end
+    when 2
+      f = SEGMENTS.index(segments[0])
+      t = SEGMENTS.index(segments[1])
+      @segments = SEGMENTS[f..t]
+    else
+      raise ArgumentError
     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
-        end
-    end
-
-    # Calls `<=>' on Duration#total.
-    #
-    # *Example*
-    #
-    #     5.days == 24.hours * 5
-    #     => true
-    #
-    def <=>(other)
-        @total <=> other.to_i
+  end
+
+  def inspect
+    h = to_h
+    segments.reverse.collect do |l|
+      "#{h[l.to_sym]} #{l}"
+    end.join(' ')
+  end
+
+  def to_i ; @seconds.to_i ; end
+  def to_f ; @seconds.to_f ; end
+
+  public
+
+  def to_a
+    a, s = [], @seconds
+    a[5], s = *s.divmod(YEAR)   if @segments.include?(:years)
+    a[4], s = *s.divmod(WEEK)   if @segments.include?(:weeks)
+    a[3], s = *s.divmod(DAY)    if @segments.include?(:days)
+    a[2], s = *s.divmod(HOUR)   if @segments.include?(:hours)
+    a[1], s = *s.divmod(MINUTE) if @segments.include?(:minutes)
+    a[0], s = *s.divmod(SECOND) if @segments.include?(:seconds)
+    a.compact.reverse
+  end
+
+  #
+  def to_h
+    h, s = {}, @seconds
+    h[:years],   s = *s.divmod(YEAR)   if @segments.include?(:years)
+    h[:weeks],   s = *s.divmod(WEEK)   if @segments.include?(:weeks)
+    h[:days],    s = *s.divmod(DAY)    if @segments.include?(:days)
+    h[:hours],   s = *s.divmod(HOUR)   if @segments.include?(:hours)
+    h[:minutes], s = *s.divmod(MINUTE) if @segments.include?(:minutes)
+    h[:seconds], s = *s.divmod(SECOND) if @segments.include?(:seconds)
+    h
+  end
+
+  def to_s
+    h = to_h
+    segments.reverse.collect do |l|
+      "#{h[l.to_sym]} #{l}"
+    end.join(' ')
+  end
+
+  # Returns true if <tt>other</tt> is also a Duration instance with the
+  # same <tt>value</tt>, or if <tt>other == value</tt>.
+  def ==(other)
+    if Duration === other
+      other.seconds == seconds
+    else
+      other == seconds
     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>
-    #
-    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)
-    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)
-    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)
-    end
-
-    # Divide two Durations.
+  end
+
+  def <=>(other)
+    @seconds <=> other.to_i
+  end
+
+  #def is_a?(klass) #:nodoc:
+  #  klass == self.class
+  #end
+
+  #def self.===(other) #:nodoc:
+  #  other.is_a?(Duration) rescue super
+  #end
+
+  def years   ; to_h[:years]   ; end
+  def weeks   ; to_h[:weeks]   ; end
+  def days    ; to_h[:days]    ; end
+  def hours   ; to_h[:hours]   ; end
+  def minutes ; to_h[:minutes] ; end
+  def seconds ; to_h[:seconds] ; end
+
+  def total ; seconds ; end
+
+  def +(other)
+    self.class.new(@seconds + other.to_i, segments)
+  end
+
+  def -(other)
+    self.class.new(@seconds - other.to_i, segments)
+  end
+
+  def +(other)
+    self.class.new(@seconds * other.to_i, segments)
+  end
+
+  def /(other)
+    self.class.new(@seconds / other.to_i, segments)
+  end
+
+  #
+  def segmented(*segments)
+    self.class.new(@seconds, segments)
+    #segments = segments.collect{ |p| p.to_s.downcase.chomp('s') }
+    #y,w,d,h,m,s = nil,nil,nil,nil,nil,nil
+    #x = @seconds
+    #y, x = *x.divmod(YEAR)   if segments.include?('year')
+    #w, x = *x.divmod(WEEK)   if segments.include?('week')
+    #d, x = *x.divmod(DAY)    if segments.include?('day')
+    #h, x = *x.divmod(HOUR)   if segments.include?('hour')
+    #m, x = *x.divmod(MINUTE) if segments.include?('minute')
+    #s = x if segments.include?('second')
+    #[y, w, d, h, m, s].compact
+  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 = to_h
+    hx = {
+     'y' => h[:years]  ,
+     'w' => h[:weeks]  ,
+     'd' => h[:days]   ,
+     'h' => h[:hours]  ,
+     'm' => h[:minutes],
+     's' => h[:seconds],
+     't' => total,
+     'x' => to_s 
+    }
+    fmt.gsub(/%?%(w|d|h|m|s|t|x)/) do |match|
+      hx[match[1..1]]
+    end.gsub('%%', '%')
+  end
+
+  #
+  def -@ #:nodoc:
+    self.class.new(-@seconds)
+  end
+
+  #
+  def +@ #:nodoc:
+    self.class.new(+@seconds)
+  end
+
+  #
+  # Need to wrap back to numeric methods, maybe use method_missing?
+  #
+
+  #
+  def before(time)
+    @seconds.before(time)
+  end
+
+  #
+  def after(time)
+    @seconds.after(time)
+  end
+
+
+  # = Numeric Extensions for Durations
+  #
+  module Numeric
+
+    # Enables the use of time calculations and declarations,
+    # like 45.minutes + 2.hours + 4.years. The base unit for
+    # all of these Numeric time methods is seconds.
+    def seconds ; Duration[self] ; end
+    alias_method :second, :seconds
+
+    # Converts minutes into seconds.
+    def minutes ; Duration[self * 60] ; end
+    alias_method :minute, :minutes
+
+    # Converts hours into seconds.
+    def hours ; Duration[self * 3600] ; end
+    alias_method :hour, :hours
+    #def as_hours ; self / 60.minutes ; end
+
+    # Converts days into seconds.
+    def days ; Duration[self * 86400] ; end
+    alias_method :day, :days
+
+    # Converts weeks into seconds.
+    def weeks ; Duration[self * 604800] ; end
+    alias_method :week, :weeks
+
+    # Converts fortnights into seconds.
+    # (A fortnight is 2 weeks)
+    def fortnights ; Duration[self * 1209600] ; end
+    alias_method :fortnight, :fortnights
+
+    # Converts months into seconds.
+    # WARNING: This is not exact as it assumes 30 days to a month.
+    def months ; Duration[self * 30 * 86400] ; end
+    alias_method :month, :months
+
+    # Converts years into seconds.
+    # WARNING: This is not exact as it assumes 365 days to a year.
+    #          ie. It doesn not account for leap years.
+    def years ; Duration[self * 365 * 86400, :years] ; end
+    alias_method :year, :years
+
+  end
+
+  # Time#duration has been added to convert the UNIX timestamp into a Duration.
+  # See Time#duration for an example.
+  #
+  module Time
+    # Create a Duration object from the UNIX timestamp.
     #
     # *Example*
     #
-    #     d = Duration.new(30)
-    #     => #<Duration: 30 seconds>
-    #     d / 2
-    #     => #<Duration: 15 seconds>
+    #   Time.now.duration
+    #   => #<Duration: 1898 weeks, 6 days, 1 hour, 12 minutes and 1 second>
     #
-    def /(other)
-        self.class.new(@total / other.to_i)
+    def duration
+      Duration[to_i]
     end
+  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
+class Numeric #:nodoc:
+  include Duration::Numeric
 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
-    # 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
-
-    # TODO: IF WE WANT TO DO THIS IT NEEDS TO BE ADDED TO times.rb ???
-    #
-    #     alias __numeric_old_method_missing method_missing
-    #
-    #     # 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
-
+class Time #:nodoc:
+  include Duration::Time
 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
-end