activesupport 3.2.22.5 → 4.0.0

data/README.rdoc

@@ -12,19 +12,21 @@ The latest version of Active Support can be installed with RubyGems:
 
   % [sudo] gem install activesupport
 
-Source code can be downloaded as part of the Rails project on GitHub
+Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/3-2-stable/activesupport
+* https://github.com/rails/rails/tree/master/activesupport
 
 
 == License
 
-Active Support is released under the MIT license.
+Active Support is released under the MIT license:
+
+* http://www.opensource.org/licenses/MIT
 
 
 == Support
 
-API documentation is at
+API documentation is at:
 
 * http://api.rubyonrails.org
 

data/lib/active_support/backtrace_cleaner.rb

@@ -1,24 +1,29 @@
 module ActiveSupport
-  # Backtraces often include many lines that are not relevant for the context under review. This makes it hard to find the 
-  # signal amongst the backtrace noise, and adds debugging time. With a BacktraceCleaner, filters and silencers are used to
-  # remove the noisy lines, so that only the most relevant lines remain.
+  # Backtraces often include many lines that are not relevant for the context
+  # under review. This makes it hard to find the signal amongst the backtrace
+  # noise, and adds debugging time. With a BacktraceCleaner, filters and
+  # silencers are used to remove the noisy lines, so that only the most relevant
+  # lines remain.
   #
-  # Filters are used to modify lines of data, while silencers are used to remove lines entirely.  The typical filter use case
-  # is to remove lengthy path information from the start of each line, and view file paths relevant to the app directory 
-  # instead of the file system root.  The typical silencer use case is to exclude the output of a noisy library from the 
-  # backtrace, so that you can focus on the rest.
-  #
-  # ==== Example:
+  # Filters are used to modify lines of data, while silencers are used to remove
+  # lines entirely. The typical filter use case is to remove lengthy path
+  # information from the start of each line, and view file paths relevant to the
+  # app directory instead of the file system root. The typical silencer use case
+  # is to exclude the output of a noisy library from the backtrace, so that you
+  # can focus on the rest.
   #
   #   bc = BacktraceCleaner.new
   #   bc.add_filter   { |line| line.gsub(Rails.root, '') }
   #   bc.add_silencer { |line| line =~ /mongrel|rubygems/ }
   #   bc.clean(exception.backtrace) # will strip the Rails.root prefix and skip any lines from mongrel or rubygems
   #
-  # To reconfigure an existing BacktraceCleaner (like the default one in Rails) and show as much data as possible, you can 
-  # always call <tt>BacktraceCleaner#remove_silencers!</tt>, which will restore the backtrace to a pristine state.  If you 
-  # need to reconfigure an existing BacktraceCleaner so that it does not filter or modify the paths of any lines of the 
-  # backtrace, you can call BacktraceCleaner#remove_filters! These two methods will give you a completely untouched backtrace.
+  # To reconfigure an existing BacktraceCleaner (like the default one in Rails)
+  # and show as much data as possible, you can always call
+  # <tt>BacktraceCleaner#remove_silencers!</tt>, which will restore the
+  # backtrace to a pristine state. If you need to reconfigure an existing
+  # BacktraceCleaner so that it does not filter or modify the paths of any lines
+  # of the backtrace, you can call BacktraceCleaner#remove_filters! These two
+  # methods will give you a completely untouched backtrace.
   #
   # Inspired by the Quiet Backtrace gem by Thoughtbot.
   class BacktraceCleaner
@@ -26,9 +31,10 @@ module ActiveSupport
       @filters, @silencers = [], []
     end
 
-    # Returns the backtrace after all filters and silencers have been run against it. Filters run first, then silencers.
+    # Returns the backtrace after all filters and silencers have been run
+    # against it. Filters run first, then silencers.
     def clean(backtrace, kind = :silent)
-      filtered = filter(backtrace)
+      filtered = filter_backtrace(backtrace)
 
       case kind
       when :silent
@@ -39,10 +45,10 @@ module ActiveSupport
         filtered
       end
     end
+    alias :filter :clean
 
-    # Adds a filter from the block provided. Each line in the backtrace will be mapped against this filter.
-    #
-    # Example:
+    # Adds a filter from the block provided. Each line in the backtrace will be
+    # mapped against this filter.
     #
     #   # Will turn "/my/rails/root/app/models/person.rb" into "/app/models/person.rb"
     #   backtrace_cleaner.add_filter { |line| line.gsub(Rails.root, '') }
@@ -50,10 +56,8 @@ module ActiveSupport
       @filters << block
     end
 
