kelredd-useful 0.1.25 → 0.2.0

data/lib/useful/ruby_extensions_from_rails/date.rb

@@ -1,244 +0,0 @@
-require File.join(File.dirname(__FILE__), 'object') unless Object.new.respond_to?(:acts_like?)
-require File.join(File.dirname(__FILE__), 'duration')
-
-module Useful
-  module RubyExtensionsFromRails
-    module Date
-      
-      DATE_FORMATS = {
-        :short        => "%e %b",
-        :long         => "%B %e, %Y",
-        :db           => "%Y-%m-%d",
-        :number       => "%Y%m%d",
-        :long_ordinal => lambda { |date| date.strftime("%B #{date.day.ordinalize}, %Y") }, # => "April 25th, 2007"
-        :rfc822       => "%e %b %Y"
-      }
-
-      module ClassMethods; end
-      def self.included(klass)
-        klass.extend(ClassMethods) if klass.kind_of?(Class)
-        
-        klass.instance_eval do
-          alias_method :to_default_s, :to_s
-          alias_method :to_s, :to_formatted_s
-          alias_method :default_inspect, :inspect
-          alias_method :inspect, :readable_inspect
-
-          # Ruby 1.9 has Date#to_time which converts to localtime only.
-          remove_method :to_time if klass.instance_methods.include?(:to_time)
-
-          # Ruby 1.9 has Date#xmlschema which converts to a string without the time component.
-          remove_method :xmlschema if klass.instance_methods.include?(:xmlschema)
-        end
-      end
-
-      module ClassMethods
-        
-        # Returns a new Date representing the date 1 day ago (i.e. yesterday's date).
-        def yesterday
-          ::Date.today.yesterday
-        end
-
-        # Returns a new Date representing the date 1 day after today (i.e. tomorrow's date).
-        def tomorrow
-          ::Date.today.tomorrow
-        end
-
-        # Returns Date.today.
-        def current
-          ::Date.today
-        end
-        
-      end
-
-      # Enable more predictable duck-typing on Date-like classes. See
-      # Object#acts_like?.
-      def acts_like_date?
-        true
-      end
-
-      # Tells whether the Date object's date lies in the past
-      def past?
-        self < ::Date.current
-      end
-
-      # Tells whether the Date object's date is today
-      def today?
-        self.to_date == ::Date.current # we need the to_date because of DateTime
-      end
-
-      # Tells whether the Date object's date lies in the future
-      def future?
-        self > ::Date.current
-      end
-
-      # Provides precise Date calculations for years, months, and days.  The +options+ parameter takes a hash with
-      # any of these keys: <tt>:years</tt>, <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>.
-      def advance(options)
-        d = self
-        d = d >> options.delete(:years) * 12 if options[:years]
-        d = d >> options.delete(:months)     if options[:months]
-        d = d +  options.delete(:weeks) * 7  if options[:weeks]
-        d = d +  options.delete(:days)       if options[:days]
-        d
-      end
-
-      # Returns a new Date where one or more of the elements have been changed according to the +options+ parameter.
-      #
-      # Examples:
-      #
-      #   Date.new(2007, 5, 12).change(:day => 1)                  # => Date.new(2007, 5, 1)
-      #   Date.new(2007, 5, 12).change(:year => 2005, :month => 1) # => Date.new(2005, 1, 12)
-      def change(options)
-        ::Date.new(
-          options[:year]  || self.year,
-          options[:month] || self.month,
-          options[:day]   || self.day
-        )
-      end
-
-      # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
-      def beginning_of_day
-        to_time
-      end
-      alias :midnight :beginning_of_day
-      alias :at_midnight :beginning_of_day
-      alias :at_beginning_of_day :beginning_of_day
-
-      # Converts Date to a Time (or DateTime if necessary) with the time portion set to the end of the day (23:59:59)
-      def end_of_day
-        to_time.end_of_day
-      end
-      alias :at_end_of_day :end_of_day
-
-      # Returns a new Date representing the "start" of this week (i.e, Monday; DateTime objects will have time set to 0:00)
-      def beginning_of_week
-        days_to_monday = self.wday!=0 ? self.wday-1 : 6
-        self - days_to_monday
-      end
-      alias :monday :beginning_of_week
-      alias :at_beginning_of_week :beginning_of_week
-
-      # Returns a new Date representing the end of this week (Sunday, DateTime objects will have time set to 23:59:59)
-      def end_of_week
-        days_to_sunday = self.wday!=0 ? 7-self.wday : 0
-        self + days_to_sunday.days
-      end
-      alias :at_end_of_week :end_of_week
-
-      # Returns a new Date representing the start of the given day in next week (default is Monday).
-      def next_week(day = :monday)
-        days_into_week = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6}
-        (self + 7).beginning_of_week + days_into_week[day]
-      end
-
-      # Returns a new Date representing the start of the month (1st of the month)
-      def beginning_of_month
-        change(:day => 1)
-      end
-      alias :at_beginning_of_month :beginning_of_month
-
-      # Returns a new Date representing the end of the month (last day of the month)
-      def end_of_month
-        change(:day => ::Time.days_in_month( self.month, self.year ))
-      end
-      alias :at_end_of_month :end_of_month
-
-      # Returns a new Date/DateTime representing the start of the quarter (1st of january, april, july, october; DateTime objects will have time set to 0:00)
-      def beginning_of_quarter
-        beginning_of_month.change(:month => [10, 7, 4, 1].detect { |m| m <= self.month })
-      end
-      alias :at_beginning_of_quarter :beginning_of_quarter
-
-      # Returns a new Date/DateTime representing the end of the quarter (last day of march, june, september, december; DateTime objects will have time set to 23:59:59)
-      def end_of_quarter
-        beginning_of_month.change(:month => [3, 6, 9, 12].detect { |m| m >= self.month }).end_of_month
-      end
-      alias :at_end_of_quarter :end_of_quarter
-
-      # Returns a new Date/DateTime representing the start of the year (1st of january; DateTime objects will have time set to 0:00)
-      def beginning_of_year
-        change(:month => 1, :day => 1)
-      end
-      alias :at_beginning_of_year :beginning_of_year
-
-      # Returns a new Time representing the end of the year (31st of december; DateTime objects will have time set to 23:59:59)
-      def end_of_year
-        change(:month => 12, :day => 31)
-      end
-      alias :at_end_of_year :end_of_year
-
-      # Convenience method which returns a new Date/DateTime representing the time 1 day ago
-      def yesterday
-        self - 1
-      end
-
-      # Convenience method which returns a new Date/DateTime representing the time 1 day since the instance time
-      def tomorrow
-        self + 1
-      end
-
-      # Convert to a formatted string. See DATE_FORMATS for predefined formats.
-      #
-      # This method is aliased to <tt>to_s</tt>.
-      #
-      # ==== Examples
-      #   date = Date.new(2007, 11, 10)       # => Sat, 10 Nov 2007
-      #
-      #   date.to_formatted_s(:db)            # => "2007-11-10"
-      #   date.to_s(:db)                      # => "2007-11-10"
-      #
-      #   date.to_formatted_s(:short)         # => "10 Nov"
-      #   date.to_formatted_s(:long)          # => "November 10, 2007"
-      #   date.to_formatted_s(:long_ordinal)  # => "November 10th, 2007"
-      #   date.to_formatted_s(:rfc822)        # => "10 Nov 2007"
-      #
-      # == Adding your own time formats to to_formatted_s
-      # You can add your own formats to the Date::DATE_FORMATS hash.
-      # Use the format name as the hash key and either a strftime string
-      # or Proc instance that takes a date argument as the value.
-      #
-      #   # config/initializers/time_formats.rb
-      #   Date::DATE_FORMATS[:month_and_year] = "%B %Y"
-      #   Date::DATE_FORMATS[:short_ordinal] = lambda { |date| date.strftime("%B #{date.day.ordinalize}") }
-      def to_formatted_s(format = :default)
-        if formatter = DATE_FORMATS[format]
-          if formatter.respond_to?(:call)
-            formatter.call(self).to_s
-          else
-            strftime(formatter)
-          end
-        else
-          to_default_s
-        end
-      end
-
-      # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005"
-      def readable_inspect
-        strftime("%a, %d %b %Y")
-      end
-
-      # Converts a Date instance to a Time, where the time is set to the beginning of the day.
-      # The timezone can be either :local or :utc (default :local).
-      #
-      # ==== Examples
-      #   date = Date.new(2007, 11, 10)  # => Sat, 10 Nov 2007
-      #
-      #   date.to_time                   # => Sat Nov 10 00:00:00 0800 2007
-      #   date.to_time(:local)           # => Sat Nov 10 00:00:00 0800 2007
-      #
-      #   date.to_time(:utc)             # => Sat Nov 10 00:00:00 UTC 2007
-      def to_time(form = :local)
-        ::Time.send("#{form}_time", year, month, day)
-      end
-
-      def xmlschema
-        to_time.xmlschema
-      end
-    end
-  end
-end
-
-class Date
-  include Useful::RubyExtensionsFromRails::Date
-end

