activesupport 3.0.20 → 3.1.0.beta1

data/lib/active_support/core_ext/object/with_options.rb

@@ -7,13 +7,27 @@ class Object
   # provided. Each method called on the block variable must take an options
   # hash as its final argument.
   #
-  #   with_options :order => 'created_at', :class_name => 'Comment' do |post|
-  #     post.has_many :comments, :conditions => ['approved = ?', true], :dependent => :delete_all
-  #     post.has_many :unapproved_comments, :conditions => ['approved = ?', false]
-  #     post.has_many :all_comments
+  # Without with_options, this code contains duplication:
+  #
+  #   class Account < ActiveRecord::Base
+  #     has_many :customers, :dependent => :destroy
+  #     has_many :products,  :dependent => :destroy
+  #     has_many :invoices,  :dependent => :destroy
+  #     has_many :expenses,  :dependent => :destroy
+  #   end
+  #
+  # Using with_options, we can remove the duplication:
+  #
+  #   class Account < ActiveRecord::Base
+  #     with_options :dependent => :destroy do |assoc|
+  #       assoc.has_many :customers
+  #       assoc.has_many :products
+  #       assoc.has_many :invoices
+  #       assoc.has_many :expenses
+  #     end
   #   end
   #
-  # Can also be used with an explicit receiver:
+  # It can also be used with an explicit receiver:
   #
   #   map.with_options :controller => "people" do |people|
   #     people.connect "/people",     :action => "index"

data/lib/active_support/core_ext/range.rb

@@ -2,3 +2,4 @@ require 'active_support/core_ext/range/blockless_step'
 require 'active_support/core_ext/range/conversions'
 require 'active_support/core_ext/range/include_range'
 require 'active_support/core_ext/range/overlaps'
+require 'active_support/core_ext/range/cover'

data/lib/active_support/core_ext/range/cover.rb

@@ -0,0 +1,3 @@
+class Range
+  alias_method(:cover?, :include?) unless instance_methods.include?(:cover?)
+end

data/lib/active_support/core_ext/string.rb

@@ -11,3 +11,4 @@ require 'active_support/core_ext/string/output_safety'
 require 'active_support/core_ext/string/exclude'
 require 'active_support/core_ext/string/encoding'
 require 'active_support/core_ext/string/strip'
+require 'active_support/core_ext/string/inquiry'

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

@@ -25,13 +25,13 @@ class String
   #   "Once upon a time in a world far far away".truncate(27)
   #   # => "Once upon a time in a wo..."
   #
-  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
-  # for a total length not exceeding <tt>:length</tt>:
+  # Pass a <tt>:separator</tt> to truncate +text+ at a natural break:
   #
   #   "Once upon a time in a world far far away".truncate(27, :separator => ' ')
   #   # => "Once upon a time in a..."
   #
-  # Pass a <tt>:separator</tt> to truncate +text+ at a natural break:
+  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
+  # for a total length not exceeding <tt>:length</tt>:
   #
   #   "And they found that many people were sleeping better.".truncate(25, :omission => "... (continued)")
   #   # => "And they f... (continued)"

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

@@ -3,7 +3,7 @@ require 'active_support/inflector/inflections'
 require 'active_support/inflector/transliterate'
 
 # 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.
+# For instance, you can figure out the name of a table from the name of a class.
 #
 #   "ScaleScore".tableize # => "scale_scores"
 #

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

@@ -0,0 +1,13 @@
+require 'active_support/string_inquirer'
+
+class String
+  # Wraps the current string in the ActiveSupport::StringInquirer class,
+  # which gives you a prettier way to test for equality. Example:
+  #
+  #   env = "production".inquiry
+  #   env.production?  # => true
+  #   env.development? # => false
+  def inquiry
+    ActiveSupport::StringInquirer.new(self)
+  end
+end

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

@@ -9,7 +9,7 @@ class String
     #
     # In Ruby 1.8 and older 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. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsuled string.
+    # class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsulated string.
     #
     #   name = 'Claus Müller'
     #   name.reverse # => "rell??M sualC"

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