-    # Adds a silencer from the block provided. If the silencer returns true for a given line, it will be excluded from 
-    # the clean backtrace.
-    #
-    # Example:
+    # Adds a silencer from the block provided. If the silencer returns +true+
+    # for a given line, it will be excluded from the clean backtrace.
     #
     #   # Will reject all lines that include the word "mongrel", like "/gems/mongrel/server.rb" or "/app/my_mongrel_server/rb"
     #   backtrace_cleaner.add_silencer { |line| line =~ /mongrel/ }
@@ -61,18 +65,22 @@ module ActiveSupport
       @silencers << block
     end
 
-    # Will remove all silencers, but leave in the filters. This is useful if your context of debugging suddenly expands as
-    # you suspect a bug in one of the libraries you use.
+    # Will remove all silencers, but leave in the filters. This is useful if
+    # your context of debugging suddenly expands as you suspect a bug in one of
+    # the libraries you use.
     def remove_silencers!
       @silencers = []
     end
 
+    # Removes all filters, but leaves in silencers. Useful if you suddenly
+    # need to see entire filepaths in the backtrace that you had already
+    # filtered out.
     def remove_filters!
       @filters = []
     end
 
     private
-      def filter(backtrace)
+      def filter_backtrace(backtrace)
         @filters.each do |f|
           backtrace = backtrace.map { |line| f.call(line) }
         end

data/lib/active_support/basic_object.rb

@@ -1,21 +1,11 @@
-module ActiveSupport
-  if defined? ::BasicObject
-    # A class with no predefined methods that behaves similarly to Builder's
-    # BlankSlate. Used for proxy classes.
-    class BasicObject < ::BasicObject
-      undef_method :==
-      undef_method :equal?
+require 'active_support/deprecation'
+require 'active_support/proxy_object'
 
-      # Let ActiveSupport::BasicObject at least raise exceptions.
-      def raise(*args)
-        ::Object.send(:raise, *args)
-      end
-    end
-  else
-    class BasicObject #:nodoc:
-      instance_methods.each do |m|
-        undef_method(m) if m.to_s !~ /(?:^__|^nil\?$|^send$|^object_id$)/
-      end
+module ActiveSupport
+  class BasicObject < ProxyObject # :nodoc:
+    def self.inherited(*)
+      ::ActiveSupport::Deprecation.warn 'ActiveSupport::BasicObject is deprecated! Use ActiveSupport::ProxyObject instead.'
+      super
     end
   end
 end

data/lib/active_support/benchmarkable.rb

@@ -3,30 +3,33 @@ require 'active_support/core_ext/hash/keys'
 
 module ActiveSupport
   module Benchmarkable
-    # Allows you to measure the execution time of a block in a template and records the result to
-    # the log. Wrap this block around expensive operations or possible bottlenecks to get a time
-    # reading for the operation. For example, let's say you thought your file processing method
-    # was taking too long; you could wrap it in a benchmark block.
+    # Allows you to measure the execution time of a block in a template and
+    # records the result to the log. Wrap this block around expensive operations
+    # or possible bottlenecks to get a time reading for the operation. For
+    # example, let's say you thought your file processing method was taking too
+    # long; you could wrap it in a benchmark block.
     #
-    #  <% benchmark "Process data files" do %>
+    #  <% benchmark 'Process data files' do %>
     #    <%= expensive_files_operation %>
     #  <% end %>
     #
-    # That would add something like "Process data files (345.2ms)" to the log, which you can then
-    # use to compare timings when optimizing your code.
+    # That would add something like "Process data files (345.2ms)" to the log,
+    # which you can then use to compare timings when optimizing your code.
     #
-    # You may give an optional logger level (:debug, :info, :warn, :error) as the :level option.
-    # The default logger level value is :info.
+    # You may give an optional logger level (<tt>:debug</tt>, <tt>:info</tt>,
+    # <tt>:warn</tt>, <tt>:error</tt>) as the <tt>:level</tt> option. The
+    # default logger level value is <tt>:info</tt>.
     #
-    #  <% benchmark "Low-level files", :level => :debug do %>
+    #  <% benchmark 'Low-level files', level: :debug do %>
     #    <%= lowlevel_files_operation %>
     #  <% end %>
     #
-    # Finally, you can pass true as the third argument to silence all log activity (other than the
-    # timing information) from inside the block. This is great for boiling down a noisy block to 
-    # just a single statement that produces one log line:
+    # Finally, you can pass true as the third argument to silence all log
+    # activity (other than the timing information) from inside the block. This
+    # is great for boiling down a noisy block to just a single statement that
+    # produces one log line:
     #
