activesupport 2.2.3 → 2.3.2

data/lib/active_support/core_ext/file/atomic.rb

@@ -1,5 +1,3 @@
-require 'tempfile'
-
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module File #:nodoc:
@@ -18,6 +16,8 @@ module ActiveSupport #:nodoc:
         #     file.write("hello")
         #   end
         def atomic_write(file_name, temp_dir = Dir.tmpdir)
+          require 'tempfile' unless defined?(Tempfile)
+
           temp_file = Tempfile.new(basename(file_name), temp_dir)
           yield temp_file
           temp_file.close

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

@@ -1,47 +1,22 @@
 require 'date'
-require 'cgi'
-require 'builder'
-require 'xmlsimple'
-
-# Locked down XmlSimple#xml_in_string
-class XmlSimple
-  # Same as xml_in but doesn't try to smartly shoot itself in the foot.
-  def xml_in_string(string, options = nil)
-    handle_options('in', options)
-
-    @doc = parse(string)
-    result = collapse(@doc.root)
-
-    if @options['keeproot']
-      merge({}, @doc.root.name, result)
-    else
-      result
-    end
-  end
-
-  def self.xml_in_string(string, options = nil)
-    new.xml_in_string(string, options)
-  end
-end
-
-# This module exists to decorate files deserialized using Hash.from_xml with
-# the <tt>original_filename</tt> and <tt>content_type</tt> methods.
-module FileLike #:nodoc:
-  attr_writer :original_filename, :content_type
-
-  def original_filename
-    @original_filename || 'untitled'
-  end
-
-  def content_type
-    @content_type || 'application/octet-stream'
-  end
-end
 
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Hash #:nodoc:
       module Conversions
