activesupport 4.2.11.3 → 5.0.0.beta1

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2005-2014 David Heinemeier Hansson
+Copyright (c) 2005-2015 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

@@ -10,11 +10,11 @@ outside of Rails.
 
 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:
 
-* https://github.com/rails/rails/tree/4-2-stable/activesupport
+* https://github.com/rails/rails/tree/master/activesupport
 
 
 == License
@@ -37,4 +37,3 @@ Bug reports can be filed for the Ruby on Rails project here:
 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.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2005-2014 David Heinemeier Hansson
+# Copyright (c) 2005-2015 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -26,7 +26,6 @@ require "active_support/dependencies/autoload"
 require "active_support/version"
 require "active_support/logger"
 require "active_support/lazy_load_hooks"
-require "active_support/core_ext/date_and_time/compatibility"
 
 module ActiveSupport
   extend ActiveSupport::Autoload
@@ -35,6 +34,7 @@ module ActiveSupport
   autoload :Dependencies
   autoload :DescendantsTracker
   autoload :FileUpdateChecker
+  autoload :EventedFileUpdateChecker
   autoload :LogSubscriber
   autoload :Notifications
 
@@ -60,6 +60,7 @@ module ActiveSupport
     autoload :StringInquirer
     autoload :TaggedLogging
     autoload :XmlMini
+    autoload :ArrayInquirer
   end
 
   autoload :Rescuable
@@ -72,22 +73,14 @@ module ActiveSupport
     NumberHelper.eager_load!
   end
 
-  @@test_order = nil
+  cattr_accessor :test_order # :nodoc:
 
-  def self.test_order=(new_order) # :nodoc:
-    @@test_order = new_order
+  def self.halt_callback_chains_on_return_false
+    Callbacks.halt_and_display_warning_on_return_false
   end
 
-  def self.test_order # :nodoc:
-    @@test_order
-  end
-
-  def self.to_time_preserves_timezone
-    DateAndTime::Compatibility.preserve_timezone
-  end
-
-  def self.to_time_preserves_timezone=(value)
-    DateAndTime::Compatibility.preserve_timezone = value
+  def self.halt_callback_chains_on_return_false=(value)
+    Callbacks.halt_and_display_warning_on_return_false = value
   end
 end
 

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

@@ -25,7 +25,7 @@ module ActiveSupport
   # 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 = [], []

data/lib/active_support/cache.rb

@@ -8,7 +8,7 @@ require 'active_support/core_ext/numeric/bytes'
 require 'active_support/core_ext/numeric/time'
 require 'active_support/core_ext/object/to_param'
 require 'active_support/core_ext/string/inflections'
-require 'active_support/deprecation'
+require 'active_support/core_ext/string/strip'
 
 module ActiveSupport
   # See ActiveSupport::Cache::Store for documentation.
@@ -179,18 +179,6 @@ module ActiveSupport
         @silence = previous_silence
       end
 
-      # :deprecated:
-      def self.instrument=(boolean)
-        ActiveSupport::Deprecation.warn "ActiveSupport::Cache.instrument= is deprecated and will be removed in Rails 5. Instrumentation is now always on so you can safely stop using it."
-        true
-      end
-
-      # :deprecated:
-      def self.instrument
-        ActiveSupport::Deprecation.warn "ActiveSupport::Cache.instrument is deprecated and will be removed in Rails 5. Instrumentation is now always on so you can safely stop using it."
-        true
-      end
-
       # Fetches data from the cache, using the given key. If there is data in
       # the cache with the given key, then that data is returned.
       #
@@ -288,15 +276,20 @@ module ActiveSupport
       def fetch(name, options = nil)
         if block_given?
           options = merged_options(options)
-          key = namespaced_key(name, options)
+          key = normalize_key(name, options)
 
-          cached_entry = find_cached_entry(key, name, options) unless options[:force]
-          entry = handle_expired_entry(cached_entry, key, options)
+          instrument(:read, name, options) do |payload|
+            cached_entry = read_entry(key, options) unless options[:force]
+            payload[:super_operation] = :fetch if payload
+            entry = handle_expired_entry(cached_entry, key, options)
 
-          if entry
-            get_entry_value(entry, name, options)
-          else
-            save_block_result_to_cache(name, options) { |_name| yield _name }
+            if entry
+              payload[:hit] = true if payload
+              get_entry_value(entry, name, options)
+            else
+              payload[:hit] = false if payload
+              save_block_result_to_cache(name, options) { |_name| yield _name }
+            end
           end
         else
           read(name, options)
