activesupport 2.0.5 → 2.1.0

data/lib/active_support/core_ext/string/conversions.rb

@@ -1,4 +1,4 @@
-require 'parsedate'
+require 'date'
 
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
@@ -12,15 +12,15 @@ module ActiveSupport #:nodoc:
 
         # Form can be either :utc (default) or :local.
         def to_time(form = :utc)
-          ::Time.send("#{form}_time", *ParseDate.parsedate(self)[0..5].map {|arg| arg || 0})
+          ::Time.send("#{form}_time", *::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 })
         end
 
         def to_date
-          ::Date.new(*ParseDate.parsedate(self)[0..2])
+          ::Date.new(*::Date._parse(self, false).values_at(:year, :mon, :mday))
         end
 
         def to_datetime
-          ::DateTime.civil(*ParseDate.parsedate(self)[0..5].map {|arg| arg || 0} << 0)
+          ::DateTime.civil(*::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec).map { |arg| arg || 0 })
         end
       end
     end

data/lib/active_support/core_ext/string/filters.rb

@@ -0,0 +1,26 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      module Filters
+        # Returns the string, first removing all whitespace on both ends of
+        # the string, and then changing remaining consecutive whitespace
+        # groups into one space each.
+        #
+        # Examples:
+        #   %{ Multi-line
+        #      string }.squish                   # => "Multi-line string"
+        #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
+        def squish
+          dup.squish!
+        end
+
+        # Performs a destructive squish. See String#squish.
+        def squish!
+          strip!
+          gsub!(/\s+/, ' ')
+          self
+        end
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/string/inflections.rb

@@ -5,44 +5,42 @@ module ActiveSupport #:nodoc:
     module String #:nodoc:
       # String inflections define new methods on the String class to transform names for different purposes.
       # For instance, you can figure out the name of a database from the name of a class.
-      #   "ScaleScore".tableize => "scale_scores"
+      #
+      #   "ScaleScore".tableize # => "scale_scores"
       module Inflections
         # Returns the plural form of the word in the string.
         #
-        # Examples
-        #   "post".pluralize #=> "posts"
-        #   "octopus".pluralize #=> "octopi"
-        #   "sheep".pluralize #=> "sheep"
-        #   "words".pluralize #=> "words"
-        #   "the blue mailman".pluralize #=> "the blue mailmen"
-        #   "CamelOctopus".pluralize #=> "CamelOctopi"
+        #   "post".pluralize             # => "posts"
+        #   "octopus".pluralize          # => "octopi"
+        #   "sheep".pluralize            # => "sheep"
+        #   "words".pluralize            # => "words"
+        #   "the blue mailman".pluralize # => "the blue mailmen"
+        #   "CamelOctopus".pluralize     # => "CamelOctopi"
         def pluralize
           Inflector.pluralize(self)
         end
 
-        # The reverse of pluralize, returns the singular form of a word in a string.
+        # The reverse of +pluralize+, returns the singular form of a word in a string.
         #
-        # Examples
-        #   "posts".singularize #=> "post"
-        #   "octopi".singularize #=> "octopus"
-        #   "sheep".singluarize #=> "sheep"
-        #   "word".singluarize #=> "word"
-        #   "the blue mailmen".singularize #=> "the blue mailman"
-        #   "CamelOctopi".singularize #=> "CamelOctopus"
+        #   "posts".singularize            # => "post"
+        #   "octopi".singularize           # => "octopus"
+        #   "sheep".singluarize            # => "sheep"
+        #   "word".singluarize             # => "word"
+        #   "the blue mailmen".singularize # => "the blue mailman"
+        #   "CamelOctopi".singularize      # => "CamelOctopus"
         def singularize
           Inflector.singularize(self)
         end
 
-        # By default, camelize converts strings to UpperCamelCase. If the argument to camelize
-        # is set to ":lower" then camelize produces lowerCamelCase.
+        # 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 
+        # +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"
+        #   "active_record".camelize                # => "ActiveRecord"
+        #   "active_record".camelize(:lower)        # => "activeRecord"
+        #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+        #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
         def camelize(first_letter = :upper)
           case first_letter
             when :upper then Inflector.camelize(self, true)
