activesupport 3.1.0 → 5.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2005-2016 David Heinemeier Hansson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -8,26 +8,32 @@ outside of Rails.
 
 == Download and installation
 
-The latest version of Active Support can be installed with Rubygems:
+The latest version of Active Support can be installed with RubyGems:
 
-  % [sudo] gem install activesupport
+  $ 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/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.com
+* http://api.rubyonrails.org
 
-Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:
+Bug reports can be filed for the Ruby on Rails project here:
 
 * https://github.com/rails/rails/issues
+
+Feature requests should be discussed on the rails-core mailing list here:
+
+* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core

data/lib/active_support/array_inquirer.rb

@@ -0,0 +1,44 @@
+module ActiveSupport
+  # Wrapping an array in an +ArrayInquirer+ gives a friendlier way to check
+  # its string-like contents:
+  #
+  #   variants = ActiveSupport::ArrayInquirer.new([:phone, :tablet])
+  #
+  #   variants.phone?    # => true
+  #   variants.tablet?   # => true
+  #   variants.desktop?  # => false
+  class ArrayInquirer < Array
+    # Passes each element of +candidates+ collection to ArrayInquirer collection.
+    # The method returns true if at least one element is the same. If +candidates+
+    # collection is not given, method returns true.
+    #
+    #   variants = ActiveSupport::ArrayInquirer.new([:phone, :tablet])
+    #
+    #   variants.any?                      # => true
+    #   variants.any?(:phone, :tablet)     # => true
+    #   variants.any?('phone', 'desktop')  # => true
+    #   variants.any?(:desktop, :watch)    # => false
+    def any?(*candidates, &block)
+      if candidates.none?
+        super
+      else
+        candidates.any? do |candidate|
+          include?(candidate.to_sym) || include?(candidate.to_s)
+        end
+      end
+    end
+
+    private
+      def respond_to_missing?(name, include_private = false)
+        name[-1] == '?'
+      end
+
+      def method_missing(name, *args)
+        if name[-1] == '?'
+          any?(name[0..-2])
+        else
+          super
+        end
+      end
+  end
+end

data/lib/active_support/backtrace_cleaner.rb

@@ -1,34 +1,40 @@
 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
+  #   bc.add_filter   { |line| line.gsub(Rails.root.to_s, '') } # strip the Rails.root prefix
+  #   bc.add_silencer { |line| line =~ /mongrel|rubygems/ } # skip any lines from mongrel or rubygems
+  #   bc.clean(exception.backtrace) # perform the cleanup
   #
-  # 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 <tt>BacktraceCleaner#remove_filters!</tt>
+  # These two methods will give you a completely untouched backtrace.
   #
-  # Inspired by the Quiet Backtrace gem by Thoughtbot.
+  # Inspired by the Quiet Backtrace gem by thoughtbot.
   class BacktraceCleaner
     def initialize
       @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.
+    # Removes all silencers, but leaves in the filters. 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 the 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
@@ -89,11 +97,7 @@ module ActiveSupport
       end
 
       def noise(backtrace)
-        @silencers.each do |s|
-          backtrace = backtrace.select { |line| s.call(line) }
-        end
-
-        backtrace
+        backtrace - silence(backtrace)
       end
   end
 end

data/lib/active_support/benchmarkable.rb

@@ -3,41 +3,39 @@ 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.
     #
-    # You may give an optional logger level as the :level option.
-    # (:debug, :info, :warn, :error); the default 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
-    # inside the block. This is great for boiling down a noisy block to just a single statement:
+    # 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 = {})
       if logger
-        if options.is_a?(Symbol)
-          ActiveSupport::Deprecation.warn("use benchmark('#{message}', :level => :#{options}) instead", caller)
-          options = { :level => options, :silence => false }
-        else
-          options.assert_valid_keys(:level, :silence)
-          options[:level] ||= :info
-        end
+        options.assert_valid_keys(:level, :silence)
+        options[:level] ||= :info
 
         result = nil
         ms = Benchmark.ms { result = options[:silence] ? logger.silence { yield } : yield }
@@ -47,14 +45,5 @@ module ActiveSupport
         yield
       end
     end
