activesupport 4.1.16 → 4.2.0.beta1

data/README.rdoc

@@ -14,7 +14,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/4-1-stable/activesupport
+* https://github.com/rails/rails/tree/master/activesupport
 
 
 == License
@@ -30,6 +30,11 @@ API documentation is at:
 
 * 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/backtrace_cleaner.rb

@@ -13,7 +13,7 @@ module ActiveSupport
   # can focus on the rest.
   #
   #   bc = BacktraceCleaner.new
-  #   bc.add_filter   { |line| line.gsub(Rails.root, '') } # strip the Rails.root prefix
+  #   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
   #
@@ -65,14 +65,14 @@ 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
+    # 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 silencers. Useful if you suddenly
+    # 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!

data/lib/active_support/cache.rb

@@ -8,6 +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'
 
 module ActiveSupport
   # See ActiveSupport::Cache::Store for documentation.
@@ -178,14 +179,16 @@ module ActiveSupport
         @silence = previous_silence
       end
 
-      # Set to +true+ if cache stores should be instrumented.
-      # Default is +false+.
+      # :deprecated:
       def self.instrument=(boolean)
-        Thread.current[:instrument_cache_store] = 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
-        Thread.current[:instrument_cache_store] || false
+        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
@@ -234,7 +237,7 @@ module ActiveSupport
       # seconds. Because of extended life of the previous cache, other processes
       # will continue to use slightly stale data for a just a bit longer. In the
       # meantime that first process will go ahead and will write into cache the
-      # new value. After that all the processes will start getting new value.
+      # new value. After that all the processes will start getting the new value.
       # The key is to keep <tt>:race_condition_ttl</tt> small.
       #
       # If the process regenerating the entry errors out, the entry will be
@@ -357,20 +360,19 @@ module ActiveSupport
       #
       # Options are passed to the underlying cache implementation.
       #
-      # Returns an array with the data for each of the names. For example:
+      # 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", "boomboom"]
+      #   cache.fetch_multi("bim", "boom") { |key| key * 2 }
+      #   # => { "bam" => "bam", "boom" => "boomboom" }
       #
       def fetch_multi(*names)
         options = names.extract_options!
         options = merged_options(options)
-
         results = read_multi(*names, options)
 
-        names.map do |name|
-          results.fetch(name) do
+        names.each_with_object({}) do |name, memo|
+          memo[name] = results.fetch(name) do
             value = yield name
             write(name, value, options)
             value
@@ -540,13 +542,9 @@ module ActiveSupport
         def instrument(operation, key, options = nil)
           log(operation, key, options)
 
-          if self.class.instrument
-            payload = { :key => key }
-            payload.merge!(options) if options.is_a?(Hash)
-            ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload){ yield(payload) }
-          else
-            yield(nil)
-          end
+          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)
@@ -564,7 +562,7 @@ module ActiveSupport
         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)
