activesupport 5.2.6 → 6.0.0

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2005-2018 David Heinemeier Hansson
+Copyright (c) 2005-2019 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -5,6 +5,7 @@ extensions that were found useful for the Rails framework. These additions
 reside in this package so they can be loaded as needed in Ruby projects
 outside of Rails.
 
+You can read more about the extensions in the {Active Support Core Extensions}[https://edgeguides.rubyonrails.org/active_support_core_extensions.html] guide.
 
 == Download and installation
 
@@ -14,7 +15,7 @@ The latest version of Active Support can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/5-2-stable/activesupport
+* https://github.com/rails/rails/tree/master/activesupport
 
 
 == License
@@ -28,7 +29,7 @@ Active Support is released under the MIT license:
 
 API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
 Bug reports for the Ruby on Rails project can be filed here:
 

data/lib/active_support/actionable_error.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Actionable errors let's you define actions to resolve an error.
+  #
+  # To make an error actionable, include the <tt>ActiveSupport::ActionableError</tt>
+  # module and invoke the +action+ class macro to define the action. An action
+  # needs a name and a block to execute.
+  module ActionableError
+    extend Concern
+
+    class NonActionable < StandardError; end
+
+    included do
+      class_attribute :_actions, default: {}
+    end
+
+    def self.actions(error) # :nodoc:
+      case error
+      when ActionableError, -> it { Class === it && it < ActionableError }
+        error._actions
+      else
+        {}
+      end
+    end
+
+    def self.dispatch(error, name) # :nodoc:
+      actions(error).fetch(name).call
+    rescue KeyError
+      raise NonActionable, "Cannot find action \"#{name}\""
+    end
+
+    module ClassMethods
+      # Defines an action that can resolve the error.
+      #
+      #   class PendingMigrationError < MigrationError
+      #     include ActiveSupport::ActionableError
+      #
+      #     action "Run pending migrations" do
+      #       ActiveRecord::Tasks::DatabaseTasks.migrate
+      #     end
+      #   end
+      def action(name, &block)
+        _actions[name] = block
+      end
+    end
+  end
+end

data/lib/active_support/backtrace_cleaner.rb

@@ -31,6 +31,9 @@ module ActiveSupport
   class BacktraceCleaner
     def initialize
       @filters, @silencers = [], []
+      add_gem_filter
+      add_gem_silencer
+      add_stdlib_silencer
     end
 
     # Returns the backtrace after all filters and silencers have been run
@@ -82,6 +85,26 @@ module ActiveSupport
     end
 
     private
+
+      FORMATTED_GEMS_PATTERN = /\A[^\/]+ \([\w.]+\) /
+
+      def add_gem_filter
+        gems_paths = (Gem.path | [Gem.default_dir]).map { |p| Regexp.escape(p) }
+        return if gems_paths.empty?
+
+        gems_regexp = %r{(#{gems_paths.join('|')})/(bundler/)?gems/([^/]+)-([\w.]+)/(.*)}
+        gems_result = '\3 (\4) \5'
+        add_filter { |line| line.sub(gems_regexp, gems_result) }
+      end
+
+      def add_gem_silencer
+        add_silencer { |line| FORMATTED_GEMS_PATTERN.match?(line) }
+      end
+
+      def add_stdlib_silencer
+        add_silencer { |line| line.start_with?(RbConfig::CONFIG["rubylibdir"]) }
+      end
+
       def filter_backtrace(backtrace)
         @filters.each do |f|
           backtrace = backtrace.map { |line| f.call(line) }
@@ -99,7 +122,11 @@ module ActiveSupport
       end
 
       def noise(backtrace)
-        backtrace - silence(backtrace)
+        backtrace.select do |line|
+          @silencers.any? do |s|
+            s.call(line)
+          end
+        end
       end
   end
 end

data/lib/active_support/cache/file_store.rb

@@ -18,7 +18,6 @@ module ActiveSupport
       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)
@@ -26,11 +25,16 @@ module ActiveSupport
         @cache_path = cache_path.to_s
       end
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      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 = exclude_from(cache_path, EXCLUDED_DIRS + GITKEEP_FILES)
+        root_dirs = (Dir.children(cache_path) - GITKEEP_FILES)
         FileUtils.rm_r(root_dirs.collect { |f| File.join(cache_path, f) })
       rescue Errno::ENOENT
       end
@@ -103,12 +107,10 @@ module ActiveSupport
         def lock_file(file_name, &block)
           if File.exist?(file_name)
             File.open(file_name, "r+") do |f|
-              begin
-                f.flock File::LOCK_EX
-                yield
-              ensure
-                f.flock File::LOCK_UN
-              end
+              f.flock File::LOCK_EX
+              yield
+            ensure
+              f.flock File::LOCK_UN
             end
           else
             yield
@@ -127,15 +129,19 @@ module ActiveSupport
           hash = Zlib.adler32(fname)
           hash, dir_1 = hash.divmod(0x1000)
           dir_2 = hash.modulo(0x1000)
-          fname_paths = []
 
           # 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?
+          if fname.length < FILENAME_MAX_SIZE
+            fname_paths = fname
+          else
+            fname_paths = []
+            begin
+              fname_paths << fname[0, FILENAME_MAX_SIZE]
+              fname = fname[FILENAME_MAX_SIZE..-1]
+            end until fname.blank?
+          end
 
-          File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, *fname_paths)
+          File.join(cache_path, DIR_FORMATTER % dir_1, DIR_FORMATTER % dir_2, fname_paths)
         end
 
         # Translate a file path into a key.
@@ -147,7 +153,7 @@ module ActiveSupport
         # Delete empty directories in the cache.
         def delete_empty_directories(dir)
           return if File.realpath(dir) == File.realpath(cache_path)
-          if exclude_from(dir, EXCLUDED_DIRS).empty?
+          if Dir.children(dir).empty?
             Dir.delete(dir) rescue nil
             delete_empty_directories(File.dirname(dir))
           end
@@ -160,8 +166,7 @@ module ActiveSupport
 
         def search_dir(dir, &callback)
           return if !File.exist?(dir)
-          Dir.foreach(dir) do |d|
-            next if EXCLUDED_DIRS.include?(d)
+          Dir.each_child(dir) do |d|
             name = File.join(dir, d)
             if File.directory?(name)
               search_dir(name, &callback)
@@ -186,11 +191,6 @@ module ActiveSupport
             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

data/lib/active_support/cache/mem_cache_store.rb

@@ -28,6 +28,14 @@ module ActiveSupport
       # Provide support for raw values in the local cache strategy.
       module LocalCacheWithRaw # :nodoc:
         private
+          def read_entry(key, options)
+            entry = super
+            if options[:raw] && local_cache && entry
+              entry = deserialize_entry(entry.value)
+            end
+            entry
+          end
+
           def write_entry(key, entry, options)
             if options[:raw] && local_cache
               raw_entry = Entry.new(entry.value.to_s)
@@ -39,6 +47,11 @@ module ActiveSupport
           end
       end
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
       prepend Strategy::LocalCache
       prepend LocalCacheWithRaw
 
@@ -181,8 +194,9 @@ module ActiveSupport
           key
         end
 
-        def deserialize_entry(entry)
-          if entry
+        def deserialize_entry(raw_value)
+          if raw_value
+            entry = Marshal.load(raw_value) rescue raw_value
             entry.is_a?(Entry) ? entry : Entry.new(entry)
           end
         end

data/lib/active_support/cache/memory_store.rb

@@ -30,6 +30,11 @@ module ActiveSupport
         @pruning = false
       end
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
       # Delete all data stored in a given cache store.
       def clear(options = nil)
         synchronize do
@@ -57,13 +62,13 @@ module ActiveSupport
         return if pruning?
         @pruning = true
         begin
-          start_time = Time.now
+          start_time = Concurrent.monotonic_time
           cleanup
           instrument(:prune, target_size, from: @cache_size) do
             keys = synchronize { @key_access.keys.sort { |a, b| @key_access[a].to_f <=> @key_access[b].to_f } }
             keys.each do |key|
               delete_entry(key, options)
-              return if @cache_size <= target_size || (max_time && Time.now - start_time > max_time)
+              return if @cache_size <= target_size || (max_time && Concurrent.monotonic_time - start_time > max_time)
             end
           end
         ensure

data/lib/active_support/cache/null_store.rb

@@ -12,6 +12,11 @@ module ActiveSupport
     class NullStore < Store
       prepend Strategy::LocalCache
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
       def clear(options = nil)
       end
 

data/lib/active_support/cache/redis_cache_store.rb

@@ -17,7 +17,6 @@ end
 
 require "digest/sha2"
 require "active_support/core_ext/marshal"
-require "active_support/core_ext/hash/transform_values"
 
 module ActiveSupport
   module Cache
@@ -67,9 +66,22 @@ module ActiveSupport
       SCAN_BATCH_SIZE = 1000
       private_constant :SCAN_BATCH_SIZE
 
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        true
+      end
+
       # Support raw values in the local cache strategy.
       module LocalCacheWithRaw # :nodoc:
         private
+          def read_entry(key, options)
+            entry = super
+            if options[:raw] && local_cache && entry
+              entry = deserialize_entry(entry.value)
+            end
+            entry
+          end
+
           def write_entry(key, entry, options)
             if options[:raw] && local_cache
               raw_entry = Entry.new(serialize_entry(entry, raw: true))
@@ -140,15 +152,17 @@ module ActiveSupport
 
       # Creates a new Redis cache store.
       #
-      # Handles three options: block provided to instantiate, single URL
-      # provided, and multiple URLs provided.
+      # Handles four options: :redis block, :redis instance, single :url
+      # string, and multiple :url strings.
       #
-      #   :redis Proc   -> options[:redis].call
-      #   :url   String -> Redis.new(url: …)
-      #   :url   Array  -> Redis::Distributed.new([{ url: … }, { url: … }, …])
+      #   Option  Class       Result
+      #   :redis  Proc    ->  options[:redis].call
+      #   :redis  Object  ->  options[:redis]
+      #   :url    String  ->  Redis.new(url: …)
+      #   :url    Array   ->  Redis::Distributed.new([{ url: … }, { url: … }, …])
       #
       # No namespace is set by default. Provide one if the Redis cache
-      # server is shared with other apps: <tt>namespace: 'myapp-cache'<tt>.
+      # server is shared with other apps: <tt>namespace: 'myapp-cache'</tt>.
       #
       # Compression is enabled by default with a 1kB threshold, so cached
       # values larger than 1kB are automatically compressed. Disable by
@@ -251,7 +265,14 @@ module ActiveSupport
       def increment(name, amount = 1, options = nil)
         instrument :increment, name, amount: amount do
           failsafe :increment do
-            redis.with { |c| c.incrby normalize_key(name, options), amount }
+            options = merged_options(options)
+            key = normalize_key(name, options)
+
+            redis.with do |c|
+              c.incrby(key, amount).tap do
+                write_key_expiry(c, key, options)
+              end
+            end
           end
         end
       end
@@ -267,7 +288,14 @@ module ActiveSupport
       def decrement(name, amount = 1, options = nil)
         instrument :decrement, name, amount: amount do
           failsafe :decrement do
-            redis.with { |c| c.decrby normalize_key(name, options), amount }
+            options = merged_options(options)
+            key = normalize_key(name, options)
+
+            redis.with do |c|
+              c.decrby(key, amount).tap do
+                write_key_expiry(c, key, options)
+              end
+            end
           end
         end
       end
@@ -320,8 +348,7 @@ module ActiveSupport
         # Read an entry from the cache.
         def read_entry(key, options = nil)
           failsafe :read_entry do
-            raw = options && options.fetch(:raw, false)
-            deserialize_entry(redis.with { |c| c.get(key) }, raw: raw)
+            deserialize_entry redis.with { |c| c.get(key) }
           end
         end
 
@@ -336,7 +363,7 @@ module ActiveSupport
         def read_multi_mget(*names)
           options = names.extract_options!
           options = merged_options(options)
-          raw = options && options.fetch(:raw, false)
+          return {} if names == []
 
           keys = names.map { |name| normalize_key(name, options) }
 
@@ -346,7 +373,7 @@ module ActiveSupport
 
           names.zip(values).each_with_object({}) do |(name, value), results|
             if value
-              entry = deserialize_entry(value, raw: raw)
+              entry = deserialize_entry(value)
               unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(name, options))
                 results[name] = entry.value
               end