+        # This module exists to decorate files deserialized using Hash.from_xml with
+        # the <tt>original_filename</tt> and <tt>content_type</tt> methods.
+        module FileLike #:nodoc:
+          attr_writer :original_filename, :content_type
+
+          def original_filename
+            @original_filename || 'untitled'
+          end
+
+          def content_type
+            @content_type || 'application/octet-stream'
+          end
+        end
 
         XML_TYPE_NAMES = {
           "Symbol"     => "symbol",
@@ -49,11 +24,12 @@ module ActiveSupport #:nodoc:
           "Bignum"     => "integer",
           "BigDecimal" => "decimal",
           "Float"      => "float",
+          "TrueClass"  => "boolean",
+          "FalseClass" => "boolean",
           "Date"       => "date",
           "DateTime"   => "datetime",
           "Time"       => "datetime",
-          "TrueClass"  => "boolean",
-          "FalseClass" => "boolean"
+          "ActiveSupport::TimeWithZone" => "datetime"
         } unless defined?(XML_TYPE_NAMES)
 
         XML_FORMATTING = {
@@ -100,7 +76,7 @@ module ActiveSupport #:nodoc:
         # Converts a hash into a string suitable for use as a URL query string. An optional <tt>namespace</tt> can be
         # passed to enclose the param names (see example below).
         #
-        # ==== Example:
+        # ==== Examples
         #   { :name => 'David', :nationality => 'Danish' }.to_query # => "name=David&nationality=Danish"
         #
         #   { :name => 'David', :nationality => 'Danish' }.to_query('user') # => "user%5Bname%5D=David&user%5Bnationality%5D=Danish"
@@ -113,12 +89,13 @@ module ActiveSupport #:nodoc:
         alias_method :to_param, :to_query
 
         def to_xml(options = {})
+          require 'builder' unless defined?(Builder)
+
           options[:indent] ||= 2
           options.reverse_merge!({ :builder => Builder::XmlMarkup.new(:indent => options[:indent]),
                                    :root => "hash" })
           options[:builder].instruct! unless options.delete(:skip_instruct)
-          dasherize = !options.has_key?(:dasherize) || options[:dasherize]
-          root = dasherize ? options[:root].to_s.dasherize : options[:root].to_s
+          root = rename_key(options[:root].to_s, options)
 
           options[:builder].__send__(:method_missing, root) do
             each do |key, value|
@@ -145,7 +122,7 @@ module ActiveSupport #:nodoc:
                   else
                     type_name = XML_TYPE_NAMES[value.class.name]
 
-                    key = dasherize ? key.to_s.dasherize : key.to_s
+                    key = rename_key(key.to_s, options)
 
                     attributes = options[:skip_types] || value.nil? || type_name.nil? ? { } : { :type => type_name }
                     if value.nil?
@@ -165,15 +142,16 @@ module ActiveSupport #:nodoc:
 
         end
 
+        def rename_key(key, options = {})
+          camelize = options.has_key?(:camelize) && options[:camelize]
+          dasherize = !options.has_key?(:dasherize) || options[:dasherize]
+          key = key.camelize if camelize
+          dasherize ? key.dasherize : key
+        end
+
         module ClassMethods
           def from_xml(xml)
-            # TODO: Refactor this into something much cleaner that doesn't rely on XmlSimple
-            typecast_xml_value(undasherize_keys(XmlSimple.xml_in_string(xml,
-              'forcearray'   => false,
-              'forcecontent' => true,
-              'keeproot'     => true,
-              'contentkey'   => '__content__')
-            ))
+            typecast_xml_value(unrename_keys(XmlMini.parse(xml)))
           end
 
           private
@@ -239,15 +217,15 @@ module ActiveSupport #:nodoc:
               end
             end
 
-            def undasherize_keys(params)
+            def unrename_keys(params)
               case params.class.to_s
                 when "Hash"
                   params.inject({}) do |h,(k,v)|
-                    h[k.to_s.tr("-", "_")] = undasherize_keys(v)
+                    h[k.to_s.underscore.tr("-", "_")] = unrename_keys(v)
                     h
                   end
                 when "Array"
-                  params.map { |v| undasherize_keys(v) }
+                  params.map { |v| unrename_keys(v) }
                 else
                   params
               end

data/lib/active_support/core_ext/hash/indifferent_access.rb

@@ -91,6 +91,12 @@ class HashWithIndifferentAccess < Hash
     self.dup.update(hash)
   end
 
+  # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+  # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+  def reverse_merge(other_hash)
+    super other_hash.with_indifferent_access
+  end
+
   # Removes a specified key from the hash.
   def delete(key)
     super(convert_key(key))

data/lib/active_support/core_ext/hash/keys.rb

@@ -38,7 +38,7 @@ module ActiveSupport #:nodoc:
         # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
         # as keys, this will fail.
         #
-        # ==== Examples:
+        # ==== Examples
         #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
         #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): name, age"
         #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing

data/lib/active_support/core_ext/hash/slice.rb

@@ -24,10 +24,17 @@ module ActiveSupport #:nodoc:
         end
 
         # Replaces the hash with only the given keys.
+        # Returns a hash contained the removed key/value pairs
+        #   {:a => 1, :b => 2, :c => 3, :d => 4}.slice!(:a, :b) # => {:c => 3, :d =>4}
         def slice!(*keys)
-          replace(slice(*keys))
+          keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
+          omit = slice(*self.keys - keys)
+          hash = slice(*keys)
+          replace(hash)
+          omit
         end
       end
     end
   end
 end
+

data/lib/active_support/core_ext/logger.rb

@@ -3,12 +3,12 @@
 class Logger
   def self.define_around_helper(level)
     module_eval <<-end_eval
-      def around_#{level}(before_message, after_message, &block)
-        self.#{level}(before_message)
-        return_value = block.call(self)
-        self.#{level}(after_message)
-        return return_value
-      end
+      def around_#{level}(before_message, after_message, &block)  # def around_debug(before_message, after_message, &block)
+        self.#{level}(before_message)                             #   self.debug(before_message)
+        return_value = block.call(self)                           #   return_value = block.call(self)
+        self.#{level}(after_message)                              #   self.debug(after_message)
+        return return_value                                       #   return return_value
+      end                                                         # end
     end_eval
   end
   [:debug, :info, :error, :fatal].each {|level| define_around_helper(level) }
@@ -30,6 +30,8 @@ require 'logger'
 #
 # Note: This logger is deprecated in favor of ActiveSupport::BufferedLogger
 class Logger
+  ##
+  # :singleton-method:
   # Set to false to disable the silencer
   cattr_accessor :silencer
   self.silencer = true

data/lib/active_support/core_ext/module/aliasing.rb

@@ -64,9 +64,9 @@ module ActiveSupport
       #   e.title    # => "Megastars"
       def alias_attribute(new_name, old_name)
         module_eval <<-STR, __FILE__, __LINE__+1
-          def #{new_name}; self.#{old_name}; end
-          def #{new_name}?; self.#{old_name}?; end
-          def #{new_name}=(v); self.#{old_name} = v; end
+          def #{new_name}; self.#{old_name}; end          # def subject; self.title; end
+          def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
+          def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end
         STR
       end
     end

data/lib/active_support/core_ext/module/attr_accessor_with_default.rb

@@ -22,10 +22,10 @@ class Module
     raise 'Default value or block required' unless !default.nil? || block
     define_method(sym, block_given? ? block : Proc.new { default })
     module_eval(<<-EVAL, __FILE__, __LINE__)
-      def #{sym}=(value)
-        class << self; attr_reader :#{sym} end
-        @#{sym} = value
-      end
+      def #{sym}=(value)                        # def age=(value)
+        class << self; attr_reader :#{sym} end  #   class << self; attr_reader :age end
+        @#{sym} = value                         #   @age = value
+      end                                       # end
     EVAL
   end
 end

data/lib/active_support/core_ext/module/attribute_accessors.rb

@@ -15,17 +15,17 @@ class Module
     syms.each do |sym|
       next if sym.is_a?(Hash)
       class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-        
-        def self.#{sym}
-          @@#{sym}
-        end
-
-        def #{sym}
-          @@#{sym}
-        end
+        unless defined? @@#{sym}  # unless defined? @@pagination_options
+          @@#{sym} = nil          #   @@pagination_options = nil
+        end                       # end
+                                  #
+        def self.#{sym}           # def self.pagination_options
+          @@#{sym}                #   @@pagination_options
+        end                       # end
+                                  #
+        def #{sym}                # def pagination_options
+          @@#{sym}                #   @@pagination_options
+        end                       # end
       EOS
     end
   end
@@ -34,19 +34,19 @@ class Module
     options = syms.extract_options!
     syms.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-        
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-        
-        #{"
-        def #{sym}=(obj)
-          @@#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
+        unless defined? @@#{sym}                       # unless defined? @@pagination_options
+          @@#{sym} = nil                               #   @@pagination_options = nil
+        end                                            # end
+                                                       #
+        def self.#{sym}=(obj)                          # def self.pagination_options=(obj)
+          @@#{sym} = obj                               #   @@pagination_options = obj
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def pagination_options=(obj)
+          @@#{sym} = obj                               #   @@pagination_options = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
       EOS
     end
   end

data/lib/active_support/core_ext/module/delegation.rb

@@ -72,6 +72,30 @@ class Module
   #   invoice.customer_name    # => "John Doe"
   #   invoice.customer_address # => "Vimmersvej 13"
   #
+  # If the object to which you delegate can be nil, you may want to use the
+  # :allow_nil option. In that case, it returns nil instead of raising a
+  # NoMethodError exception:
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar
+  #  end
+  #
+  #  Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar, :allow_nil => true
+  #  end
+  #
+  #  Foo.new.zoo   # returns nil
+  #
   def delegate(*methods)
     options = methods.pop
     unless options.is_a?(Hash) && to = options[:to]
@@ -84,11 +108,13 @@ class Module
 
     prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
 
+    allow_nil = options[:allow_nil] && "#{to} && "
+
     methods.each do |method|
       module_eval(<<-EOS, "(__DELEGATION__)", 1)
-        def #{prefix}#{method}(*args, &block)
-          #{to}.__send__(#{method.inspect}, *args, &block)
-        end
+        def #{prefix}#{method}(*args, &block)                           # def customer_name(*args, &block)
+          #{allow_nil}#{to}.__send__(#{method.inspect}, *args, &block)  #   client && client.__send__(:name, *args, &block)
+        end                                                             # end
       EOS
     end
   end

data/lib/active_support/core_ext/module/synchronization.rb

@@ -26,11 +26,11 @@ class Module
       end
 
       module_eval(<<-EOS, __FILE__, __LINE__)
-        def #{aliased_method}_with_synchronization#{punctuation}(*args, &block)
-          #{with}.synchronize do
-            #{aliased_method}_without_synchronization#{punctuation}(*args, &block)
-          end
-        end
+        def #{aliased_method}_with_synchronization#{punctuation}(*args, &block)     # def expire_with_synchronization(*args, &block)
+          #{with}.synchronize do                                                    #   @@lock.synchronize do
+            #{aliased_method}_without_synchronization#{punctuation}(*args, &block)  #     expire_without_synchronization(*args, &block)
+          end                                                                       #   end
+        end                                                                         # end
       EOS
 
       alias_method_chain method, :synchronization

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

@@ -9,6 +9,7 @@ class Object
   #
   # Note: This method is defined as a default implementation for all Objects for Hash#to_query to work.
   def to_query(key)
+    require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
     "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
   end
-end
+end

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

@@ -40,6 +40,21 @@ class Object
     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)