@@ -310,7 +303,7 @@ module ActiveSupport
       # Options are passed to the underlying cache implementation.
       def read(name, options = nil)
         options = merged_options(options)
-        key = namespaced_key(name, options)
+        key = normalize_key(name, options)
         instrument(:read, name, options) do |payload|
           entry = read_entry(key, options)
           if entry
@@ -338,19 +331,22 @@ module ActiveSupport
       def read_multi(*names)
         options = names.extract_options!
         options = merged_options(options)
-        results = {}
-        names.each do |name|
-          key = namespaced_key(name, options)
-          entry = read_entry(key, options)
-          if entry
-            if entry.expired?
-              delete_entry(key, options)
-            else
-              results[name] = entry.value
+
+        instrument_multi(:read, names, options) do |payload|
+          results = {}
+          names.each do |name|
+            key = normalize_key(name, options)
+            entry = read_entry(key, options)
+            if entry
+              if entry.expired?
+                delete_entry(key, options)
+              else
+                results[name] = entry.value
+              end
             end
           end
+          results
         end
-        results
       end
 
       # Fetches data from the cache, using the given keys. If there is data in
@@ -363,8 +359,11 @@ module ActiveSupport
       # Returns a hash with the data for each of the names. For example:
       #
       #   cache.write("bim", "bam")
-      #   cache.fetch_multi("bim", "boom") { |key| key * 2 }
-      #   # => { "bam" => "bam", "boom" => "boomboom" }
+      #   cache.fetch_multi("bim", "unknown_key") do |key|
+      #     "Fallback value for key: #{key}"
+      #   end
+      #   # => { "bim" => "bam",
+      #   #      "unknown_key" => "Fallback value for key: unknown_key" }
       #
       def fetch_multi(*names)
         options = names.extract_options!
@@ -388,7 +387,7 @@ module ActiveSupport
 
         instrument(:write, name, options) do
           entry = Entry.new(value, options)
-          write_entry(namespaced_key(name, options), entry, options)
+          write_entry(normalize_key(name, options), entry, options)
         end
       end
 
@@ -399,7 +398,7 @@ module ActiveSupport
         options = merged_options(options)
 
         instrument(:delete, name) do
-          delete_entry(namespaced_key(name, options), options)
+          delete_entry(normalize_key(name, options), options)
         end
       end
 
@@ -410,7 +409,7 @@ module ActiveSupport
         options = merged_options(options)
 
         instrument(:exist?, name) do
-          entry = read_entry(namespaced_key(name, options), options)
+          entry = read_entry(normalize_key(name, options), options)
           (entry && !entry.expired?) || false
         end
       end
@@ -531,7 +530,7 @@ module ActiveSupport
 
         # Prefix a key with the namespace. Namespace and key will be delimited
         # with a colon.
-        def namespaced_key(key, options)
+        def normalize_key(key, options)
           key = expanded_key(key)
           namespace = options[:namespace] if options
           prefix = namespace.is_a?(Proc) ? namespace.call : namespace
@@ -539,32 +538,44 @@ module ActiveSupport
           key
         end
 
+        def namespaced_key(*args)
+          ActiveSupport::Deprecation.warn(<<-MESSAGE.strip_heredoc)
+            `namespaced_key` is deprecated and will be removed from Rails 5.1.
+            Please use `normalize_key` which will return a fully resolved key.
+          MESSAGE
+          normalize_key(*args)
+        end
+
         def instrument(operation, key, options = nil)