+            if race_ttl && (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.
               entry.expires_at = Time.now + race_ttl
@@ -624,7 +622,7 @@ module ActiveSupport
       # 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)
+        convert_version_4beta1_entry! if defined?(@value)
         @expires_in && @created_at + @expires_in <= Time.now.to_f
       end
 

data/lib/active_support/cache/file_store.rb

@@ -14,6 +14,7 @@ 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
 
       def initialize(cache_path, options = nil)
@@ -117,6 +118,10 @@ module ActiveSupport
 
         # Translate a key into a file path.
         def key_file_path(key)
+          if key.size > FILEPATH_MAX_SIZE
+            key = Digest::MD5.hexdigest(key)
+          end
+
           fname = URI.encode_www_form_component(key)
           hash = Zlib.adler32(fname)
           hash, dir_1 = hash.divmod(0x1000)

data/lib/active_support/cache/strategy/local_cache.rb

@@ -86,13 +86,13 @@ module ActiveSupport
 
         def increment(name, amount = 1, options = nil) # :nodoc:
           value = bypass_local_cache{super}
-          increment_or_decrement(value, name, amount, options)
+          set_cache_value(value, name, amount, options)
           value
         end
 
         def decrement(name, amount = 1, options = nil) # :nodoc:
           value = bypass_local_cache{super}
-          increment_or_decrement(value, name, amount, options)
+          set_cache_value(value, name, amount, options)
           value
         end
 
@@ -120,8 +120,7 @@ module ActiveSupport
             super
           end
 
-        private
-          def increment_or_decrement(value, name, amount, options)
+          def set_cache_value(value, name, amount, options)
             if local_cache
               local_cache.mute do
                 if value
@@ -133,6 +132,8 @@ module ActiveSupport
             end
           end
 
+        private
+
           def local_cache_key
             @local_cache_key ||= "#{self.class.name.underscore}_local_cache_#{object_id}".gsub(/[\/-]/, '_').to_sym
           end

data/lib/active_support/cache/strategy/local_cache_middleware.rb

@@ -1,4 +1,6 @@
 require 'rack/body_proxy'
+require 'rack/utils'
+
 module ActiveSupport
   module Cache
     module Strategy
@@ -28,6 +30,9 @@ module ActiveSupport
               LocalCacheRegistry.set_cache_for(local_cache_key, nil)
             end
             response
+          rescue Rack::Utils::InvalidParameterError
+            LocalCacheRegistry.set_cache_for(local_cache_key, nil)
+            [400, {}, []]
           rescue Exception
             LocalCacheRegistry.set_cache_for(local_cache_key, nil)
             raise

data/lib/active_support/callbacks.rb

@@ -71,7 +71,8 @@ module ActiveSupport
     # order.
     #
     # If the callback chain was halted, returns +false+. Otherwise returns the
-    # result of the block, or +true+ if no block is given.
+    # result of the block, +nil+ if no callbacks have been set, or +true+
+    # if callbacks have been set but no block is given.
     #
     #   run_callbacks :save do
     #     save
@@ -117,24 +118,22 @@ module ActiveSupport
       ENDING = End.new
 
       class Before
-        def self.build(callback_sequence, user_callback, user_conditions, chain_config, filter)
+        def self.build(next_callback, user_callback, user_conditions, chain_config, filter)
           halted_lambda = chain_config[:terminator]
 
           if chain_config.key?(:terminator) && user_conditions.any?
-            halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter)
+            halting_and_conditional(next_callback, user_callback, user_conditions, halted_lambda, filter)
           elsif chain_config.key? :terminator
-            halting(callback_sequence, user_callback, halted_lambda, filter)
+            halting(next_callback, user_callback, halted_lambda, filter)
           elsif user_conditions.any?
-            conditional(callback_sequence, user_callback, user_conditions)
+            conditional(next_callback, user_callback, user_conditions)
           else
-            simple callback_sequence, user_callback
+            simple next_callback, user_callback
           end
         end
 
-        private
-
-        def self.halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter)
-          callback_sequence.before do |env|
+        def self.halting_and_conditional(next_callback, user_callback, user_conditions, halted_lambda, filter)
+          lambda { |env|
             target = env.target
             value  = env.value
             halted = env.halted
@@ -146,13 +145,13 @@ module ActiveSupport
                 target.send :halted_callback_hook, filter
               end
             end
-
-            env
-          end
+            next_callback.call env
+          }
         end
+        private_class_method :halting_and_conditional
 
-        def self.halting(callback_sequence, user_callback, halted_lambda, filter)
-          callback_sequence.before do |env|
+        def self.halting(next_callback, user_callback, halted_lambda, filter)
+          lambda { |env|
             target = env.target
             value  = env.value
             halted = env.halted
@@ -164,58 +163,57 @@ module ActiveSupport
                 target.send :halted_callback_hook, filter
               end
             end
-
-            env
-          end
+            next_callback.call env
+          }
         end
+        private_class_method :halting
 
-        def self.conditional(callback_sequence, user_callback, user_conditions)
-          callback_sequence.before do |env|
+        def self.conditional(next_callback, user_callback, user_conditions)
+          lambda { |env|
             target = env.target
             value  = env.value
 
             if user_conditions.all? { |c| c.call(target, value) }
               user_callback.call target, value
             end
-
-            env
-          end
+            next_callback.call env
+          }
         end
+        private_class_method :conditional
 
-        def self.simple(callback_sequence, user_callback)
-          callback_sequence.before do |env|
+        def self.simple(next_callback, user_callback)
+          lambda { |env|
             user_callback.call env.target, env.value
-
-            env
-          end
+            next_callback.call env
+          }
         end
+        private_class_method :simple
       end
 
       class After
-        def self.build(callback_sequence, user_callback, user_conditions, chain_config)
+        def self.build(next_callback, user_callback, user_conditions, chain_config)
           if chain_config[:skip_after_callbacks_if_terminated]
             if chain_config.key?(:terminator) && user_conditions.any?
-              halting_and_conditional(callback_sequence, user_callback, user_conditions)
+              halting_and_conditional(next_callback, user_callback, user_conditions)
             elsif chain_config.key?(:terminator)
-              halting(callback_sequence, user_callback)
+              halting(next_callback, user_callback)
             elsif user_conditions.any?