@@ -380,6 +407,12 @@ module ActiveSupport
           end
         end
 
+        def write_key_expiry(client, key, options)
+          if options[:expires_in] && client.ttl(key).negative?
+            client.expire key, options[:expires_in].to_i
+          end
+        end
+
         # Delete an entry from the cache.
         def delete_entry(key, options)
           failsafe :delete_entry, returning: false do
@@ -415,20 +448,9 @@ module ActiveSupport
           end
         end
 
-        def deserialize_entry(serialized_entry, raw:)
+        def deserialize_entry(serialized_entry)
           if serialized_entry
             entry = Marshal.load(serialized_entry) rescue serialized_entry
-
-            written_raw = serialized_entry.equal?(entry)
-            if raw != written_raw
-              ActiveSupport::Deprecation.warn(<<-MSG.squish)
-                Using a different value for the raw option when reading and writing
-                to a cache key is deprecated for :redis_cache_store and Rails 6.0
-                will stop automatically detecting the format when reading to avoid
-                marshal loading untrusted raw strings.
-              MSG
-            end
-
             entry.is_a?(Entry) ? entry : Entry.new(entry)
           end
         end

data/lib/active_support/cache.rb

@@ -229,6 +229,14 @@ module ActiveSupport
       # ask whether you should force a cache write. Otherwise, it's clearer to
       # just call <tt>Cache#write</tt>.
       #