@@ -52,78 +50,72 @@ module ActiveSupport #:nodoc:
         alias_method :camelcase, :camelize
 
         # Capitalizes all the words and replaces some characters in the string to create
-        # a nicer looking title. Titleize is meant for creating pretty output. It is not
+        # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
         # used in the Rails internals.
         #
-        # titleize is also aliased as as titlecase
+        # +titleize+ is also aliased as +titlecase+.
         #
-        # Examples
-        #   "man from the boondocks".titleize #=> "Man From The Boondocks"
-        #   "x-men: the last stand".titleize #=> "X Men: The Last Stand"
+        #   "man from the boondocks".titleize # => "Man From The Boondocks"
+        #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
         def titleize
           Inflector.titleize(self)
         end
         alias_method :titlecase, :titleize
 
-        # The reverse of +camelize+. Makes an underscored form from the expression in the string.
+        # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
         # 
-        # Changes '::' to '/' to convert namespaces to paths.
+        # +underscore+ will also change '::' to '/' to convert namespaces to paths.
         #
-        # Examples
-        #   "ActiveRecord".underscore #=> "active_record"
-        #   "ActiveRecord::Errors".underscore #=> active_record/errors
+        #   "ActiveRecord".underscore         # => "active_record"
+        #   "ActiveRecord::Errors".underscore # => active_record/errors
         def underscore
           Inflector.underscore(self)
         end
 
         # Replaces underscores with dashes in the string.
         #
-        # Example
-        #   "puni_puni" #=> "puni-puni"
+        #   "puni_puni" # => "puni-puni"
         def dasherize
           Inflector.dasherize(self)
         end
 
-        # Removes the module part from the expression in the string
+        # Removes the module part from the constant expression in the string.
         #
-        # Examples
-        #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
-        #   "Inflections".demodulize #=> "Inflections"
+        #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+        #   "Inflections".demodulize                                       # => "Inflections"
         def demodulize
           Inflector.demodulize(self)
         end
 
-        # Create the name of a table like Rails does for models to table names. This method
-        # uses the pluralize method on the last word in the string.
+        # Creates the name of a table like Rails does for models to table names. This method
+        # uses the +pluralize+ method on the last word in the string.
         #
-        # Examples
-        #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
-        #   "egg_and_ham".tableize #=> "egg_and_hams"
-        #   "fancyCategory".tableize #=> "fancy_categories"
+        #   "RawScaledScorer".tableize # => "raw_scaled_scorers"
+        #   "egg_and_ham".tableize     # => "egg_and_hams"
+        #   "fancyCategory".tableize   # => "fancy_categories"
         def tableize
           Inflector.tableize(self)
         end
 
         # Create a class name from a plural table name 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.)
+        # 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"
+        #   "egg_and_hams".classify # => "EggAndHam"
+        #   "posts".classify        # => "Post"
         #
-        # Singular names are not handled correctly
-        #   "business".classify #=> "Busines"
+        # Singular names are not handled correctly.
+        #
+        #   "business".classify # => "Busines"
         def classify
           Inflector.classify(self)
         end
         
-        # Capitalizes the first word and turns underscores into spaces and strips _id.
-        # Like titleize, this is meant for creating pretty output.
+        # Capitalizes the first word, turns underscores into spaces, and strips '_id'.
+        # Like +titleize+, this is meant for creating pretty output.
         #
-        # Examples
-        #   "employee_salary" #=> "Employee salary" 
-        #   "author_id" #=> "Author"
+        #   "employee_salary" # => "Employee salary" 
+        #   "author_id"       # => "Author"
         def humanize
           Inflector.humanize(self)
         end
@@ -133,20 +125,20 @@ module ActiveSupport #:nodoc:
         # the method should put '_' between the name and 'id'.
         #
         # Examples
-        #   "Message".foreign_key #=> "message_id"
-        #   "Message".foreign_key(false) #=> "messageid"
-        #   "Admin::Post".foreign_key #=> "post_id"
+        #   "Message".foreign_key        # => "message_id"
+        #   "Message".foreign_key(false) # => "messageid"
+        #   "Admin::Post".foreign_key    # => "post_id"
         def foreign_key(separate_class_name_and_id_with_underscore = true)
           Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
         end
 
-        # Constantize tries to find a declared constant with the name specified
+        # +constantize+ tries to find a declared constant with the name specified
         # in the string. It raises a NameError when the name is not in CamelCase
         # or is not initialized.
         #
         # Examples