-              conditional callback_sequence, user_callback, user_conditions
+              conditional next_callback, user_callback, user_conditions
             else
-              simple callback_sequence, user_callback
+              simple next_callback, user_callback
             end
           else
             if user_conditions.any?
-              conditional callback_sequence, user_callback, user_conditions
+              conditional next_callback, user_callback, user_conditions
             else
-              simple callback_sequence, user_callback
+              simple next_callback, user_callback
             end
           end
         end
 
-        private
-
-        def self.halting_and_conditional(callback_sequence, user_callback, user_conditions)
-          callback_sequence.after do |env|
+        def self.halting_and_conditional(next_callback, user_callback, user_conditions)
+          lambda { |env|
+            env = next_callback.call env
             target = env.target
             value  = env.value
             halted = env.halted
@@ -223,120 +221,124 @@ module ActiveSupport
             if !halted && user_conditions.all? { |c| c.call(target, value) }
               user_callback.call target, value
             end
-
             env
-          end
+          }
         end
+        private_class_method :halting_and_conditional
 
-        def self.halting(callback_sequence, user_callback)
-          callback_sequence.after do |env|
+        def self.halting(next_callback, user_callback)
+          lambda { |env|
+            env = next_callback.call env
             unless env.halted
               user_callback.call env.target, env.value
             end
-
             env
-          end
+          }
         end
+        private_class_method :halting
 
-        def self.conditional(callback_sequence, user_callback, user_conditions)
-          callback_sequence.after do |env|
+        def self.conditional(next_callback, user_callback, user_conditions)
+          lambda { |env|
+            env = next_callback.call env
             target = env.target
             value  = env.value
 
             if user_conditions.all? { |c| c.call(target, value) }
               user_callback.call target, value
             end
-
             env
-          end
+          }
         end
+        private_class_method :conditional
 
-        def self.simple(callback_sequence, user_callback)
-          callback_sequence.after do |env|
+        def self.simple(next_callback, user_callback)
+          lambda { |env|
+            env = next_callback.call env
             user_callback.call env.target, env.value
-
             env
-          end
+          }
         end
+        private_class_method :simple
       end
 
       class Around
-        def self.build(callback_sequence, user_callback, user_conditions, chain_config)
+        def self.build(next_callback, user_callback, user_conditions, chain_config)
           if chain_config.key?(:terminator) && user_conditions.any?
-            halting_and_conditional(callback_sequence, user_callback, user_conditions)
+            halting_and_conditional(next_callback, user_callback, user_conditions)
           elsif chain_config.key? :terminator
-            halting(callback_sequence, user_callback)
+            halting(next_callback, user_callback)
           elsif user_conditions.any?
-            conditional(callback_sequence, user_callback, user_conditions)
+            conditional(next_callback, user_callback, user_conditions)
           else
-            simple(callback_sequence, user_callback)
+            simple(next_callback, user_callback)
           end
         end
 
-        private
-
-        def self.halting_and_conditional(callback_sequence, user_callback, user_conditions)
-          callback_sequence.around do |env, &run|
+        def self.halting_and_conditional(next_callback, user_callback, user_conditions)
+          lambda { |env|
             target = env.target
             value  = env.value
             halted = env.halted
 
             if !halted && user_conditions.all? { |c| c.call(target, value) }
               user_callback.call(target, value) {
-                env = run.call env
+                env = next_callback.call env
                 env.value
               }
-
               env
             else
-              run.call env
+              next_callback.call env
             end
-          end
+          }
         end
+        private_class_method :halting_and_conditional
 
-        def self.halting(callback_sequence, user_callback)
-          callback_sequence.around do |env, &run|
+        def self.halting(next_callback, user_callback)
+          lambda { |env|
             target = env.target
             value  = env.value
 
             if env.halted
-              run.call env
+              next_callback.call env
             else
               user_callback.call(target, value) {
-                env = run.call env
+                env = next_callback.call env
                 env.value
               }
               env
             end
-          end
+          }
         end
+        private_class_method :halting
 
-        def self.conditional(callback_sequence, user_callback, user_conditions)
-          callback_sequence.around do |env, &run|
+        def self.conditional(next_callback, user_callback, user_conditions)
+          lambda { |env|
             target = env.target
             value  = env.value
 
             if user_conditions.all? { |c| c.call(target, value) }
               user_callback.call(target, value) {
-                env = run.call env
+                env = next_callback.call env
                 env.value
               }
               env
             else
-              run.call env
+              next_callback.call env
             end
-          end
+          }
         end
+        private_class_method :conditional
 