+      # Setting <tt>skip_nil: true</tt> will not cache nil result:
+      #
+      #   cache.fetch('foo') { nil }
+      #   cache.fetch('bar', skip_nil: true) { nil }
+      #   cache.exist?('foo') # => true
+      #   cache.exist?('bar') # => false
+      #
+      #
       # Setting <tt>compress: false</tt> disables compression of the cache entry.
       #
       # Setting <tt>:expires_in</tt> will set an expiration time on the cache.
@@ -333,8 +341,9 @@ module ActiveSupport
       # the cache with the given key, then that data is returned. Otherwise,
       # +nil+ is returned.
       #
-      # Note, if data was written with the <tt>:expires_in<tt> or <tt>:version</tt> options,
-      # both of these conditions are applied before the data is returned.
+      # Note, if data was written with the <tt>:expires_in</tt> or
+      # <tt>:version</tt> options, both of these conditions are applied before
+      # the data is returned.
       #
       # Options are passed to the underlying cache implementation.
       def read(name, options = nil)
@@ -402,8 +411,6 @@ module ActiveSupport
       # to the cache. If you do not want to write the cache when the cache is
       # not found, use #read_multi.
       #
-      # Options are passed to the underlying cache implementation.
-      #
       # Returns a hash with the data for each of the names. For example:
       #
       #   cache.write("bim", "bam")