data/lib/useful/ruby_extensions_from_rails/duration.rb

@@ -1,99 +0,0 @@
-module Useful
-  module RubyExtensionsFromRails
-    # Provides accurate date and time measurements using Date#advance and 
-    # Time#advance, respectively. It mainly supports the methods on Numeric,
-    # such as in this example:
-    #
-    #   1.month.ago       # equivalent to Time.now.advance(:months => -1)
-    class Duration
-      attr_accessor :value, :parts
-
-      def initialize(value, parts) #:nodoc:
-        @value, @parts = value, parts
-      end
-
-      # Adds another Duration or a Numeric to this Duration. Numeric values
-      # are treated as seconds.
-      def +(other)
-        if Duration === other
-          Duration.new(value + other.value, @parts + other.parts)
-        else
-          Duration.new(value + other, @parts + [[:seconds, other]])
-        end
-      end
-
-      # Subtracts another Duration or a Numeric from this Duration. Numeric
-      # values are treated as seconds.
-      def -(other)
-        self + (-other)
-      end
-
-      def -@ #:nodoc:
-        Duration.new(-value, parts.map { |type,number| [type, -number] })
-      end
-
-      def is_a?(klass) #:nodoc:
-        klass == Duration || super
-      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.value == value
-        else
-          other == value
-        end
-      end
-
-      def self.===(other) #:nodoc:
-        other.is_a?(Duration) rescue super
-      end
-
-      # Calculates a new Time or Date that is as far in the future
-      # as this Duration represents.
-      def since(time = ::Time.current)
-        sum(1, time)
-      end
-      alias :from_now :since
-
-      # Calculates a new Time or Date that is as far in the past
-      # as this Duration represents.
-      def ago(time = ::Time.current)
-        sum(-1, time)
-      end
-      alias :until :ago
-
-      def inspect #:nodoc:
-        consolidated = parts.inject(::Hash.new(0)) { |h,part| h[part.first] += part.last; h }
-        [:years, :months, :days, :minutes, :seconds].map do |length|
-          n = consolidated[length]
-          "#{n} #{n == 1 ? length.to_s.singularize : length.to_s}" if n.nonzero?
-        end.compact.join(',')
-      end
-
-      protected
-
-      def sum(sign, time = ::Time.current) #:nodoc:
-        parts.inject(time) do |t,(type,number)|
-          if t.acts_like?(:time) || t.acts_like?(:date)
-            if type == :seconds
-              t.since(sign * number)
-            else
-              t.advance(type => sign * number)
-            end
-          else
-            raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
-          end
-        end
-      end
-
-      private
-
-      def method_missing(method, *args, &block) #:nodoc:
-        value.send(method, *args)
-      end
-      
-    end
-  end
-end