-
-    # Silence the logger during the execution of the block.
-    #
-    def silence
-      old_logger_level, logger.level = logger.level, ::Logger::ERROR if logger
-      yield
-    ensure
-      logger.level = old_logger_level if logger
-    end
   end
 end

data/lib/active_support/cache/file_store.rb

@@ -1,64 +1,58 @@
+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
     # A cache store implementation which stores everything on the filesystem.
     #
     # FileStore implements the Strategy::LocalCache strategy which implements
-    # an in memory cache inside of a block.
+    # an in-memory cache inside of a block.
     class FileStore < Store
+      prepend Strategy::LocalCache
       attr_reader :cache_path
 
       DIR_FORMATTER = "%03X"
+      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)
+      FILEPATH_MAX_SIZE = 900 # max is 1024, plus some room
+      EXCLUDED_DIRS = ['.', '..'].freeze
+      GITKEEP_FILES = ['.gitkeep', '.keep'].freeze
 
       def initialize(cache_path, options = nil)
         super(options)
         @cache_path = cache_path.to_s
-        extend Strategy::LocalCache
       end
 
+      # Deletes all items from the cache. In this case it deletes all the entries in the specified
+      # file store directory except for .keep or .gitkeep. Be careful which directory is specified in your
+      # config file when using +FileStore+ because everything in that directory will be deleted.
       def clear(options = nil)
-        root_dirs = Dir.entries(cache_path).reject{|f| f.in?(['.', '..'])}
+        root_dirs = exclude_from(cache_path, EXCLUDED_DIRS + GITKEEP_FILES)
         FileUtils.rm_r(root_dirs.collect{|f| File.join(cache_path, f)})
+      rescue Errno::ENOENT
       end
 
+      # Preemptively iterates through all stored keys and removes the ones which have expired.
       def cleanup(options = nil)
         options = merged_options(options)
-        each_key(options) do |key|
+        search_dir(cache_path) do |fname|
+          key = file_path_key(fname)
           entry = read_entry(key, options)
           delete_entry(key, options) if entry && entry.expired?
         end
       end
 
+      # Increments an already existing integer value that is stored in the cache.
+      # If the key is not found nothing is done.
       def increment(name, amount = 1, options = nil)
-        file_name = key_file_path(namespaced_key(name, options))
-        lock_file(file_name) do
-          options = merged_options(options)
-          if num = read(name, options)
-            num = num.to_i + amount
-            write(name, num, options)
-            num
-          else
-            nil
-          end
-        end
+        modify_value(name, amount, options)
       end
 
+      # Decrements an already existing integer value that is stored in the cache.
+      # If the key is not found nothing is done.
       def decrement(name, amount = 1, options = nil)
-        file_name = key_file_path(namespaced_key(name, options))
-        lock_file(file_name) do
-          options = merged_options(options)
-          if num = read(name, options)
-            num = num.to_i - amount
-            write(name, num, options)
-            num
-          else
-            nil
-          end
-        end
+        modify_value(name, -amount, options)
       end
 
       def delete_matched(matcher, options = nil)
@@ -67,7 +61,7 @@ module ActiveSupport
           matcher = key_matcher(matcher, options)
           search_dir(cache_path) do |path|
             key = file_path_key(path)
-            delete_entry(key, options) if key.match(matcher)
+            delete_entry(path, options) if key.match(matcher)
           end
         end
       end
@@ -75,43 +69,30 @@ module ActiveSupport
       protected
 
         def read_entry(key, options)
-          file_name = key_file_path(key)
-          if File.exist?(file_name)
-            entry = File.open(file_name) { |f| Marshal.load(f) }
-            if entry && !entry.expired? && !entry.expires_in && !self.options[:expires_in]
-              # Check for deprecated use of +:expires_in+ option from versions < 3.0
-              deprecated_expires_in = options[:expires_in]
-              if deprecated_expires_in
-                ActiveSupport::Deprecation.warn('Setting :expires_in on read has been deprecated in favor of setting it on write.', caller)
-                if entry.created_at + deprecated_expires_in.to_f <= Time.now.to_f
-                  delete_entry(key, options)
-                  entry = nil
-                end
-              end
-            end
-            entry
+          if File.exist?(key)
+            File.open(key) { |f| Marshal.load(f) }
           end