@@ -413,6 +420,17 @@ module ActiveSupport
       #   # => { "bim" => "bam",
       #   #      "unknown_key" => "Fallback value for key: unknown_key" }
       #
+      # Options are passed to the underlying cache implementation. For example:
+      #
+      #   cache.fetch_multi("fizz", expires_in: 5.seconds) do |key|
+      #     "buzz"
+      #   end
+      #   # => {"fizz"=>"buzz"}
+      #   cache.read("fizz")
+      #   # => "buzz"
+      #   sleep(6)
+      #   cache.read("fizz")
+      #   # => nil
       def fetch_multi(*names)
         raise ArgumentError, "Missing block: `Cache#fetch_multi` requires a block." unless block_given?
 
@@ -420,18 +438,18 @@ module ActiveSupport
         options = merged_options(options)
 
         instrument :read_multi, names, options do |payload|
-          read_multi_entries(names, options).tap do |results|
-            payload[:hits] = results.keys
-            payload[:super_operation] = :fetch_multi
+          reads   = read_multi_entries(names, options)
+          writes  = {}
+          ordered = names.each_with_object({}) do |name, hash|
+            hash[name] = reads.fetch(name) { writes[name] = yield(name) }
+          end
 
-            writes = {}
+          payload[:hits] = reads.keys
+          payload[:super_operation] = :fetch_multi
 
-            (names - results.keys).each do |name|
-              results[name] = writes[name] = yield(name)
-            end
+          write_multi(writes, options)
 
-            write_multi writes, options
-          end
+          ordered
         end
       end
 
@@ -474,7 +492,7 @@ module ActiveSupport
       #
       # Options are passed to the underlying cache implementation.
       #
-      # All implementations may not support this method.
+      # Some implementations may not support this method.
       def delete_matched(matcher, options = nil)
         raise NotImplementedError.new("#{self.class.name} does not support delete_matched")
       end
@@ -483,7 +501,7 @@ module ActiveSupport
       #
       # Options are passed to the underlying cache implementation.
       #
-      # All implementations may not support this method.
+      # Some implementations may not support this method.
       def increment(name, amount = 1, options = nil)
         raise NotImplementedError.new("#{self.class.name} does not support increment")
       end