-        #   "Module".constantize #=> Module
-        #   "Class".constantize #=> Class
+        #   "Module".constantize # => Module
+        #   "Class".constantize  # => Class
         def constantize
           Inflector.constantize(self)
         end

data/lib/active_support/core_ext/string/iterators.rb

@@ -5,6 +5,10 @@ module ActiveSupport #:nodoc:
     module String #:nodoc:
       # Custom string iterators
       module Iterators
+        def self.append_features(base)
+          super unless '1.9'.respond_to?(:each_char)
+        end
+
         # Yields a single-character string for each character in the string.
         # When $KCODE = 'UTF8', multi-byte characters are yielded appropriately.
         def each_char

data/lib/active_support/core_ext/string/starts_ends_with.rb

@@ -3,10 +3,18 @@ module ActiveSupport #:nodoc:
     module String #:nodoc:
       # Additional string tests.
       module StartsEndsWith
-        def self.included(base)
-          base.class_eval do
-            alias_method :start_with?, :starts_with?
-            alias_method :end_with?, :ends_with?
+        def self.append_features(base)
+          if '1.8.7 and up'.respond_to?(:start_with?)
+            base.class_eval do
+              alias_method :starts_with?, :start_with?
+              alias_method :ends_with?, :end_with?
+            end
+          else
+            super
+            base.class_eval do
+              alias_method :start_with?, :starts_with?
+              alias_method :end_with?, :ends_with?
+            end
           end
         end
 

data/lib/active_support/core_ext/string/unicode.rb

@@ -1,33 +1,40 @@
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module String #:nodoc:
-      if RUBY_VERSION < '1.9'
+      unless '1.9'.respond_to?(:force_encoding)
         # Define methods for handling unicode data.
         module Unicode
+          def self.append_features(base)
+            if '1.8.7'.respond_to?(:chars)
+              base.class_eval { remove_method :chars }
+            end
+            super
+          end
+
           # +chars+ is a Unicode safe proxy for string methods. It creates and returns an instance of the
           # ActiveSupport::Multibyte::Chars class which encapsulates the original string. A Unicode safe version of all
           # the String methods are defined on this proxy class. Undefined methods are forwarded to String, so all of the
           # string overrides can also be called through the +chars+ proxy.
           #
           #   name = 'Claus Müller'
-          #   name.reverse #=> "rell??M sualC"
-          #   name.length #=> 13
+          #   name.reverse              # => "rell??M sualC"
+          #   name.length               # => 13
           #
-          #   name.chars.reverse.to_s #=> "rellüM sualC"
-          #   name.chars.length #=> 12
+          #   name.chars.reverse.to_s   # => "rellüM sualC"
+          #   name.chars.length         # => 12
           #   
           #
           # All the methods on the chars proxy which normally return a string will return a Chars object. This allows
           # method chaining on the result of any of these methods.
           #
-          #   name.chars.reverse.length #=> 12
+          #   name.chars.reverse.length # => 12
           #
           # The Char object tries to be as interchangeable with String objects as possible: sorting and comparing between
           # String and Char work like expected. The bang! methods change the internal string representation in the Chars
           # object. Interoperability problems can be resolved easily with a +to_s+ call.
           #
           # For more information about the methods defined on the Chars proxy see ActiveSupport::Multibyte::Chars and
-          # ActiveSupport::Multibyte::Handlers::UTF8Handler
+          # ActiveSupport::Multibyte::Handlers::UTF8Handler.
           def chars
             ActiveSupport::Multibyte::Chars.new(self)
           end

data/lib/active_support/core_ext/symbol.rb

@@ -1,4 +1,4 @@
-unless :test.respond_to?(:to_proc)
+unless :to_proc.respond_to?(:to_proc)
   class Symbol
     # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
     #

data/lib/active_support/core_ext/time.rb

@@ -11,9 +11,11 @@ end
 require 'active_support/core_ext/time/behavior'
 require 'active_support/core_ext/time/calculations'
 require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/time/zones'
 
 class Time#:nodoc:
   include ActiveSupport::CoreExtensions::Time::Behavior
   include ActiveSupport::CoreExtensions::Time::Calculations
   include ActiveSupport::CoreExtensions::Time::Conversions