-        rescue
+        rescue => e
+          logger.error("FileStoreError (#{e}): #{e.message}") if logger
           nil
         end
 
         def write_entry(key, entry, options)
-          file_name = key_file_path(key)
-          ensure_cache_path(File.dirname(file_name))
-          File.atomic_write(file_name, cache_path) {|f| Marshal.dump(entry, f)}
+          return false if options[:unless_exist] && File.exist?(key)
+          ensure_cache_path(File.dirname(key))
+          File.atomic_write(key, cache_path) {|f| Marshal.dump(entry, f)}
           true
         end
 
         def delete_entry(key, options)
-          file_name = key_file_path(key)
-          if File.exist?(file_name)
+          if File.exist?(key)
             begin
-              File.delete(file_name)
-              delete_empty_directories(File.dirname(file_name))
+              File.delete(key)
+              delete_empty_directories(File.dirname(key))
               true
             rescue => e
               # Just in case the error was caused by another process deleting the file first.
-              raise e if File.exist?(file_name)
+              raise e if File.exist?(key)
               false
             end
           end
@@ -135,35 +116,47 @@ module ActiveSupport
         end
 
         # Translate a key into a file path.
-        def key_file_path(key)
-          fname = Rack::Utils.escape(key)
+        def normalize_key(key, options)
+          key = super
+          fname = URI.encode_www_form_component(key)
+
+          if fname.size > FILEPATH_MAX_SIZE
+            fname = Digest::MD5.hexdigest(key)
+          end
+
           hash = Zlib.adler32(fname)
           hash, dir_1 = hash.divmod(0x1000)
           dir_2 = hash.modulo(0x1000)
           fname_paths = []
-          # Make sure file name is < 255 characters so it doesn't exceed file system limits.
-          if fname.size <= 255
-            fname_paths << fname
-          else
-            while fname.size <= 255
-              fname_path << fname[0, 255]
-              fname = fname[255, -1]
-            end
-          end
+
+          # Make sure file name doesn't exceed file system limits.
+          begin
+            fname_paths << fname[0, FILENAME_MAX_SIZE]
+            fname = fname[FILENAME_MAX_SIZE..-1]
+          end until fname.blank?
+
           File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, *fname_paths)
         end
 
+        def key_file_path(key)
+          ActiveSupport::Deprecation.warn(<<-MESSAGE.strip_heredoc)
+            `key_file_path` is deprecated and will be removed from Rails 5.1.
+            Please use `normalize_key` which will return a fully resolved key or nothing.
+          MESSAGE
+          key
+        end
+
         # 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?(['.', '..'])}.empty?
-            File.delete(dir) rescue nil
+          return if File.realpath(dir) == File.realpath(cache_path)
+          if exclude_from(dir, EXCLUDED_DIRS).empty?
+            Dir.delete(dir) rescue nil
             delete_empty_directories(File.dirname(dir))
           end
         end
@@ -174,8 +167,9 @@ module ActiveSupport
         end
 
         def search_dir(dir, &callback)
+          return if !File.exist?(dir)
           Dir.foreach(dir) do |d|
-            next if d == "." || d == ".."
+            next if EXCLUDED_DIRS.include?(d)
             name = File.join(dir, d)
             if File.directory?(name)
               search_dir(name, &callback)
@@ -184,6 +178,27 @@ module ActiveSupport
             end
           end
         end
+
+        # Modifies the amount of an already existing integer value that is stored in the cache.
+        # If the key is not found nothing is done.
+        def modify_value(name, amount, options)
+          file_name = normalize_key(name, options)
+
+          lock_file(file_name) do
+            options = merged_options(options)
+
+            if num = read(name, options)
+              num = num.to_i + amount
+              write(name, num, options)
+              num
+            end
+          end
+        end
+
+        # Exclude entries from source directory
+        def exclude_from(source, excludes)
+          Dir.entries(source).reject { |f| excludes.include?(f) }
+        end
     end
   end
 end