data/lib/useful/ruby_extensions_from_rails/fixnum.rb

@@ -1,32 +0,0 @@
-module Useful
-  module RubyExtensionsFromRails
-    module Fixnum
-      
-      # Turns a number into an ordinal string used to denote the position in an
-      # ordered sequence such as 1st, 2nd, 3rd, 4th.
-      #
-      # Examples:
-      #   1.ordinalize     # => "1st"
-      #   2.ordinalize     # => "2nd"
-      #   1003.ordinalize  # => "1003rd"
-      #   1004.ordinalize  # => "1004th"
-      def ordinalize
-        if (11..13).include?(self.to_i % 100)
-          "#{number}th"
-        else
-          case self.to_i % 10
-            when 1; "#{number}st"
-            when 2; "#{number}nd"
-            when 3; "#{number}rd"
-            else    "#{number}th"
-          end
-        end
-      end
-
-    end
-  end
-end
-
-class Fixnum
-  include Useful::RubyExtensionsFromRails::Fixnum
-end

data/lib/useful/ruby_extensions_from_rails/hash.rb

@@ -1,50 +0,0 @@
-module Useful
-  module RubyExtensionsFromRails
-    module Hash
-
-      module ClassMethods; end
-      def self.included(klass)
-        klass.extend(ClassMethods) if klass.kind_of?(Class)
-      end
-
-      module ClassMethods
-
-        # inspired by ActiveSupport::CoreExtensions::Hash::Keys (http://api.rubyonrails.org/)
-        def stringify_keys(hash)
-          hash.keys.each{ |key| hash[(key.to_s rescue key)] ||= hash.delete(key) }
-          hash
-        end
-        
-        # inspired by from ActiveSupport::CoreExtensions::Hash::Keys (http://api.rubyonrails.org/)
-        def symbolize_keys(hash)
-          hash.keys.each{ |key| hash[(key.to_sym rescue key)] ||= hash.delete(key) }
-          hash
-        end
-        
-      end
-
-      # Return a new hash with all keys converted to strings.
-      def stringify_keys
-        self.class.stringify_keys(self.clone)
-      end
-      # Destructively convert all keys to strings. 
-      def stringify_keys!
-        self.class.stringify_keys(self)
-      end
-
-      # Return a new hash with all keys converted to strings.
-      def symbolize_keys
-        self.class.symbolize_keys(self.clone)
-      end
-      # Destructively convert all keys to strings. 
-      def symbolize_keys!
-        self.class.symbolize_keys(self)
-      end
-
-    end
-  end
-end
-
-class Hash
-  include Useful::RubyExtensionsFromRails::Hash
-end

