kelredd-useful 0.1.1 → 0.1.2

data/lib/useful/ruby_extensions/date.rb

@@ -0,0 +1,18 @@
+module Useful
+  module RubyExtensions
+    module Date
+      
+      def week_days_until(end_date)
+        week_days = (1..5)
+        raise ::ArgumentError, "End date cannot be nil." if end_date.nil?
+        raise ::ArgumentError, "End date cannot come before questioned date." if end_date < self
+        (self..end_date).to_a.select{|date| week_days.include?(date.wday)}.length
+      end
+
+    end
+  end
+end
+
+class Date
+  include Useful::RubyExtensions::Date
+end

data/lib/useful/ruby_extensions/false_class.rb

@@ -0,0 +1,19 @@
+module Useful
+  module RubyExtensions
+    module FalseClass
+      
+      def to_affirmative
+        "No"
+      end
+
+      def to_i
+        0
+      end
+    
+    end
+  end
+end
+
+class FalseClass
+  include Useful::RubyExtensions::FalseClass
+end

data/lib/useful/ruby_extensions/fixnum.rb

@@ -20,7 +20,7 @@ module Useful
         end
         value
       end
-
+      
     end
   end
 end

data/lib/useful/ruby_extensions/hash.rb

@@ -1,5 +1,3 @@
-require 'cgi'
-
 module Useful
   module RubyExtensions
     module Hash
@@ -11,18 +9,6 @@ module Useful
 
       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
-        
         def only(hash, *keys)
           hash.delete_if{ |k,v| !keys.flatten.include?(k) }
           hash
@@ -35,24 +21,6 @@ module Useful
         
       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
-
       # Return a new hash with only keys in *keys
       def only(*keys)
         self.class.only(self.clone, keys)
@@ -87,11 +55,12 @@ module Useful
 
       # Returns string formatted for HTTP URL encoded name-value pairs.
       # For example,
-      #  {:id => 'thomas_hardy'}.to_http_str 
-      #  # => "id=thomas_hardy"
-      #  {:id => 23423, :since => Time.now}.to_http_str
-      #  # => "since=Thu,%2021%20Jun%202007%2012:10:05%20-0500&id=23423"
+      #  {:id => 'thomas_hardy'}.to_http_query_str 
+      #  # => "?id=thomas_hardy"
+      #  {:id => 23423, :since => Time.now}.to_http_query_str
+      #  # => "?since=Thu,%2021%20Jun%202007%2012:10:05%20-0500&id=23423"
       def to_http_query_str(opts = {})
+        require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
         opts[:prepend] ||= '?'
         opts[:append] ||= ''
         self.empty? ? '' : "#{opts[:prepend]}#{self.collect{|key, val| "#{key.to_s}=#{CGI.escape(val.to_s)}"}.join('&')}#{opts[:append]}"

data/lib/useful/ruby_extensions/numeric.rb

@@ -1,10 +1,10 @@
-require File.join(File.dirname(__FILE__), 'object')
-require File.join(File.dirname(__FILE__), 'string')
-require File.join(File.dirname(__FILE__), 'hash')
+require File.join(File.dirname(__FILE__), '..', 'ruby_extensions_from_rails', 'object') unless Object.new.respond_to?(:blank?)
+require File.join(File.dirname(__FILE__), '..', 'ruby_extensions_from_rails', 'hash') unless Hash.new.respond_to?(:symbolize_keys!)
+require File.join(File.dirname(__FILE__), '..', 'ruby_extensions_from_rails', 'string') unless String.new.respond_to?(:starts_with?)
 
 module Useful
   module RubyExtensions