+
   # An elegant way to factor duplication out of options passed to a series of
   # method calls. Each method called in the block, with the block variable as
   # the receiver, will have its options merged with the default +options+ hash
@@ -71,4 +86,5 @@ class Object
   def acts_like?(duck)
     respond_to? "acts_like_#{duck}?"
   end
+
 end

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

@@ -15,7 +15,7 @@ module ActiveSupport #:nodoc:
         end
         # Gives a human readable format of the range.
         #
-        # ==== Example: 
+        # ==== Example
         # 
         #   [1..100].to_formatted_s # => "1..100"
         def to_formatted_s(format = :default)

data/lib/active_support/core_ext/rexml.rb

@@ -1,34 +1,39 @@
-require 'rexml/document'
-require 'rexml/entity'
-
 # Fixes the rexml vulnerability disclosed at:
 # http://www.ruby-lang.org/en/news/2008/08/23/dos-vulnerability-in-rexml/
 # This fix is identical to rexml-expansion-fix version 1.0.1
+require 'rexml/rexml'
 
 # Earlier versions of rexml defined REXML::Version, newer ones REXML::VERSION
-unless REXML::Document.respond_to?(:entity_expansion_limit=)
-  module REXML
-    class Entity < Child
-      undef_method :unnormalized
-      def unnormalized
-        document.record_entity_expansion! if document
-        v = value()
-        return nil if v.nil?
-        @unnormalized = Text::unnormalize(v, parent)
-        @unnormalized
-      end
-    end
-    class Document < Element
-      @@entity_expansion_limit = 10_000
-      def self.entity_expansion_limit= val
-        @@entity_expansion_limit = val
+unless (defined?(REXML::VERSION) ? REXML::VERSION : REXML::Version) > "3.1.7.2"
+  require 'rexml/document'
+
+  # REXML in 1.8.7 has the patch but didn't update Version from 3.1.7.2.
+  unless REXML::Document.respond_to?(:entity_expansion_limit=)
+    require 'rexml/entity'
+
+    module REXML
+      class Entity < Child
+        undef_method :unnormalized
+        def unnormalized
+          document.record_entity_expansion! if document
+          v = value()
+          return nil if v.nil?
+          @unnormalized = Text::unnormalize(v, parent)
+          @unnormalized
+        end
       end
+      class Document < Element
+        @@entity_expansion_limit = 10_000
+        def self.entity_expansion_limit= val
+          @@entity_expansion_limit = val
+        end
 
-      def record_entity_expansion!
-        @number_of_expansions ||= 0
-        @number_of_expansions += 1
-        if @number_of_expansions > @@entity_expansion_limit
-          raise "Number of entity expansions exceeded, processing aborted."
+        def record_entity_expansion!
+          @number_of_expansions ||= 0
+          @number_of_expansions += 1
+          if @number_of_expansions > @@entity_expansion_limit
+            raise "Number of entity expansions exceeded, processing aborted."
+          end
         end
       end
     end