data/lib/useful/ruby_extensions_from_rails/numeric.rb

@@ -1,60 +0,0 @@
-require File.join(File.dirname(__FILE__), 'duration')
-
-module Useful
-  module RubyExtensionsFromRails
-    module Numeric
-
-      def seconds
-        Useful::RubyExtensionsFromRails::Duration.new(self, [[:seconds, self]])
-      end
-      alias :second :seconds
-
-      def minutes
-        Useful::RubyExtensionsFromRails::Duration.new(self * 60, [[:seconds, self * 60]])
-      end
-      alias :minute :minutes  
-
-      def hours
-        Useful::RubyExtensionsFromRails::Duration.new(self * 3600, [[:seconds, self * 3600]])
-      end
-      alias :hour :hours
-
-      def days
-        Useful::RubyExtensionsFromRails::Duration.new(self * 24.hours, [[:days, self]])
-      end
-      alias :day :days
-
-      def weeks
-        Useful::RubyExtensionsFromRails::Duration.new(self * 7.days, [[:days, self * 7]])
-      end
-      alias :week :weeks
-
-      def fortnights
-        Useful::RubyExtensionsFromRails::Duration.new(self * 2.weeks, [[:days, self * 14]])
-      end
-      alias :fortnight :fortnights
-
-      # Reads best without arguments:  10.minutes.ago
-      def ago(time = ::Time.now)
-        time - self
-      end
-
-      # Reads best with argument:  10.minutes.until(time)
-      alias :until :ago
-
-      # Reads best with argument:  10.minutes.since(time)
-      def since(time = ::Time.now)
-        time + self
-      end
-
-      # Reads best without arguments:  10.minutes.from_now
-      alias :from_now :since
-
-    end
-  end
-end
-
-
-class Numeric
-  include Useful::RubyExtensionsFromRails::Numeric
-end

data/lib/useful/ruby_extensions_from_rails/object.rb

@@ -1,79 +0,0 @@
-module Useful
-  module RubyExtensionsFromRails
-    module Object
-      
-      def blank?
-        self.nil? || (self.respond_to?(:empty?) ? self.empty? : false)
-      end
-
-      # Returns +value+ after yielding +value+ to the block. This simplifies the
-      # process of constructing an object, performing work on the object, and then
-      # returning the object from a method. It is a Ruby-ized realization of the K
-      # combinator, courtesy of Mikael Brockman.
-      #
-      # ==== Examples
-      #
-      #  # Without returning
-      #  def foo
-      #    values = []
-      #    values << "bar"
-      #    values << "baz"
-      #    return values
-      #  end
-      #
-      #  foo # => ['bar', 'baz']
-      #
-      #  # returning with a local variable
-      #  def foo
-      #    returning values = [] do
-      #      values << 'bar'
-      #      values << 'baz'
-      #    end
-      #  end
-      #
-      #  foo # => ['bar', 'baz']
-      #  
-      #  # returning with a block argument
-      #  def foo
-      #    returning [] do |values|
-      #      values << 'bar'
-      #      values << 'baz'
-      #    end
-      #  end
-      #  
-      #  foo # => ['bar', 'baz']
-      def returning(value)
-        yield(value)
-        value
-      end
-
-      # Yields <code>x</code> to the block, and then returns <code>x</code>.
-      # The primary purpose of this method is to "tap into" a method chain,
-      # in order to perform operations on intermediate results within the chain.
-      #
-      #   (1..10).tap { |x| puts "original: #{x.inspect}" }.to_a.
-      #     tap    { |x| puts "array: #{x.inspect}" }.
-      #     select { |x| x%2 == 0 }.
-      #     tap    { |x| puts "evens: #{x.inspect}" }.
-      #     map    { |x| x*x }.
-      #     tap    { |x| puts "squares: #{x.inspect}" }
-      def tap
-        yield self
-        self
-      end unless ::Object.respond_to?(:tap)
-
-      # A duck-type assistant method. For example, Active Support extends Date
-      # to define an acts_like_date? method, and extends Time to define
-      # acts_like_time?. As a result, we can do "x.acts_like?(:time)" and
-      # "x.acts_like?(:date)" to do duck-type-safe comparisons, since classes that
-      # we want to act like Time simply need to define an acts_like_time? method.
-      def acts_like?(duck)
-        respond_to? "acts_like_#{duck}?"
-      end
-    end
-  end
-end
-
-class Object
-  include Useful::RubyExtensionsFromRails::Object
-end