@@ -492,7 +510,7 @@ module ActiveSupport
       #
       # Options are passed to the underlying cache implementation.
       #
-      # All implementations may not support this method.
+      # Some implementations may not support this method.
       def decrement(name, amount = 1, options = nil)
         raise NotImplementedError.new("#{self.class.name} does not support decrement")
       end
@@ -501,7 +519,7 @@ module ActiveSupport
       #
       # Options are passed to the underlying cache implementation.
       #
-      # All implementations may not support this method.
+      # Some implementations may not support this method.
       def cleanup(options = nil)
         raise NotImplementedError.new("#{self.class.name} does not support cleanup")
       end
@@ -511,7 +529,7 @@ module ActiveSupport
       #
       # The options hash is passed to the underlying cache implementation.
       #
-      # All implementations may not support this method.
+      # Some implementations may not support this method.
       def clear(options = nil)
         raise NotImplementedError.new("#{self.class.name} does not support clear")
       end
@@ -587,9 +605,13 @@ module ActiveSupport
         # Merges the default options with ones specific to a method call.
         def merged_options(call_options)
           if call_options
-            options.merge(call_options)
+            if options.empty?
+              call_options
+            else
+              options.merge(call_options)
+            end
           else
-            options.dup
+            options
           end
         end
 
@@ -634,7 +656,7 @@ module ActiveSupport
             if key.size > 1
               key = key.collect { |element| expanded_key(element) }
             else
-              key = key.first
+              key = expanded_key(key.first)
             end
           when Hash
             key = key.sort_by { |k, _| k.to_s }.collect { |k, v| "#{k}=#{v}" }
@@ -685,7 +707,7 @@ module ActiveSupport
         end
 
         def get_entry_value(entry, name, options)
-          instrument(:fetch_hit, name, options) {}
+          instrument(:fetch_hit, name, options) { }
           entry.value
         end
 
@@ -694,7 +716,7 @@ module ActiveSupport
             yield(name)
           end
 
-          write(name, result, options)
+          write(name, result, options) unless result.nil? && options[:skip_nil]
           result
         end
     end

data/lib/active_support/callbacks.rb

@@ -23,6 +23,9 @@ module ActiveSupport
   # +ClassMethods.set_callback+), and run the installed callbacks at the
   # appropriate times (via +run_callbacks+).
   #
+  # By default callbacks are halted by throwing +:abort+.
+  # See +ClassMethods.define_callbacks+ for details.
+  #
   # Three kinds of callbacks are supported: before callbacks, run before a
   # certain event; after callbacks, run after the event; and around callbacks,
   # blocks that surround the event, triggering it when they yield. Callback code
@@ -497,9 +500,7 @@ module ActiveSupport
           arg.halted || !@user_conditions.all? { |c| c.call(arg.target, arg.value) }
         end
 
-        def nested
-          @nested
-        end
+        attr_reader :nested
 
         def final?
           !@call_template
@@ -578,7 +579,7 @@ module ActiveSupport
         end
 
         protected
-          def chain; @chain; end
+          attr_reader :chain
 
         private
 
@@ -659,9 +660,17 @@ module ActiveSupport
         # * <tt>:if</tt> - A symbol or an array of symbols, each naming an instance
         #   method or a proc; the callback will be called only when they all return
         #   a true value.
+        #
+        #   If a proc is given, its body is evaluated in the context of the
+        #   current object. It can also optionally accept the current object as
+        #   an argument.
         # * <tt>:unless</tt> - A symbol or an array of symbols, each naming an
         #   instance method or a proc; the callback will be called only when they
         #   all return a false value.
+        #
+        #   If a proc is given, its body is evaluated in the context of the
+        #   current object. It can also optionally accept the current object as
+        #   an argument.
         # * <tt>:prepend</tt> - If +true+, the callback will be prepended to the
         #   existing chain rather than appended.
         def set_callback(name, *filter_list, &block)
@@ -809,7 +818,9 @@ module ActiveSupport
           names.each do |name|
             name = name.to_sym
 
-            set_callbacks name, CallbackChain.new(name, options)
+            ([self] + ActiveSupport::DescendantsTracker.descendants(self)).each do |target|
+              target.set_callbacks name, CallbackChain.new(name, options)
+            end
 
             module_eval <<-RUBY, __FILE__, __LINE__ + 1
               def _run_#{name}_callbacks(&block)