-        def self.simple(callback_sequence, user_callback)
-          callback_sequence.around do |env, &run|
+        def self.simple(next_callback, user_callback)
+          lambda { |env|
             user_callback.call(env.target, env.value) {
-              env = run.call env
+              env = next_callback.call env
               env.value
             }
             env
-          end
+          }
         end
+        private_class_method :simple
       end
     end
 
@@ -387,17 +389,17 @@ module ActiveSupport
       end
 
       # Wraps code with filter
-      def apply(callback_sequence)
+      def apply(next_callback)
         user_conditions = conditions_lambdas
         user_callback = make_lambda @filter
 
         case kind
         when :before
-          Filters::Before.build(callback_sequence, user_callback, user_conditions, chain_config, @filter)
+          Filters::Before.build(next_callback, user_callback, user_conditions, chain_config, @filter)
         when :after
-          Filters::After.build(callback_sequence, user_callback, user_conditions, chain_config)
+          Filters::After.build(next_callback, user_callback, user_conditions, chain_config)
         when :around
-          Filters::Around.build(callback_sequence, user_callback, user_conditions, chain_config)
+          Filters::Around.build(next_callback, user_callback, user_conditions, chain_config)
         end
       end
 
@@ -414,15 +416,8 @@ module ActiveSupport
       #   Procs::   A proc to call with the object.
       #   Objects:: An object with a <tt>before_foo</tt> method on it to call.
       #
-      # All of these objects are compiled into methods and handled
-      # the same after this point:
-      #
-      #   Symbols:: Already methods.
-      #   Strings:: class_eval'd into methods.
-      #   Procs::   using define_method compiled into methods.
-      #   Objects::
-      #     a method is created that calls the before_foo method
-      #     on the object.
+      # All of these objects are converted into a lambda and handled
+      # the same after this point.
       def make_lambda(filter)
         case filter
         when Symbol
@@ -469,42 +464,6 @@ module ActiveSupport
       end
     end
 
-    # Execute before and after filters in a sequence instead of
-    # chaining them with nested lambda calls, see:
-    # https://github.com/rails/rails/issues/18011
-    class CallbackSequence
-      def initialize(&call)
-        @call = call
-        @before = []
-        @after = []
-      end
-
-      def before(&before)
-        @before.unshift(before)
-        self
-      end
-
-      def after(&after)
-        @after.push(after)
-        self
-      end
-
-      def around(&around)
-        CallbackSequence.new do |*args|
-          around.call(*args) {
-            self.call(*args)
-          }
-        end
-      end
-
-      def call(*args)
-        @before.each { |b| b.call(*args) }
-        value = @call.call(*args)
-        @after.each { |a| a.call(*args) }
-        value
-      end
-    end
-
     # An Array with a compile method.
     class CallbackChain #:nodoc:#
       include Enumerable
@@ -549,9 +508,8 @@ module ActiveSupport
 
       def compile
         @callbacks || @mutex.synchronize do
-          final_sequence = CallbackSequence.new { |env| Filters::ENDING.call(env) }
-          @callbacks ||= @chain.reverse.inject(final_sequence) do |callback_sequence, callback|
-            callback.apply callback_sequence
+          @callbacks ||= @chain.reverse.inject(Filters::ENDING) do |chain, callback|
+            callback.apply chain
           end
         end
       end
@@ -608,7 +566,7 @@ module ActiveSupport
       #
       #   set_callback :save, :before, :before_meth
       #   set_callback :save, :after,  :after_meth, if: :condition
-      #   set_callback :save, :around, ->(r, &block) { stuff; result = block.call; stuff }
+      #   set_callback :save, :around, ->(r, block) { stuff; result = block.call; stuff }
       #
       # The second arguments indicates whether the callback is to be run +:before+,
       # +:after+, or +:around+ the event. If omitted, +:before+ is assumed. This
@@ -760,15 +718,9 @@ module ActiveSupport
       #   would call <tt>Audit#save</tt>.
       def define_callbacks(*names)
         options = names.extract_options!
-        if options.key?(:terminator) && String === options[:terminator]
-          ActiveSupport::Deprecation.warn "String based terminators are deprecated, please use a lambda"
-          value = options[:terminator]
-          line = class_eval "lambda { |result| #{value} }", __FILE__, __LINE__
-          options[:terminator] = lambda { |target, result| target.instance_exec(result, &line) }
-        end
 
         names.each do |name|
-          class_attribute "_#{name}_callbacks", instance_writer: false
+          class_attribute "_#{name}_callbacks"
           set_callbacks name, CallbackChain.new(name, options)
         end
       end