facets 2.8.4 → 2.9.0.pre.1

data/lib/more/facets/duration.rb

@@ -1,286 +0,0 @@
-class Duration
-  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
-  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
-  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*
-    #
-    #   Time.now.duration
-    #   => #<Duration: 1898 weeks, 6 days, 1 hour, 12 minutes and 1 second>
-    #
-    def duration
-      Duration[to_i]
-    end
-  end
-
-end
-
-class Numeric #:nodoc:
-  include Duration::Numeric
-end
-
-class Time #:nodoc:
-  include Duration::Time
-end
-

data/lib/more/facets/enumargs.rb

@@ -1,192 +0,0 @@
-# Enumerable::Arguments
-#
-# Copyright (c) 2004 Thomas Sawyer
-#
-# LGPL(3) License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-
-require 'facets/enumerator'
-
-# This is a simple reimplementation of the core Enumerable module
-# to allow the methods to take and pass-on arbitrary arguments to the
-# underlying #each call. This library uses Enumerator and scans
-# Enumerable so it can alwasy stay in sync.
-#
-# NOTE Any Enumerable method with a negative arity cannot do pass arguments
-# due to ambiguity in the argument count. So the methods #inject and #zip
-# do NOT work this way, but simply work as they do in Enumerable.
-# The method #find (and #detect) though has been made to work by removing
-# its rarely used optional parameter and providing instead an optional
-# keyword parameter (:ifnone => ...). Please keep these difference in mind.
-#
-#   require 'enumargs'
-#
-#   class T
-#     include Enumerable::Arguments
-#     def initialize(arr)
-#       @arr = arr
-#     end
-#     def each(n)
-#       arr.each{ |e| yield(e+n) }
-#     end
-#   end
-#
-#   t = T.new([1,2,3])
-#   t.collect(4)
-#   #=> [5,6,7]
-#
-module Enumerable
-module Arguments
-
-  def self.wrap_enumerable_method( methodname )
-
-    m = methodname
-    meth = Enumerable.instance_method(m)
-    arity = meth.arity
-
-    case arity <=> 0
-    when 0
-      class_eval %{
-        def #{m}( *args, &yld )
-          enum_for(:each, *args).#{m}( &yld )
-        end
-      }
-    when 1
-      class_eval %{
-        def #{m}( *args, &yld )
-          args, each_args = args[0...#{arity}], args[#{arity}..-1]
-          enum_for(:each, *each_args).#{m}( *args, &yld )
-        end
-      }
-    else
-      class_eval %{
-        def #{m}( *args, &yld )
-          enum_for(:each).#{m}( *args, &yld )
-        end
-      }
-    end
-  end
-
-  Enumerable.instance_methods(false).each do |m|
-    wrap_enumerable_method( m )
-  end
-
-  #
-  def to_a(*args)
-    map(*args){ |x| x }
-  end
-
-  # Make exception for #find (a negative arity method) to accept
-  # keyword argument.
-  #
-  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
-  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
-  #
-  def find(*args, &yld)  # future use **keys ?
-    if Hash === args.last and args.last.key?(:ifnone)
-      ifnone = args.last.delete(:ifnone)
-      args.pop if args.last.empty?
-      enum_for(:each, *args).find( ifnone, &yld )
-    else
-      enum_for(:each, *args).find( &yld )
-    end
-  end
-  alias_method :detect, :find
-
-end
-end
-
-
-=begin  OLD CODE
-module EnumerableArgs
-
-  def collect(*args)  # :yield:
-    a = []
-    each(*args){ |n| a << yield(n) }
-    a
-  end
-  alias_method( :map, :collect )
-
-  def detect(*args)  # :yield:
-    each(*args){ |n| return n if yield(n) }
-    nil
-  end
-  alias_method( :find, :detect )
-
-  def each_with_index(*args)
-    i=0
-    each(*args){ |*n| n << i; yield(*n); i+=1 }
-    self
-  end
-
-  def to_a(*args)
-    a = []
-    each(*args){ |n| a << n }
-    a
-  end
-  alias_method( :entries, :to_a )
-
-  # An additional method not part of standard Enumerable.
-  # The regular version of this method can be found in Facets,
-  # but it is a bit more advanced then this one.
-  # At some point they need to be put into sync.
-  def each_slice(*args, &yld)
-    a = []; s = []
-    ar = yld.arity.abs
-    each(*args){ |n|
-      s << n
-      if s.length >= ar
-        yld.call(*s)
-        s = []
-      end
-    }
-    a
-  end
-  alias_method( :each_by, :each_slice )
-
-  def select(*args)  # :yield:
-    a = []
-    each(*args){ |n| a << n if yield(n) }
-    a
-  end
-  alias_method( :find_all, :select )
-
-  def grep(pattern, *args)
-    a = []
-    each(*args){ |n| a << (block_given? ? yield(n) : n) if pattern === n }
-    a
-  end
-
-  def include?(anObj, *args)
-    each(*args){ |n| return true if anObj == n }
-    false
-  end
-  alias_method( :member?, :include? )
-
-  def max(*args)
-    to_a(*args).max
-  end
-
-  def min(*args)
-    to_a(*args).min
-  end
-
-  def reject(*args)
-    a = []
-    each(*args){ |n| a << n if ! yield(n) }
-    a
-  end
-
-  def sort(*args)
-    # TODO
-  end
-
-end
-=end
-