-    module Numeric #:nodoc:
+    module Numeric
 
       LOCALES = {
         :en => {
@@ -144,6 +144,7 @@ module Useful
       #  1234567890.50.to_currency(:unit => "£", :separator => ",", :delimiter => "", :format => "%n %u")
       #  # => 1234567890,50 £
       def to_currency(opts = {})
+        return opts[:zero_display] if opts[:zero_display] && self == 0
         opts.symbolize_keys!
         opts[:locale] ||= :en
         locale = LOCALES[opts.delete(:locale)]

data/lib/useful/ruby_extensions/object.rb

@@ -10,10 +10,6 @@ module Useful
         self == true
       end
       
-      def blank?
-        self.nil? || self.empty? rescue false
-      end
-
     end
   end
 end

data/lib/useful/ruby_extensions/string.rb

@@ -30,10 +30,6 @@ module Useful
         !self.match(pattern).nil?
       end
       
-      def starts_with?(string)
-        self.match?(Regexp.new("\\A#{string}"))
-      end
-
       def show_regexp(re)
         if self =~ re
           "#{$`}<<#{$&}>>#{$'}"

data/lib/useful/ruby_extensions/true_class.rb

@@ -0,0 +1,19 @@
+module Useful
+  module RubyExtensions
+    module TrueClass
+      
+      def to_affirmative
+        "Yes"
+      end
+
+      def to_i
+        1
+      end
+    
+    end
+  end
+end
+
+class TrueClass
+  include Useful::RubyExtensions::TrueClass
+end

data/lib/useful/ruby_extensions.rb

@@ -1,7 +1,3 @@
-$:.unshift File.dirname(__FILE__)
-require 'ruby_extensions/array'
-require 'ruby_extensions/hash'
-require 'ruby_extensions/string'
-require 'ruby_extensions/fixnum'
-require 'ruby_extensions/numeric'
-require 'ruby_extensions/object'
+Dir[File.join(File.dirname(__FILE__), "ruby_extensions" ,"*.rb")].each do |file|
+  require file
+end

data/lib/useful/ruby_extensions_from_rails/date.rb

@@ -0,0 +1,244 @@
+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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,79 @@
+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

data/lib/useful/ruby_extensions_from_rails/string.rb

@@ -0,0 +1,166 @@
+module Useful
+  module RubyExtensionsFromRails
+    module String
+      
+      module ClassMethods; end
+      def self.included(klass)
+        klass.extend(ClassMethods) if klass.kind_of?(Class)
+      end
+
+      module ClassMethods
+        
+        # By default, +camelize+ converts strings to UpperCamelCase. If the argument to +camelize+
+        # is set to <tt>:lower</tt> then +camelize+ produces lowerCamelCase.
+        #
+        # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+        #
+        # Examples:
+        #   "active_record".camelize                # => "ActiveRecord"
+        #   "active_record".camelize(:lower)        # => "activeRecord"
+        #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+        #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+        def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+          if first_letter_in_uppercase
+            lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+          else
+            lower_case_and_underscored_word.first.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+          end
+        end
+
+        # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
+        #
+        # Changes '::' to '/' to convert namespaces to paths.
+        #
+        # Examples:
+        #   "ActiveRecord".underscore         # => "active_record"
+        #   "ActiveRecord::Errors".underscore # => active_record/errors
+        def underscore(camel_cased_word)
+          camel_cased_word.to_s.gsub(/::/, '/').
+            gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+            gsub(/([a-z\d])([A-Z])/,'\1_\2').
+            tr("-", "_").
+            downcase
+        end
+
+        # Replaces underscores with dashes in the string.
+        #
+        # Example:
+        #   "puni_puni" # => "puni-puni"
+        def dasherize(underscored_word)
+          underscored_word.gsub(/_/, '-')
+        end
+
+        # Removes the module part from the expression in the string.
+        #
+        # Examples:
+        #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+        #   "Inflections".demodulize                                       # => "Inflections"
+        def demodulize(class_name_in_module)
+          class_name_in_module.to_s.gsub(/^.*::/, '')
+        end
+
+        # Create a class name from a string like Rails does for table names to models.
+        # Note that this returns a string and not a Class. (To convert to an actual class
+        # follow +classify+ with +constantize+.)
+        #
+        # Examples:
+        #   "egg_and_hams".classify # => "EggAndHam"
+        #   "posts".classify        # => "Post"
+        #
+        # Singular names are not handled correctly:
+        #   "business".classify     # => "Busines"
+        def classify(class_str)
+          # strip out any leading schema name
+          camelize(class_str.to_s.sub(/.*\./, ''))
+        end
+
+        # Ruby 1.9 introduces an inherit argument for Module#const_get and
+        # #const_defined? and changes their default behavior.
+        if Module.method(:const_get).arity == 1
+          # Tries to find a constant with the name specified in the argument string:
+          #
+          #   "Module".constantize     # => Module
+          #   "Test::Unit".constantize # => Test::Unit
+          #
+          # The name is assumed to be the one of a top-level constant, no matter whether
+          # it starts with "::" or not. No lexical context is taken into account:
+          #
+          #   C = 'outside'
+          #   module M
+          #     C = 'inside'
+          #     C               # => 'inside'
+          #     "C".constantize # => 'outside', same as ::C
+          #   end
+          #
+          # NameError is raised when the name is not in CamelCase or the constant is
+          # unknown.
+          def constantize(camel_cased_word)
+            names = camel_cased_word.split('::')
+            names.shift if names.empty? || names.first.empty?
+
+            constant = ::Object
+            names.each do |name|
+              constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+            end
+            constant
+          end
+        else
+          def constantize(camel_cased_word) #:nodoc:
+            names = camel_cased_word.split('::')
+            names.shift if names.empty? || names.first.empty?
+
+            constant = ::Object
+            names.each do |name|
+              constant = constant.const_get(name, false) || constant.const_missing(name)
+            end
+            constant
+          end
+        end
+
+      end #ClassMethods
+
+      def camelize(first_letter = :upper)
+        case first_letter
+          when :upper then String.camelize(self, true)
+          when :lower then String.camelize(self, false)
+        end
+      end
+      alias_method :camelcase, :camelize
+
+      def underscore
+        self.class.underscore(self)
+      end
+
+      def dasherize
+        self.class.dasherize(self)
+      end
+
+      def demodulize
+        self.class.demodulize(self)
+      end
+
+      def classify
+        self.class.classify(self)
+      end
+      
+      def constantize
+        self.class.constantize(self)
+      end
+      
+      def ends_with?(suffix)
+        suffix = suffix.to_s
+        self[-suffix.length, suffix.length] == suffix      
+      end
+      
+      def starts_with?(prefix)
+        prefix = prefix.to_s
+        self[0, prefix.length] == prefix
+      end
+
+    end
+  end
+end
+
+class String
+  include Useful::RubyExtensionsFromRails::String
+end

data/lib/useful/ruby_extensions_from_rails/time.rb

@@ -0,0 +1,320 @@
+require File.join(File.dirname(__FILE__), 'object') unless Object.new.respond_to?(:acts_like?)
+require File.join(File.dirname(__FILE__), 'duration')
+require File.join(File.dirname(__FILE__), 'numeric')
+
+module Useful
+  module RubyExtensionsFromRails
+    module Time
+
+      def self.included(base) #:nodoc:
+        base.extend ClassMethods
+        base.class_eval do
+          alias_method :to_default_s, :to_s
+          alias_method :to_s, :to_formatted_s
+        end
+      end
+
+      COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+      DATE_FORMATS = {
+        :db           => "%Y-%m-%d %H:%M:%S",
+        :number       => "%Y%m%d%H%M%S",
+        :time         => "%H:%M",
+        :short        => "%d %b %H:%M",
+        :long         => "%B %d, %Y %H:%M",
+        :long_ordinal => lambda { |time| time.strftime("%B #{time.day.ordinalize}, %Y %H:%M") },
+        :rfc822       => lambda { |time| time.strftime("%a, %d %b %Y %H:%M:%S #{time.formatted_offset(false)}") }
+      }
+
+      module ClassMethods
+        # Return the number of days in the given month.
+        # If no year is specified, it will use the current year.
+        def days_in_month(month, year = now.year)
+          return 29 if month == 2 && ::Date.gregorian_leap?(year)
+          COMMON_YEAR_DAYS_IN_MONTH[month]
+        end
+
+        # Returns a new Time if requested year can be accommodated by Ruby's Time class
+        # (i.e., if year is within either 1970..2038 or 1902..2038, depending on system architecture);
+        # otherwise returns a DateTime
+        def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
+          ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
+        end
+
+        # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:utc</tt>.
+        def utc_time(*args)
+          time_with_datetime_fallback(:utc, *args)
+        end
+
+        # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:local</tt>.
+        def local_time(*args)
+          time_with_datetime_fallback(:local, *args)
+        end
+
+        # Returns Time.now
+        def current
+          ::Time.now
+        end
+        
+      end
+
+      # Enable more predictable duck-typing on Time-like classes. See
+      # Object#acts_like?.
+      def acts_like_time?
+        true
+      end
+
+      # Tells whether the Time object's time lies in the past
+      def past?
+        self < ::Time.current
+      end
+
+      # Tells whether the Time object's time is today
+      def today?
+        self.to_date == ::Date.current
+      end
+
+      # Tells whether the Time object's time lies in the future
+      def future?
+        self > ::Time.current
+      end
+
+      # Seconds since midnight: Time.now.seconds_since_midnight
+      def seconds_since_midnight
+        self.to_i - self.change(:hour => 0).to_i + (self.usec/1.0e+6)
+      end
+
+      # Returns a new Time where one or more of the elements have been changed according to the +options+ parameter. The time options
+      # (hour, minute, sec, usec) reset cascadingly, so if only the hour is passed, then minute, sec, and usec is set to 0. If the hour and
+      # minute is passed, then sec and usec is set to 0.
+      def change(options)
+        ::Time.send(
+          self.utc? ? :utc_time : :local_time,
+          options[:year]  || self.year,
+          options[:month] || self.month,
+          options[:day]   || self.day,
+          options[:hour]  || self.hour,
+          options[:min]   || (options[:hour] ? 0 : self.min),
+          options[:sec]   || ((options[:hour] || options[:min]) ? 0 : self.sec),
+          options[:usec]  || ((options[:hour] || options[:min] || options[:sec]) ? 0 : self.usec)
+        )
+      end
+
+      # Uses Date to provide precise Time 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>, <tt>:hours</tt>,
+      # <tt>:minutes</tt>, <tt>:seconds</tt>.
+      def advance(options)
+        unless options[:weeks].nil?
+          options[:weeks], partial_weeks = options[:weeks].divmod(1)
+          options[:days] = (options[:days] || 0) + 7 * partial_weeks
+        end
+        
+        unless options[:days].nil?
+          options[:days], partial_days = options[:days].divmod(1)
+          options[:hours] = (options[:hours] || 0) + 24 * partial_days
+        end
+        
+        d = to_date.advance(options)
+        time_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
+        seconds_to_advance = (options[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600
+        seconds_to_advance == 0 ? time_advanced_by_date : time_advanced_by_date.since(seconds_to_advance)
+      end
+
+      # Returns a new Time representing the time a number of seconds ago, this is basically a wrapper around the Numeric extension
+      def ago(seconds)
+        self.since(-seconds)
+      end
+
+      # Returns a new Time representing the time a number of seconds since the instance time, this is basically a wrapper around
+      # the Numeric extension.
+      def since(seconds)
+        f = seconds.since(self)
+        if Useful::RubyExtensionsFromRails::Duration === seconds
+          f
+        else
+          initial_dst = self.dst? ? 1 : 0
+          final_dst   = f.dst? ? 1 : 0
+          (seconds.abs >= 86400 && initial_dst != final_dst) ? f + (initial_dst - final_dst).hours : f
+        end
+      end
+      alias :in :since
+
+      # Returns a new Time representing the time a number of specified months ago
+      def months_ago(months)
+        advance(:months => -months)
+      end
+
+      # Returns a new Time representing the time a number of specified months in the future
+      def months_since(months)
+        advance(:months => months)
+      end
+
+      # Returns a new Time representing the time a number of specified years ago
+      def years_ago(years)
+        advance(:years => -years)
+      end
+
+      # Returns a new Time representing the time a number of specified years in the future
+      def years_since(years)
+        advance(:years => years)
+      end
+
+      # Short-hand for years_ago(1)
+      def last_year
+        years_ago(1)
+      end
+
+      # Short-hand for years_since(1)
+      def next_year
+        years_since(1)
+      end
+
+      # Short-hand for months_ago(1)
+      def last_month
+        months_ago(1)
+      end
+
+      # Short-hand for months_since(1)
+      def next_month
+        months_since(1)
+      end
+
+      # Returns a new Time representing the start of the day (0:00)
+      def beginning_of_day
+        (self - self.seconds_since_midnight).change(:usec => 0)
+      end
+      alias :midnight :beginning_of_day
+      alias :at_midnight :beginning_of_day
+      alias :at_beginning_of_day :beginning_of_day
+
+      # Returns a new Time representing the end of the day (23:59:59)
+      def end_of_day
+        change(:hour => 23, :min => 59, :sec => 59)
+      end
+      alias :at_end_of_day :end_of_day
+
+      # Returns a new Time representing the "start" of this week (Monday, 0:00)
+      def beginning_of_week
+        days_to_monday = self.wday!=0 ? self.wday-1 : 6
+        (self - days_to_monday.days).midnight
+      end
+      alias :monday :beginning_of_week
+      alias :at_beginning_of_week :beginning_of_week
+
+      # Returns a new Time representing the end of this week (Sunday, 23:59:59)
+      def end_of_week
+        days_to_sunday = self.wday!=0 ? 7-self.wday : 0
+        (self + days_to_sunday.days).end_of_day
+      end
+      alias :at_end_of_week :end_of_week
+
+      # Returns a new Time 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}
+        since(1.week).beginning_of_week.since(days_into_week[day].day).change(:hour => 0)
+      end
+
+      # Returns a new Time representing the start of the month (1st of the month, 0:00)
+      def beginning_of_month
+        #self - ((self.mday-1).days + self.seconds_since_midnight)
+        change(:day => 1,:hour => 0, :min => 0, :sec => 0, :usec => 0)
+      end
+      alias :at_beginning_of_month :beginning_of_month
+
+      # Returns a new Time representing the end of the month (last day of the month, 0:00)
+      def end_of_month
+        #self - ((self.mday-1).days + self.seconds_since_midnight)
+        last_day = ::Time.days_in_month( self.month, self.year )
+        change(:day => last_day, :hour => 23, :min => 59, :sec => 59, :usec => 0)
+      end
+      alias :at_end_of_month :end_of_month
+
+      # Returns  a new Time representing the start of the quarter (1st of january, april, july, october, 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 Time representing the end of the quarter (last day of march, june, september, december, 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 Time representing the start of the year (1st of january, 0:00)
+      def beginning_of_year
+        change(:month => 1,:day => 1,:hour => 0, :min => 0, :sec => 0, :usec => 0)
+      end
+      alias :at_beginning_of_year :beginning_of_year
+
+      # Returns a new Time representing the end of the year (31st of december, 23:59:59)
+      def end_of_year
+        change(:month => 12,:day => 31,:hour => 23, :min => 59, :sec => 59)
+      end
+      alias :at_end_of_year :end_of_year
+
+      # Convenience method which returns a new Time representing the time 1 day ago
+      def yesterday
+        advance(:days => -1)
+      end
+
+      # Convenience method which returns a new Time representing the time 1 day since the instance time
+      def tomorrow
+        advance(:days => 1)
+      end
+
+      # Converts to a formatted string. See DATE_FORMATS for builtin formats.
+      #
+      # This method is aliased to <tt>to_s</tt>.
+      #
+      #   time = Time.now                     # => Thu Jan 18 06:10:17 CST 2007
+      #
+      #   time.to_formatted_s(:time)          # => "06:10:17"
+      #   time.to_s(:time)                    # => "06:10:17"
+      #
+      #   time.to_formatted_s(:db)            # => "2007-01-18 06:10:17"
+      #   time.to_formatted_s(:number)        # => "20070118061017"
+      #   time.to_formatted_s(:short)         # => "18 Jan 06:10"
+      #   time.to_formatted_s(:long)          # => "January 18, 2007 06:10"
+      #   time.to_formatted_s(:long_ordinal)  # => "January 18th, 2007 06:10"
+      #   time.to_formatted_s(:rfc822)        # => "Thu, 18 Jan 2007 06:10:17 -0600"
+      #
+      # == Adding your own time formats to +to_formatted_s+
+      # You can add your own formats to the Time::DATE_FORMATS hash.
+      # Use the format name as the hash key and either a strftime string
+      # or Proc instance that takes a time argument as the value.
+      #
+      #   # config/initializers/time_formats.rb
+      #   Time::DATE_FORMATS[:month_and_year] = "%B %Y"
+      #   Time::DATE_FORMATS[:short_ordinal] = lambda { |time| time.strftime("%B #{time.day.ordinalize}") }
+      def to_formatted_s(format = :default)
+        return to_default_s unless formatter = DATE_FORMATS[format]
+        formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
+      end
+      
+      # Returns the UTC offset as an +HH:MM formatted string.
+      #
+      #   Time.local(2000).formatted_offset         # => "-06:00"
+      #   Time.local(2000).formatted_offset(false)  # => "-0600"
+      def formatted_offset(colon = true, alternate_utc_string = nil)
+        utc? && alternate_utc_string || utc_offset.to_utc_offset_s(colon)
+      end
+
+      # Converts a Time object to a Date, dropping hour, minute, and second precision.
+      #
+      #   my_time = Time.now  # => Mon Nov 12 22:59:51 -0500 2007
+      #   my_time.to_date     # => Mon, 12 Nov 2007
+      #
+      #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")  # => Tue Jan 13 13:13:03 -0500 2009
+      #   your_time.to_date                                 # => Tue, 13 Jan 2009
+      def to_date
+        ::Date.new(year, month, day)
+      end
+
+    end
+  end
+end
+
+class Time
+  include Useful::RubyExtensionsFromRails::Time
+end

data/lib/useful/ruby_extensions_from_rails.rb

@@ -0,0 +1,3 @@
+Dir[File.join(File.dirname(__FILE__), "ruby_extensions_from_rails" ,"*.rb")].each do |file|
+  require file
+end

data/lib/useful/sinatra_helpers.rb

@@ -1,4 +1,3 @@
-$:.unshift File.dirname(__FILE__)
-require 'sinatra_helpers/environment_tests'
-require 'sinatra_helpers/erb'
-require 'sinatra_helpers/tags'
+Dir[File.join(File.dirname(__FILE__), "sinatra_helpers" ,"*.rb")].each do |file|
+  require file
+end

data/lib/useful/version.rb

@@ -3,7 +3,7 @@ module Useful
     
     MAJOR = 0
     MINOR = 1
-    TINY  = 1
+    TINY  = 2
     
     def self.to_s # :nodoc:
       [MAJOR, MINOR, TINY].join('.')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kelredd-useful
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Kelredd
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-02 00:00:00 -07:00
+date: 2009-06-16 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -27,12 +27,25 @@ files:
 - lib/useful
 - lib/useful/ruby_extensions
 - lib/useful/ruby_extensions/array.rb
+- lib/useful/ruby_extensions/date.rb
+- lib/useful/ruby_extensions/false_class.rb
 - lib/useful/ruby_extensions/fixnum.rb
 - lib/useful/ruby_extensions/hash.rb
 - lib/useful/ruby_extensions/numeric.rb
 - lib/useful/ruby_extensions/object.rb
 - lib/useful/ruby_extensions/string.rb
+- lib/useful/ruby_extensions/true_class.rb
 - lib/useful/ruby_extensions.rb
+- lib/useful/ruby_extensions_from_rails
+- lib/useful/ruby_extensions_from_rails/date.rb
+- lib/useful/ruby_extensions_from_rails/duration.rb
+- lib/useful/ruby_extensions_from_rails/fixnum.rb
+- lib/useful/ruby_extensions_from_rails/hash.rb
+- lib/useful/ruby_extensions_from_rails/numeric.rb
+- lib/useful/ruby_extensions_from_rails/object.rb
+- lib/useful/ruby_extensions_from_rails/string.rb
+- lib/useful/ruby_extensions_from_rails/time.rb
+- lib/useful/ruby_extensions_from_rails.rb
 - lib/useful/sinatra_helpers
 - lib/useful/sinatra_helpers/environment_tests.rb
 - lib/useful/sinatra_helpers/erb