-          log(operation, key, options)
+          log { "Cache #{operation}: #{normalize_key(key, options)}#{options.blank? ? "" : " (#{options.inspect})"}" }
 
           payload = { :key => key }
           payload.merge!(options) if options.is_a?(Hash)
           ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload){ yield(payload) }
         end
 
-        def log(operation, key, options = nil)
-          return unless logger && logger.debug? && !silence?
-          logger.debug("Cache #{operation}: #{key}#{options.blank? ? "" : " (#{options.inspect})"}")
+        def instrument_multi(operation, keys, options = nil)
+          log do
+            formatted_keys = keys.map { |k| "- #{k}" }.join("\n")
+            "Caches multi #{operation}:\n#{formatted_keys}#{options.blank? ? "" : " (#{options.inspect})"}"
+          end
+
+          payload = { key: keys }
+          payload.merge!(options) if options.is_a?(Hash)
+          ActiveSupport::Notifications.instrument("cache_#{operation}_multi.active_support", payload) { yield(payload) }
         end
 
-        def find_cached_entry(key, name, options)
-          instrument(:read, name, options) do |payload|
-            payload[:super_operation] = :fetch if payload
-            read_entry(key, options)
-          end
+        def log
+          return unless logger && logger.debug? && !silence?
+          logger.debug(yield)
         end
 
         def handle_expired_entry(entry, key, options)
           if entry && entry.expired?
             race_ttl = options[:race_condition_ttl].to_i
             if (race_ttl > 0) && (Time.now.to_f - entry.expires_at <= race_ttl)
-              # When an entry has :race_condition_ttl defined, put the stale entry back into the cache
-              # for a brief period while the entry is begin recalculated.
+              # When an entry has a positive :race_condition_ttl defined, put the stale entry back into the cache
+              # for a brief period while the entry is being recalculated.
               entry.expires_at = Time.now + race_ttl
               write_entry(key, entry, :expires_in => race_ttl * 2)
             else
@@ -615,14 +626,12 @@ module ActiveSupport
       end
 
       def value
-        convert_version_4beta1_entry! if defined?(@v)
         compressed? ? uncompress(@value) : @value
       end
 
       # Check if the entry is expired. The +expires_in+ parameter can override
       # the value set when the entry was created.
       def expired?
-        convert_version_4beta1_entry! if defined?(@v)
         @expires_in && @created_at + @expires_in <= Time.now.to_f
       end
 
@@ -658,8 +667,6 @@ module ActiveSupport
       # Duplicate the value in a class. This is used by cache implementations that don't natively
       # serialize entries to protect against accidental cache modifications.
       def dup_value!
-        convert_version_4beta1_entry! if defined?(@v)
-
         if @value && !compressed? && !(@value.is_a?(Numeric) || @value == true || @value == false)
           if @value.is_a?(String)
             @value = @value.dup
@@ -692,26 +699,6 @@ module ActiveSupport
         def uncompress(value)
           Marshal.load(Zlib::Inflate.inflate(value))
         end
-
-        # The internals of this method changed between Rails 3.x and 4.0. This method provides the glue
-        # to ensure that cache entries created under the old version still work with the new class definition.
-        def convert_version_4beta1_entry!
-          if defined?(@v)
-            @value = @v
-            remove_instance_variable(:@v)
-          end
-
-          if defined?(@c)
-            @compressed = @c
-            remove_instance_variable(:@c)
-          end
-
-          if defined?(@x) && @x
-            @created_at ||= Time.now.to_f
-            @expires_in = @x - @created_at
-            remove_instance_variable(:@x)
-          end
-        end
     end
   end
 end

data/lib/active_support/cache/file_store.rb

@@ -10,6 +10,7 @@ module ActiveSupport
     # FileStore implements the Strategy::LocalCache strategy which implements
     # an in-memory cache inside of a block.
     class FileStore < Store
+      prepend Strategy::LocalCache
       attr_reader :cache_path
 
       DIR_FORMATTER = "%03X"
@@ -20,7 +21,6 @@ module ActiveSupport
       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
@@ -29,6 +29,7 @@ module ActiveSupport
       def clear(options = nil)
         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)})
+      rescue Errno::ENOENT
       end
 
       # Preemptively iterates through all stored keys and removes the ones which have expired.
@@ -59,7 +60,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
@@ -67,9 +68,8 @@ module ActiveSupport
       protected
 
         def read_entry(key, options)
-          file_name = key_file_path(key)
-          if File.exist?(file_name)
-            File.open(file_name) { |f| Marshal.load(f) }
+          if File.exist?(key)
+            File.open(key) { |f| Marshal.load(f) }
           end
         rescue => e
           logger.error("FileStoreError (#{e}): #{e.message}") if logger
@@ -77,23 +77,21 @@ module ActiveSupport
         end
 
         def write_entry(key, entry, options)
-          file_name = key_file_path(key)
-          return false if options[:unless_exist] && File.exist?(file_name)
-          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
@@ -117,12 +115,14 @@ module ActiveSupport
         end
 
         # Translate a key into a file path.
-        def key_file_path(key)
-          if key.size > FILEPATH_MAX_SIZE
-            key = Digest::MD5.hexdigest(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
 
-          fname = URI.encode_www_form_component(key)
           hash = Zlib.adler32(fname)
           hash, dir_1 = hash.divmod(0x1000)
           dir_2 = hash.modulo(0x1000)
@@ -137,6 +137,14 @@ module ActiveSupport
           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.to_s.size..-1].split(File::SEPARATOR, 4).last
@@ -173,7 +181,7 @@ module ActiveSupport
         # 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 = key_file_path(namespaced_key(name, options))
+          file_name = normalize_key(name, options)
 
           lock_file(file_name) do
             options = merged_options(options)