+  include ActiveSupport::CoreExtensions::Time::Zones
 end

data/lib/active_support/core_ext/time/calculations.rb

@@ -9,24 +9,31 @@ module ActiveSupport #:nodoc:
           base.class_eval do
             alias_method :plus_without_duration, :+
             alias_method :+, :plus_with_duration
+            
             alias_method :minus_without_duration, :-
             alias_method :-, :minus_with_duration
+            
+            alias_method :minus_without_coercion, :-
+            alias_method :-, :minus_with_coercion
+            
+            alias_method :compare_without_coercion, :<=>
+            alias_method :<=>, :compare_with_coercion
           end
         end
 
+        COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
         module ClassMethods
-          # Return the number of days in the given month. If a year is given,
-          # February will return the correct number of days for leap years.
-          # Otherwise, this method will always report February as having 28
-          # days.
-          def days_in_month(month, year=nil)
-            if month == 2
-              !year.nil? && (year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)) ?  29 : 28
-            elsif month <= 7
-              month % 2 == 0 ? 30 : 31
-            else
-              month % 2 == 0 ? 31 : 30
-            end
+          # Overriding case equality method so that it returns true for ActiveSupport::TimeWithZone instances
+          def ===(other)
+            other.is_a?(::Time)
+          end
+          
+          # 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
@@ -39,12 +46,12 @@ module ActiveSupport #:nodoc:
             ::DateTime.civil(year, month, day, hour, min, sec, offset)
           end
 
-          # wraps class method time_with_datetime_fallback with utc_or_local == :utc
+          # 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 == :local
+          # 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
@@ -71,8 +78,10 @@ module ActiveSupport #:nodoc:
           )
         end
 
-        # Uses Date to provide precise Time calculations for years, months, and days.  The +options+ parameter takes a hash with
-        # any of these keys: :years, :months, :weeks, :days, :hours, :minutes, :seconds.
+        # 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)
           d = to_date.advance(options)
           time_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
@@ -81,18 +90,21 @@ module ActiveSupport #:nodoc:
         end
 
         # Returns a new Time representing the time a number of seconds ago, this is basically a wrapper around the Numeric extension
-        # Do not use this method in combination with x.months, use months_ago instead!
         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. Do not use this method in combination with x.months, use months_since instead!
+        # the Numeric extension.
         def since(seconds)
-          initial_dst = self.dst? ? 1 : 0
           f = seconds.since(self)
-          final_dst   = f.dst? ? 1 : 0
-          (seconds.abs >= 86400 && initial_dst != final_dst) ? f + (initial_dst - final_dst).hours : f
+          if ActiveSupport::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
         rescue
           self.to_datetime.since(seconds)          
         end
@@ -147,6 +159,13 @@ module ActiveSupport #:nodoc:
         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}
@@ -187,20 +206,32 @@ module ActiveSupport #:nodoc:
         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
+          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
-          self.ago(1.day)
+          advance(:days => -1)
         end
 
         # Convenience method which returns a new Time representing the time 1 day since the instance time
         def tomorrow
-          self.since(1.day)
+          advance(:days => 1)
         end
 
         def plus_with_duration(other) #:nodoc:
@@ -218,6 +249,27 @@ module ActiveSupport #:nodoc:
             minus_without_duration(other)
           end
         end
+        
+        # Time#- can also be used to determine the number of seconds between two Time instances.
+        # We're layering on additional behavior so that ActiveSupport::TimeWithZone instances
+        # are coerced into values that Time#- will recognize
+        def minus_with_coercion(other)
+          other = other.comparable_time if other.respond_to?(:comparable_time)
+          minus_without_coercion(other)
+        end
+        
+        # Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances
+        # can be chronologically compared with a Time
+        def compare_with_coercion(other)
+          # if other is an ActiveSupport::TimeWithZone, coerce a Time instance from it so we can do <=> comparision
+          other = other.comparable_time if other.respond_to?(:comparable_time)
+          if other.acts_like?(:date)
+            # other is a Date/DateTime, so coerce self #to_datetime and hand off to DateTime#<=>
+            to_datetime.compare_without_coercion(other)
+          else
+            compare_without_coercion(other)
+          end
+        end
       end
     end
   end