@@ -3,38 +3,28 @@ require 'active_support/core_ext/kernel/singleton_class'
 
 class ERB
   module Util
-    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#x27;' }
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
     JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003E', '<' => '\u003C' }
 
-    if RUBY_VERSION >= '1.9'
-      # A utility method for escaping HTML tag characters.
-      # This method is also aliased as <tt>h</tt>.
-      #
-      # In your ERB templates, use this method to escape any unsafe content. For example:
-      #   <%=h @person.name %>
-      #
-      # ==== Example:
-      #   puts html_escape("is a > 0 & a < 10?")
-      #   # => is a &gt; 0 &amp; a &lt; 10?
-      def html_escape(s)
-        s = s.to_s
-        if s.html_safe?
-          s
-        else
-          s.gsub(/[&"'><]/, HTML_ESCAPE).html_safe
-        end
-      end
-    else
-      def html_escape(s) #:nodoc:
-        s = s.to_s
-        if s.html_safe?
-          s
-        else
-          s.gsub(/[&"'><]/n) { |special| HTML_ESCAPE[special] }.html_safe
-        end
+    # A utility method for escaping HTML tag characters.
+    # This method is also aliased as <tt>h</tt>.
+    #
+    # In your ERB templates, use this method to escape any unsafe content. For example:
+    #   <%=h @person.name %>
+    #
+    # ==== Example:
+    #   puts html_escape("is a > 0 & a < 10?")
+    #   # => is a &gt; 0 &amp; a &lt; 10?
+    def html_escape(s)
+      s = s.to_s
+      if s.html_safe?
+        s
+      else
+        s.gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }.html_safe
       end
     end
 
+    # Aliasing twice issues a warning "discarding old...". Remove first to avoid it.
     remove_method(:h)
     alias h html_escape
 
@@ -61,8 +51,7 @@ class ERB
     #   <%=j @person.to_json %>
     #
     def json_escape(s)
-      result = s.to_s.gsub(/[&"><]/) { |special| JSON_ESCAPE[special] }
-      s.html_safe? ? result.html_safe : result
+      s.to_s.gsub(/[&"><]/) { |special| JSON_ESCAPE[special] }
     end
 
     alias j json_escape
@@ -85,50 +74,10 @@ end
 
 module ActiveSupport #:nodoc:
   class SafeBuffer < String
-    UNSAFE_STRING_METHODS = ["capitalize", "chomp", "chop", "delete", "downcase", "gsub", "lstrip", "next", "reverse", "rstrip", "slice", "squeeze", "strip", "sub", "succ", "swapcase", "tr", "tr_s", "upcase", "prepend"].freeze
-
-    alias_method :original_concat, :concat
-    private :original_concat
-
-    class SafeConcatError < StandardError
-      def initialize
-        super "Could not concatenate to the buffer because it is not html safe."
-      end
-    end
-
-    def [](*args)
-      return super if args.size < 2
-
-      if html_safe?
-        new_safe_buffer = super
-        new_safe_buffer.instance_eval { @html_safe = true }
-        new_safe_buffer
-      else
-        to_str[*args]
-      end
-    end
-
-    def safe_concat(value)
-      raise SafeConcatError unless html_safe?
-      original_concat(value)
-    end
-
-    def initialize(*)
-      @html_safe = true
-      super
-    end
-
-    def initialize_copy(other)
-      super
-      @html_safe = other.html_safe?
-    end
-
-    def clone_empty
-      self[0, 0]
-    end
+    alias safe_concat concat
 
     def concat(value)
-      if !html_safe? || value.html_safe?
+      if value.html_safe?
         super(value)
       else
         super(ERB::Util.h(value))
@@ -141,39 +90,34 @@ module ActiveSupport #:nodoc:
     end
 
     def html_safe?
-      defined?(@html_safe) && @html_safe
+      true
+    end
+
+    def html_safe
+      self
     end
 
     def to_s
       self
     end
 
-    def to_param
-      to_str
+    def encode_with(coder)
+      coder.represent_scalar nil, to_str
     end
 
     def to_yaml(*args)
-      to_str.to_yaml(*args)
-    end
+      return super() if defined?(YAML::ENGINE) && !YAML::ENGINE.syck?
 
-    for unsafe_method in UNSAFE_STRING_METHODS
-      if 'String'.respond_to?(unsafe_method)
-        class_eval <<-EOT, __FILE__, __LINE__ + 1
-          def #{unsafe_method}(*args, &block)       # def capitalize(*args, &block)
-            to_str.#{unsafe_method}(*args, &block)  #   to_str.capitalize(*args, &block)
-          end                                       # end
-
-          def #{unsafe_method}!(*args)              # def capitalize!(*args)
-            @html_safe = false                      #   @html_safe = false
-            super                                   #   super
-          end                                       # end
-        EOT
-      end
+      to_str.to_yaml(*args)
     end
   end
 end
 
 class String
+  def html_safe!
+    raise "You can't call html_safe! on a String"
+  end
+
   def html_safe
     ActiveSupport::SafeBuffer.new(self)
   end

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

@@ -1,7 +1,4 @@
 require 'active_support/duration'
-require 'active_support/core_ext/date/acts_like'
-require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/date_time/conversions'
 
 class Time
   COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
@@ -10,7 +7,7 @@ class Time
   class << self
     # Overriding case equality method so that it returns true for ActiveSupport::TimeWithZone instances
     def ===(other)
-      super || (self == Time && other.is_a?(ActiveSupport::TimeWithZone))
+      other.is_a?(::Time)
     end
 
     # Return the number of days in the given month.
@@ -22,7 +19,7 @@ class Time
 
     # 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
+    # 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 = ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
       # This check is needed because Time.utc(y) returns a time object in the 2000s for 0 <= y <= 138.
@@ -117,6 +114,11 @@ class Time
   end
   alias :in :since
 
+  # Returns a new Time representing the time a number of specified weeks ago.
+  def weeks_ago(weeks)
+    advance(:weeks => -weeks)
+  end
+
   # Returns a new Time representing the time a number of specified months ago
   def months_ago(months)
     advance(:months => -months)
@@ -172,6 +174,11 @@ class Time
   end
   alias :at_end_of_week :end_of_week
 
+  # Returns a new Time representing the start of the given day in the previous week (default is Monday).
+  def prev_week(day = :monday)
+    ago(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0)
+  end
+
   # Returns a new Time representing the start of the given day in next week (default is Monday).
   def next_week(day = :monday)
     since(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0)
@@ -273,14 +280,8 @@ class Time
   # 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 <=> comparison
-    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
+    # we're avoiding Time#to_datetime cause it's expensive
+    other.is_a?(Time) ? compare_without_coercion(other.to_time) : to_datetime <=> other
   end
   alias_method :compare_without_coercion, :<=>
   alias_method :<=>, :compare_with_coercion

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

@@ -19,8 +19,8 @@ class Time
   #
   #   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(:time)          # => "06:10"
+  #   time.to_s(:time)                    # => "06:10"
   #
   #   time.to_formatted_s(:db)            # => "2007-01-18 06:10:17"
   #   time.to_formatted_s(:number)        # => "20070118061017"
@@ -55,31 +55,9 @@ class Time
     utc? && alternate_utc_string || ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, 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 unless method_defined?(:to_date)
-
   # A method to keep Time, Date and DateTime instances interchangeable on conversions.
   # In this case, it simply returns +self+.
   def to_time
     self
   end unless method_defined?(:to_time)
-
-  # Converts a Time instance to a Ruby DateTime instance, preserving UTC offset.
-  #
-  #   my_time = Time.now    # => Mon Nov 12 23:04:21 -0500 2007
-  #   my_time.to_datetime   # => Mon, 12 Nov 2007 23:04:21 -0500
-  #
-  #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")  # => Tue Jan 13 13:13:03 -0500 2009
-  #   your_time.to_datetime                             # => Tue, 13 Jan 2009 13:13:03 -0500
-  def to_datetime
-    ::DateTime.civil(year, month, day, hour, min, sec, Rational(utc_offset, 86400))
-  end unless method_defined?(:to_datetime)
 end

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

@@ -37,7 +37,6 @@ if Time.local(2010).zone != Marshal.load(Marshal.dump(Time.local(2010))).zone
         time.instance_eval do
           if zone = defined?(@_zone) && remove_instance_variable('@_zone')
             ary = to_a
-            ary[0] += subsec if ary[0] == sec
             ary[-1] = zone
             utc? ? Time.utc(*ary) : Time.local(*ary)
           else

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

@@ -19,40 +19,51 @@ class Time
     # * A TZInfo::Timezone object.
     # * An identifier for a TZInfo::Timezone object (e.g., "America/New_York").
     #
-    # Here's an example of how you might set <tt>Time.zone</tt> on a per request basis -- <tt>current_user.time_zone</tt>
-    # just needs to return a string identifying the user's preferred TimeZone:
+    # Here's an example of how you might set <tt>Time.zone</tt> on a per request basis and reset it when the request is done.
+    # <tt>current_user.time_zone</tt> just needs to return a string identifying the user's preferred time zone:
     #
     #   class ApplicationController < ActionController::Base
-    #     before_filter :set_time_zone
+    #     around_filter :set_time_zone
     #
     #     def set_time_zone
-    #       Time.zone = current_user.time_zone
+    #       old_time_zone = Time.zone
+    #       Time.zone = current_user.time_zone if logged_in?
+    #       yield
+    #     ensure
+    #       Time.zone = old_time_zone
     #     end
     #   end
     def zone=(time_zone)
-      Thread.current[:time_zone] = get_zone(time_zone)
+      Thread.current[:time_zone] = find_zone!(time_zone)
     end
 
     # Allows override of <tt>Time.zone</tt> locally inside supplied block; resets <tt>Time.zone</tt> to existing value when done.
     def use_zone(time_zone)
-      old_zone, ::Time.zone = ::Time.zone, get_zone(time_zone)
-      yield
-    ensure
-      ::Time.zone = old_zone
+      new_zone = find_zone!(time_zone)
+      begin
+        old_zone, ::Time.zone = ::Time.zone, new_zone
+        yield
+      ensure
+        ::Time.zone = old_zone
+      end
     end
 
-    private
-      def get_zone(time_zone)
-        return time_zone if time_zone.nil? || time_zone.is_a?(ActiveSupport::TimeZone)
-        # lookup timezone based on identifier (unless we've been passed a TZInfo::Timezone)
-        unless time_zone.respond_to?(:period_for_local)
-          time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone) rescue nil
-        end
-        # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
-        if time_zone
-          time_zone.is_a?(ActiveSupport::TimeZone) ? time_zone : ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone)
-        end
+    # Returns a TimeZone instance or nil, or raises an ArgumentError for invalid timezones.
+    def find_zone!(time_zone)
+      return time_zone if time_zone.nil? || time_zone.is_a?(ActiveSupport::TimeZone)
+      # lookup timezone based on identifier (unless we've been passed a TZInfo::Timezone)
+      unless time_zone.respond_to?(:period_for_local)
+        time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone)
       end
+      # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
+      time_zone.is_a?(ActiveSupport::TimeZone) ? time_zone : ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone)
+    rescue TZInfo::InvalidTimezoneIdentifier
+      raise ArgumentError, "Invalid Timezone: #{time_zone}"
+    end
+
+    def find_zone(time_zone)
+      find_zone!(time_zone) rescue nil
+    end
   end
 
   # Returns the simultaneous time in <tt>Time.zone</tt>.
@@ -70,6 +81,6 @@ class Time
   def in_time_zone(zone = ::Time.zone)
     return self unless zone
 
-    ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.__send__(:get_zone, zone))
+    ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.find_zone!(zone))
   end
 end