-    #  <% benchmark "Process data files", :level => :info, :silence => true do %>
+    #  <% benchmark 'Process data files', level: :info, silence: true do %>
     #    <%= expensive_and_chatty_files_operation %>
     #  <% end %>
     def benchmark(message = "Benchmarking", options = {})
@@ -44,8 +47,9 @@ module ActiveSupport
     end
 
     # Silence the logger during the execution of the block.
-    #
     def silence
+      message = "ActiveSupport::Benchmarkable#silence is deprecated. It will be removed from Rails 4.1."
+      ActiveSupport::Deprecation.warn message
       old_logger_level, logger.level = logger.level, ::Logger::ERROR if logger
       yield
     ensure

data/lib/active_support/buffered_logger.rb

@@ -1,125 +1,21 @@
-require 'thread'
-require 'logger'
-require 'active_support/core_ext/logger'
-require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/deprecation'
-require 'fileutils'
+require 'active_support/logger'
 
 module ActiveSupport
-  # Inspired by the buffered logger idea by Ezra
-  class BufferedLogger
-    module Severity
-      DEBUG   = 0
-      INFO    = 1
-      WARN    = 2
-      ERROR   = 3
-      FATAL   = 4
-      UNKNOWN = 5
-    end
-    include Severity
-
-    MAX_BUFFER_SIZE = 1000
-
-    ##
-    # :singleton-method:
-    # Set to false to disable the silencer
-    cattr_accessor :silencer
-    self.silencer = true
-
-    # Silences the logger for the duration of the block.
-    def silence(temporary_level = ERROR)
-      if silencer
-        begin
-          logger = self.class.new @log_dest.dup, temporary_level
-          yield logger
-        ensure
-          logger.close
-        end
-      else
-        yield self
-      end
-    end
-    deprecate :silence
-
-    attr_reader :auto_flushing
-    deprecate :auto_flushing
-
-    def initialize(log, level = DEBUG)
-      @log_dest      = log
-
-      unless log.respond_to?(:write)
-        unless File.exist?(File.dirname(log))
-          ActiveSupport::Deprecation.warn(<<-eowarn)
-Automatic directory creation for '#{log}' is deprecated.  Please make sure the directory for your log file exists before creating the logger.
-          eowarn
-          FileUtils.mkdir_p(File.dirname(log))
-        end
-      end
-
-      @log = open_logfile log
-      self.level = level
-    end
-
-    def open_log(log, mode)
-      open(log, mode).tap do |open_log|
-        open_log.set_encoding(Encoding::BINARY) if open_log.respond_to?(:set_encoding)
-        open_log.sync = true
-      end
-    end
-    deprecate :open_log
-
-    def level
-      @log.level
-    end
-
-    def level=(l)
-      @log.level = l
-    end
+  class BufferedLogger < Logger
 
-    def add(severity, message = nil, progname = nil, &block)
-      @log.add(severity, message, progname, &block)
-    end
-
-    # Dynamically add methods such as:
-    # def info
-    # def warn
-    # def debug
-    Severity.constants.each do |severity|
-      class_eval <<-EOT, __FILE__, __LINE__ + 1
-        def #{severity.downcase}(message = nil, progname = nil, &block) # def debug(message = nil, progname = nil, &block)
-          add(#{severity}, message, progname, &block)                   #   add(DEBUG, message, progname, &block)
-        end                                                             # end
-
-        def #{severity.downcase}?                                       # def debug?
-          #{severity} >= level                                         #   DEBUG >= level
-        end                                                             # end
-      EOT
-    end
-
-    # Set the auto-flush period. Set to true to flush after every log message,
-    # to an integer to flush every N messages, or to false, nil, or zero to
-    # never auto-flush. If you turn auto-flushing off, be sure to regularly
-    # flush the log yourself -- it will eat up memory until you do.
-    def auto_flushing=(period)
-    end
-    deprecate :auto_flushing=
-
-    def flush
-    end
-    deprecate :flush
-
-    def respond_to?(method, include_private = false)
-      return false if method.to_s == "flush"
+    def initialize(*args)
+      self.class._deprecation_warning
       super
     end
 
-    def close
-      @log.close
+    def self.inherited(*)
+      _deprecation_warning
+      super
     end
 
-    private
-    def open_logfile(log)
-      Logger.new log
+    def self._deprecation_warning
+      ::ActiveSupport::Deprecation.warn 'ActiveSupport::BufferedLogger is deprecated! Use ActiveSupport::Logger instead.'
     end
   end
 end

data/lib/active_support/cache/file_store.rb

@@ -1,7 +1,7 @@
+require 'active_support/core_ext/marshal'
 require 'active_support/core_ext/file/atomic'
 require 'active_support/core_ext/string/conversions'
-require 'active_support/core_ext/object/inclusion'
-require 'rack/utils'
+require 'uri/common'
 
 module ActiveSupport
   module Cache
@@ -13,7 +13,7 @@ module ActiveSupport
       attr_reader :cache_path
 
       DIR_FORMATTER = "%03X"
-      FILENAME_MAX_SIZE = 230 # max filename size on file system is 255, minus room for timestamp and random characters appended by Tempfile (used by atomic write)
+      FILENAME_MAX_SIZE = 228 # max filename size on file system is 255, minus room for timestamp and random characters appended by Tempfile (used by atomic write)
       EXCLUDED_DIRS = ['.', '..'].freeze
 
       def initialize(cache_path, options = nil)
@@ -23,14 +23,13 @@ module ActiveSupport
       end
 
       def clear(options = nil)
-        root_dirs = Dir.entries(cache_path).reject{|f| f.in?(EXCLUDED_DIRS)}
+        root_dirs = Dir.entries(cache_path).reject {|f| (EXCLUDED_DIRS + [".gitkeep"]).include?(f)}
         FileUtils.rm_r(root_dirs.collect{|f| File.join(cache_path, f)})
       end
 
       def cleanup(options = nil)
         options = merged_options(options)
-        search_dir(cache_path) do |fname|
-          key = file_path_key(fname)
+        each_key(options) do |key|
           entry = read_entry(key, options)
           delete_entry(key, options) if entry && entry.expired?
         end
@@ -82,7 +81,8 @@ module ActiveSupport
           if File.exist?(file_name)
             File.open(file_name) { |f| Marshal.load(f) }
           end
-        rescue
+        rescue => e
+          logger.error("FileStoreError (#{e}): #{e.message}") if logger
           nil
         end
 
@@ -127,7 +127,7 @@ module ActiveSupport
 
         # Translate a key into a file path.
         def key_file_path(key)
-          fname = Rack::Utils.escape(key)
+          fname = URI.encode_www_form_component(key)
           hash = Zlib.adler32(fname)
           hash, dir_1 = hash.divmod(0x1000)
           dir_2 = hash.modulo(0x1000)
@@ -144,15 +144,15 @@ module ActiveSupport
 
         # Translate a file path into a key.
         def file_path_key(path)
-          fname = path[cache_path.size, path.size].split(File::SEPARATOR, 4).last
-          Rack::Utils.unescape(fname)
+          fname = path[cache_path.to_s.size..-1].split(File::SEPARATOR, 4).last
+          URI.decode_www_form_component(fname, Encoding::UTF_8)
         end
 
         # Delete empty directories in the cache.
         def delete_empty_directories(dir)
-          return if dir == cache_path
-          if Dir.entries(dir).reject{|f| f.in?(EXCLUDED_DIRS)}.empty?
-            File.delete(dir) rescue nil
+          return if File.realpath(dir) == File.realpath(cache_path)
+          if Dir.entries(dir).reject {|f| EXCLUDED_DIRS.include?(f)}.empty?
+            Dir.delete(dir) rescue nil
             delete_empty_directories(File.dirname(dir))
           end
         end
@@ -165,7 +165,7 @@ module ActiveSupport
         def search_dir(dir, &callback)
           return if !File.exist?(dir)
           Dir.foreach(dir) do |d|
-            next if d.in?(EXCLUDED_DIRS)
+            next if EXCLUDED_DIRS.include?(d)
             name = File.join(dir, d)
             if File.directory?(name)
               search_dir(name, &callback)

data/lib/active_support/cache/mem_cache_store.rb

@@ -1,12 +1,13 @@
 begin
-  require 'memcache'
+  require 'dalli'
 rescue LoadError => e
-  $stderr.puts "You don't have memcache-client installed in your application. Please add it to your Gemfile and run bundle install"
+  $stderr.puts "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
   raise e
 end
 
 require 'digest/md5'
-require 'active_support/core_ext/string/encoding'
+require 'active_support/core_ext/marshal'
+require 'active_support/core_ext/array/extract_options'
 
 module ActiveSupport
   module Cache
@@ -23,21 +24,13 @@ module ActiveSupport
     # MemCacheStore implements the Strategy::LocalCache strategy which implements
     # an in-memory cache inside of a block.
     class MemCacheStore < Store
-      module Response # :nodoc:
-        STORED      = "STORED\r\n"
-        NOT_STORED  = "NOT_STORED\r\n"
-        EXISTS      = "EXISTS\r\n"
-        NOT_FOUND   = "NOT_FOUND\r\n"
-        DELETED     = "DELETED\r\n"
-      end
-
       ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
 
       def self.build_mem_cache(*addresses)
         addresses = addresses.flatten
         options = addresses.extract_options!
         addresses = ["localhost:11211"] if addresses.empty?
-        MemCache.new(addresses, options)
+        Dalli::Client.new(addresses, options)
       end
 
       # Creates a new MemCacheStore object, with the given memcached server
@@ -91,11 +84,11 @@ module ActiveSupport
       # to zero.
       def increment(name, amount = 1, options = nil) # :nodoc:
         options = merged_options(options)
-        response = instrument(:increment, name, :amount => amount) do
+        instrument(:increment, name, :amount => amount) do
           @data.incr(escape_key(namespaced_key(name, options)), amount)
         end
-        response == Response::NOT_FOUND ? nil : response.to_i
-      rescue MemCache::MemCacheError
+      rescue Dalli::DalliError
+        logger.error("DalliError (#{e}): #{e.message}") if logger
         nil
       end
 
@@ -105,11 +98,11 @@ module ActiveSupport
       # to zero.
       def decrement(name, amount = 1, options = nil) # :nodoc:
         options = merged_options(options)
-        response = instrument(:decrement, name, :amount => amount) do
+        instrument(:decrement, name, :amount => amount) do
           @data.decr(escape_key(namespaced_key(name, options)), amount)
         end
-        response == Response::NOT_FOUND ? nil : response.to_i
-      rescue MemCache::MemCacheError
+      rescue Dalli::DalliError
+        logger.error("DalliError (#{e}): #{e.message}") if logger
         nil
       end
 
@@ -117,6 +110,9 @@ module ActiveSupport
       # be used with care when shared cache is being used.
       def clear(options = nil)
         @data.flush_all
+      rescue Dalli::DalliError => e
+        logger.error("DalliError (#{e}): #{e.message}") if logger
+        nil
       end
 
       # Get the statistics from the memcached servers.
@@ -127,9 +123,9 @@ module ActiveSupport
       protected
         # Read an entry from the cache.
         def read_entry(key, options) # :nodoc:
-          deserialize_entry(@data.get(escape_key(key), true))
-        rescue MemCache::MemCacheError => e
-          logger.error("MemCacheError (#{e}): #{e.message}") if logger
+          deserialize_entry(@data.get(escape_key(key), options))
+        rescue Dalli::DalliError => e
+          logger.error("DalliError (#{e}): #{e.message}") if logger
           nil
         end
 
@@ -142,19 +138,17 @@ module ActiveSupport
             # Set the memcache expire a few minutes in the future to support race condition ttls on read
             expires_in += 5.minutes
           end
-          response = @data.send(method, escape_key(key), value, expires_in, options[:raw])
-          response == Response::STORED
-        rescue MemCache::MemCacheError => e
-          logger.error("MemCacheError (#{e}): #{e.message}") if logger
+          @data.send(method, escape_key(key), value, expires_in, options)
+        rescue Dalli::DalliError => e
+          logger.error("DalliError (#{e}): #{e.message}") if logger
           false
         end
 
         # Delete an entry from the cache.
         def delete_entry(key, options) # :nodoc:
-          response = @data.delete(escape_key(key))
-          response == Response::DELETED
-        rescue MemCache::MemCacheError => e
-          logger.error("MemCacheError (#{e}): #{e.message}") if logger
+          @data.delete(escape_key(key))
+        rescue Dalli::DalliError => e
+          logger.error("DalliError (#{e}): #{e.message}") if logger
           false
         end
 
@@ -165,7 +159,7 @@ module ActiveSupport
         # characters properly.
         def escape_key(key)
           key = key.to_s.dup
-          key = key.force_encoding("BINARY") if key.encoding_aware?
+          key = key.force_encoding(Encoding::ASCII_8BIT)
           key = key.gsub(ESCAPE_KEY_CHARS){ |match| "%#{match.getbyte(0).to_s(16).upcase}" }
           key = "#{key[0, 213]}:md5:#{Digest::MD5.hexdigest(key)}" if key.size > 250
           key

data/lib/active_support/cache/memory_store.rb

@@ -135,8 +135,10 @@ module ActiveSupport
         end
 
         def write_entry(key, entry, options) # :nodoc:
+          entry.dup_value!
           synchronize do
             old_entry = @data[key]
+            return false if @data.key?(key) && options[:unless_exist]
             @cache_size -= old_entry.size if old_entry
             @cache_size += entry.size
             @key_access[key] = Time.now.to_f