activesupport 4.2.11.3 → 5.0.7.2

data/lib/active_support/callbacks.rb

@@ -4,6 +4,9 @@ require 'active_support/core_ext/array/extract_options'
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/kernel/reporting'
 require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/string/filters'
+require 'active_support/deprecation'
 require 'thread'
 
 module ActiveSupport
@@ -64,6 +67,12 @@ module ActiveSupport
 
     CALLBACK_FILTER_TYPES = [:before, :after, :around]
 
+    # If true, Active Record and Active Model callbacks returning +false+ will
+    # halt the entire callback chain and display a deprecation message.
+    # If false, callback chains will only be halted by calling +throw :abort+.
+    # Defaults to +true+.
+    mattr_accessor(:halt_and_display_warning_on_return_false, instance_writer: false) { true }
+
     # Runs the callbacks for the given event.
     #
     # Calls the before and around callbacks in the order they were set, yields
@@ -124,14 +133,10 @@ module ActiveSupport
         def self.build(callback_sequence, user_callback, user_conditions, chain_config, filter)
           halted_lambda = chain_config[:terminator]
 
-          if chain_config.key?(:terminator) && user_conditions.any?
+          if user_conditions.any?
             halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter)
-          elsif chain_config.key? :terminator
-            halting(callback_sequence, user_callback, halted_lambda, filter)
-          elsif user_conditions.any?
-            conditional(callback_sequence, user_callback, user_conditions)
           else
-            simple callback_sequence, user_callback
+            halting(callback_sequence, user_callback, halted_lambda, filter)
           end
         end
 
@@ -142,8 +147,8 @@ module ActiveSupport
             halted = env.halted
 
             if !halted && user_conditions.all? { |c| c.call(target, value) }
-              result = user_callback.call target, value
-              env.halted = halted_lambda.call(target, result)
+              result_lambda = -> { user_callback.call target, value }
+              env.halted = halted_lambda.call(target, result_lambda)
               if env.halted
                 target.send :halted_callback_hook, filter
               end
@@ -161,8 +166,9 @@ module ActiveSupport
             halted = env.halted
 
             unless halted
-              result = user_callback.call target, value
-              env.halted = halted_lambda.call(target, result)
+              result_lambda = -> { user_callback.call target, value }
+              env.halted = halted_lambda.call(target, result_lambda)
+
               if env.halted
                 target.send :halted_callback_hook, filter
               end
@@ -172,42 +178,15 @@ module ActiveSupport
           end
         end
         private_class_method :halting
-
-        def self.conditional(callback_sequence, user_callback, user_conditions)
-          callback_sequence.before do |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.before do |env|
-            user_callback.call env.target, env.value
-
-            env
-          end
-        end
-        private_class_method :simple
       end
 
       class After
         def self.build(callback_sequence, user_callback, user_conditions, chain_config)
           if chain_config[:skip_after_callbacks_if_terminated]
-            if chain_config.key?(:terminator) && user_conditions.any?
+            if user_conditions.any?
               halting_and_conditional(callback_sequence, user_callback, user_conditions)
-            elsif chain_config.key?(:terminator)
-              halting(callback_sequence, user_callback)
-            elsif user_conditions.any?
-              conditional callback_sequence, user_callback, user_conditions
             else
-              simple callback_sequence, user_callback
+              halting(callback_sequence, user_callback)
             end
           else
             if user_conditions.any?
@@ -270,14 +249,10 @@ module ActiveSupport
 
       class Around
         def self.build(callback_sequence, user_callback, user_conditions, chain_config)
-          if chain_config.key?(:terminator) && user_conditions.any?
+          if user_conditions.any?
             halting_and_conditional(callback_sequence, user_callback, user_conditions)
-          elsif chain_config.key? :terminator
-            halting(callback_sequence, user_callback)
-          elsif user_conditions.any?
-            conditional(callback_sequence, user_callback, user_conditions)
           else
-            simple(callback_sequence, user_callback)
+            halting(callback_sequence, user_callback)
           end
         end
 
@@ -289,13 +264,11 @@ module ActiveSupport
 
             if !halted && user_conditions.all? { |c| c.call(target, value) }
               user_callback.call(target, value) {
-                env = run.call env
-                env.value
+                run.call.value
               }
-
               env
             else
-              run.call env
+              run.call
             end
           end
         end
@@ -307,51 +280,28 @@ module ActiveSupport
             value  = env.value
 
             if env.halted
-              run.call env
+              run.call
             else
               user_callback.call(target, value) {
-                env = run.call env
-                env.value
+                run.call.value
               }
               env
             end
           end
         end
         private_class_method :halting
-
-        def self.conditional(callback_sequence, user_callback, user_conditions)
-          callback_sequence.around do |env, &run|
-            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.value
-              }
-              env
-            else
-              run.call env
-            end
-          end
-        end
-        private_class_method :conditional
-
-        def self.simple(callback_sequence, user_callback)
-          callback_sequence.around do |env, &run|
-            user_callback.call(env.target, env.value) {
-              env = run.call env
-              env.value
-            }
-            env
-          end
-        end
-        private_class_method :simple
       end
     end
 
     class Callback #:nodoc:#
       def self.build(chain, filter, kind, options)
+        if filter.is_a?(String)
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Passing string to define callback is deprecated and will be removed
+            in Rails 5.1 without replacement.
+          MSG
+        end
+
         new chain.name, filter, kind, options, chain.config
       end
 
@@ -371,14 +321,14 @@ module ActiveSupport
       def filter; @key; end
       def raw_filter; @filter; end
 
-      def merge(chain, new_options)
+      def merge_conditional_options(chain, if_option:, unless_option:)
         options = {
           :if     => @if.dup,
           :unless => @unless.dup
         }
 
-        options[:if].concat     Array(new_options.fetch(:unless, []))
-        options[:unless].concat Array(new_options.fetch(:if, []))
+        options[:if].concat     Array(unless_option)
+        options[:unless].concat Array(if_option)
 
         self.class.build chain, @filter, @kind, options
       end
@@ -493,17 +443,17 @@ module ActiveSupport
       end
 
       def around(&around)
-        CallbackSequence.new do |*args|
-          around.call(*args) {
-            self.call(*args)
+        CallbackSequence.new do |arg|
+          around.call(arg) {
+            self.call(arg)
           }
         end
       end
 
-      def call(*args)
-        @before.each { |b| b.call(*args) }
-        value = @call.call(*args)
-        @after.each { |a| a.call(*args) }
+      def call(arg)
+        @before.each { |b| b.call(arg) }
+        value = @call.call(arg)
+        @after.each { |a| a.call(arg) }
         value
       end
     end
@@ -517,7 +467,8 @@ module ActiveSupport
       def initialize(name, config)
         @name = name
         @config = {
-          :scope => [ :kind ]
+          scope: [:kind],
+          terminator: default_terminator
         }.merge!(config)
         @chain = []
         @callbacks = nil
@@ -588,6 +539,17 @@ module ActiveSupport
         @callbacks = nil
         @chain.delete_if { |c| callback.duplicates?(c) }
       end
+
+      def default_terminator
+        Proc.new do |target, result_lambda|
+          terminate = true
+          catch(:abort) do
+            result_lambda.call if result_lambda.is_a?(Proc)
+            terminate = false
+          end
+          terminate
+        end
+      end
     end
 
     module ClassMethods
@@ -609,18 +571,18 @@ module ActiveSupport
 
       # Install a callback for the given event.
       #
-      #   set_callback :save, :before, :before_meth
-      #   set_callback :save, :after,  :after_meth, if: :condition
+      #   set_callback :save, :before, :before_method
+      #   set_callback :save, :after,  :after_method, if: :condition
       #   set_callback :save, :around, ->(r, block) { stuff; result = block.call; stuff }
       #
-      # The second arguments indicates whether the callback is to be run +:before+,
+      # The second argument indicates whether the callback is to be run +:before+,
       # +:after+, or +:around+ the event. If omitted, +:before+ is assumed. This
       # means the first example above can also be written as:
       #
-      #   set_callback :save, :before_meth
+      #   set_callback :save, :before_method
       #
       # The callback can be specified as a symbol naming an instance method; as a
-      # proc, lambda, or block; as a string to be instance evaluated; or as an
+      # proc, lambda, or block; as a string to be instance evaluated(deprecated); or as an
       # object that responds to a certain method determined by the <tt>:scope</tt>
       # argument to +define_callbacks+.
       #
@@ -664,19 +626,27 @@ module ActiveSupport
       #   class Writer < Person
       #      skip_callback :validate, :before, :check_membership, if: -> { self.age > 18 }
       #   end
+      #
+      # An <tt>ArgumentError</tt> will be raised if the callback has not
+      # already been set (unless the <tt>:raise</tt> option is set to <tt>false</tt>).
       def skip_callback(name, *filter_list, &block)
         type, filters, options = normalize_callback_params(filter_list, block)
+        options[:raise] = true unless options.key?(:raise)
 
         __update_callbacks(name) do |target, chain|
           filters.each do |filter|
-            filter = chain.find {|c| c.matches?(type, filter) }
+            callback = chain.find {|c| c.matches?(type, filter) }
+
+            if !callback && options[:raise]
+              raise ArgumentError, "#{type.to_s.capitalize} #{name} callback #{filter.inspect} has not been defined"
+            end
 
-            if filter && options.any?
-              new_filter = filter.merge(chain, options)
-              chain.insert(chain.index(filter), new_filter)
+            if callback && (options.key?(:if) || options.key?(:unless))
+              new_callback = callback.merge_conditional_options(chain, if_option: options[:if], unless_option: options[:unless])
+              chain.insert(chain.index(callback), new_callback)
             end
 
-            chain.delete(filter)
+            chain.delete(callback)
           end
           target.set_callbacks name, chain
         end
@@ -703,21 +673,23 @@ module ActiveSupport
       # ===== Options
       #
       # * <tt>:terminator</tt> - Determines when a before filter will halt the
-      #   callback chain, preventing following callbacks from being called and
-      #   the event from being triggered. This should be a lambda to be executed.
-      #   The current object and the return result of the callback will be called
-      #   with the lambda.
+      #   callback chain, preventing following before and around callbacks from
+      #   being called and the event from being triggered.
+      #   This should be a lambda to be executed.
+      #   The current object and the result lambda of the callback will be provided
+      #   to the terminator lambda.
       #
-      #     define_callbacks :validate, terminator: ->(target, result) { result == false }
+      #     define_callbacks :validate, terminator: ->(target, result_lambda) { result_lambda.call == false }
       #
       #   In this example, if any before validate callbacks returns +false+,
-      #   other callbacks are not executed. Defaults to +false+, meaning no value
-      #   halts the chain.
+      #   any successive before and around callback is not executed.
+      #
+      #   The default terminator halts the chain when a callback throws +:abort+.
       #
       # * <tt>:skip_after_callbacks_if_terminated</tt> - Determines if after
       #   callbacks should be terminated by the <tt>:terminator</tt> option. By
-      #   default after callbacks executed no matter if callback chain was
-      #   terminated or not. Option makes sense only when <tt>:terminator</tt>
+      #   default after callbacks are executed no matter if callback chain was
+      #   terminated or not. This option makes sense only when <tt>:terminator</tt>
       #   option is specified.
       #
       # * <tt>:scope</tt> - Indicates which methods should be executed when an
@@ -783,13 +755,37 @@ module ActiveSupport
 
       protected
 
-      def get_callbacks(name)
+      def get_callbacks(name) # :nodoc:
         send "_#{name}_callbacks"
       end
 
-      def set_callbacks(name, callbacks)
+      def set_callbacks(name, callbacks) # :nodoc:
         send "_#{name}_callbacks=", callbacks
       end
+
+      def deprecated_false_terminator # :nodoc:
+        Proc.new do |target, result_lambda|
+          terminate = true
+          catch(:abort) do
+            result = result_lambda.call if result_lambda.is_a?(Proc)
+            if Callbacks.halt_and_display_warning_on_return_false && result == false
+              display_deprecation_warning_for_false_terminator
+            else
+              terminate = false
+            end
+          end
+          terminate
+        end
+      end
+
+      private
+
+      def display_deprecation_warning_for_false_terminator
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          Returning `false` in Active Record and Active Model callbacks will not implicitly halt a callback chain in Rails 5.1.
+          To explicitly halt the callback chain, please use `throw :abort` instead.
+        MSG
+      end
     end
   end
 end

data/lib/active_support/concern.rb

@@ -114,7 +114,7 @@ module ActiveSupport
         return false
       else
         return false if base < self
-        @_dependencies.each { |dep| base.send(:include, dep) }
+        @_dependencies.each { |dep| base.include(dep) }
         super
         base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
         base.class_eval(&@_included_block) if instance_variable_defined?(:@_included_block)

data/lib/active_support/concurrency/latch.rb

@@ -1,26 +1,25 @@
-require 'thread'
-require 'monitor'
+require 'concurrent/atomic/count_down_latch'
 
 module ActiveSupport
   module Concurrency
     class Latch
+
       def initialize(count = 1)
-        @count = count
-        @lock = Monitor.new
-        @cv = @lock.new_cond
+        if count == 1
+          ActiveSupport::Deprecation.warn("ActiveSupport::Concurrency::Latch is deprecated. Please use Concurrent::Event instead.")
+        else
+          ActiveSupport::Deprecation.warn("ActiveSupport::Concurrency::Latch is deprecated. Please use Concurrent::CountDownLatch instead.")
+        end
+
+        @inner = Concurrent::CountDownLatch.new(count)
       end
 
       def release
-        @lock.synchronize do
-          @count -= 1 if @count > 0
-          @cv.broadcast if @count.zero?
-        end
+        @inner.count_down
       end
 
       def await
-        @lock.synchronize do
-          @cv.wait_while { @count > 0 }
-        end
+        @inner.wait(nil)
       end
     end
   end

data/lib/active_support/concurrency/share_lock.rb

@@ -0,0 +1,226 @@
+require 'thread'
+require 'monitor'
+
+module ActiveSupport
+  module Concurrency
+    # A share/exclusive lock, otherwise known as a read/write lock.
+    #
+    # https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock
+    class ShareLock
+      include MonitorMixin
+
+      # We track Thread objects, instead of just using counters, because
+      # we need exclusive locks to be reentrant, and we need to be able
+      # to upgrade share locks to exclusive.
+
+
+      def raw_state # :nodoc:
+        synchronize do
+          threads = @sleeping.keys | @sharing.keys | @waiting.keys
+          threads |= [@exclusive_thread] if @exclusive_thread
+
+          data = {}
+
+          threads.each do |thread|
+            purpose, compatible = @waiting[thread]
+
+            data[thread] = {
+              thread: thread,
+              sharing: @sharing[thread],
+              exclusive: @exclusive_thread == thread,
+              purpose: purpose,
+              compatible: compatible,
+              waiting: !!@waiting[thread],
+              sleeper: @sleeping[thread],
+            }
+          end
+
+          # NB: Yields while holding our *internal* synchronize lock,
+          # which is supposed to be used only for a few instructions at
+          # a time. This allows the caller to inspect additional state
+          # without things changing out from underneath, but would have
+          # disastrous effects upon normal operation. Fortunately, this
+          # method is only intended to be called when things have
+          # already gone wrong.
+          yield data
+        end
+      end
+
+      def initialize
+        super()
+
+        @cv = new_cond
+
+        @sharing = Hash.new(0)
+        @waiting = {}
+        @sleeping = {}
+        @exclusive_thread = nil
+        @exclusive_depth = 0
+      end
+
+      # Returns false if +no_wait+ is set and the lock is not
+      # immediately available. Otherwise, returns true after the lock
+      # has been acquired.
+      #
+      # +purpose+ and +compatible+ work together; while this thread is
+      # waiting for the exclusive lock, it will yield its share (if any)
+      # to any other attempt whose +purpose+ appears in this attempt's
+      # +compatible+ list. This allows a "loose" upgrade, which, being
+      # less strict, prevents some classes of deadlocks.
+      #
+      # For many resources, loose upgrades are sufficient: if a thread
+      # is awaiting a lock, it is not running any other code. With
+      # +purpose+ matching, it is possible to yield only to other
+      # threads whose activity will not interfere.
+      def start_exclusive(purpose: nil, compatible: [], no_wait: false)
+        synchronize do
+          unless @exclusive_thread == Thread.current
+            if busy_for_exclusive?(purpose)
+              return false if no_wait
+
+              yield_shares(purpose: purpose, compatible: compatible, block_share: true) do
+                wait_for(:start_exclusive) { busy_for_exclusive?(purpose) }
+              end
+            end
+            @exclusive_thread = Thread.current
+          end
+          @exclusive_depth += 1
+
+          true
+        end
+      end
+
+      # Relinquish the exclusive lock. Must only be called by the thread
+      # that called start_exclusive (and currently holds the lock).
+      def stop_exclusive(compatible: [])
+        synchronize do
+          raise "invalid unlock" if @exclusive_thread != Thread.current
+
+          @exclusive_depth -= 1
+          if @exclusive_depth == 0
+            @exclusive_thread = nil
+
+            if eligible_waiters?(compatible)
+              yield_shares(compatible: compatible, block_share: true) do
+                wait_for(:stop_exclusive) { @exclusive_thread || eligible_waiters?(compatible) }
+              end
+            end
+            @cv.broadcast
+          end
+        end
+      end
+
+      def start_sharing
+        synchronize do
+          if @sharing[Thread.current] > 0 || @exclusive_thread == Thread.current
+            # We already hold a lock; nothing to wait for
+          elsif @waiting[Thread.current]
+            # We're nested inside a +yield_shares+ call: we'll resume as
+            # soon as there isn't an exclusive lock in our way
+            wait_for(:start_sharing) { @exclusive_thread }
+          else
+            # This is an initial / outermost share call: any outstanding
+            # requests for an exclusive lock get to go first
+            wait_for(:start_sharing) { busy_for_sharing?(false) }
+          end
+          @sharing[Thread.current] += 1
+        end
+      end
+
+      def stop_sharing
+        synchronize do
+          if @sharing[Thread.current] > 1
+            @sharing[Thread.current] -= 1
+          else
+            @sharing.delete Thread.current
+            @cv.broadcast
+          end
+        end
+      end
+
+      # Execute the supplied block while holding the Exclusive lock. If
+      # +no_wait+ is set and the lock is not immediately available,
+      # returns +nil+ without yielding. Otherwise, returns the result of
+      # the block.
+      #
+      # See +start_exclusive+ for other options.
+      def exclusive(purpose: nil, compatible: [], after_compatible: [], no_wait: false)
+        if start_exclusive(purpose: purpose, compatible: compatible, no_wait: no_wait)
+          begin
+            yield
+          ensure
+            stop_exclusive(compatible: after_compatible)
+          end
+        end
+      end
+
+      # Execute the supplied block while holding the Share lock.
+      def sharing
+        start_sharing
+        begin
+          yield
+        ensure
+          stop_sharing
+        end
+      end
+
+      # Temporarily give up all held Share locks while executing the
+      # supplied block, allowing any +compatible+ exclusive lock request
+      # to proceed.
+      def yield_shares(purpose: nil, compatible: [], block_share: false)
+        loose_shares = previous_wait = nil
+        synchronize do
+          if loose_shares = @sharing.delete(Thread.current)
+            if previous_wait = @waiting[Thread.current]
+              purpose = nil unless purpose == previous_wait[0]
+              compatible &= previous_wait[1]
+            end
+            compatible |= [false] unless block_share
+            @waiting[Thread.current] = [purpose, compatible]
+          end
+
+          @cv.broadcast
+        end
+
+        begin
+          yield
+        ensure
+          synchronize do
+            wait_for(:yield_shares) { @exclusive_thread && @exclusive_thread != Thread.current }
+
+            if previous_wait
+              @waiting[Thread.current] = previous_wait
+            else
+              @waiting.delete Thread.current
+            end
+            @sharing[Thread.current] = loose_shares if loose_shares
+          end
+        end
+      end
+
+      private
+
+      # Must be called within synchronize
+      def busy_for_exclusive?(purpose)
+        busy_for_sharing?(purpose) ||
+          @sharing.size > (@sharing[Thread.current] > 0 ? 1 : 0)
+      end
+
+      def busy_for_sharing?(purpose)
+        (@exclusive_thread && @exclusive_thread != Thread.current) ||
+          @waiting.any? { |t, (_, c)| t != Thread.current && !c.include?(purpose) }
+      end
+
+      def eligible_waiters?(compatible)
+        @waiting.any? { |t, (p, _)| compatible.include?(p) && @waiting.all? { |t2, (_, c2)| t == t2 || c2.include?(p) } }
+      end
+
+      def wait_for(method)
+        @sleeping[Thread.current] = method
+        @cv.wait_while { yield }
+      ensure
+        @sleeping.delete Thread.current
+      end
+    end
+  end
+end

data/lib/active_support/configurable.rb

@@ -122,6 +122,7 @@ module ActiveSupport
           send("#{name}=", yield) if block_given?
         end
       end
+      private :config_accessor
     end
 
     # Reads and writes attributes from a configuration <tt>OrderedHash</tt>.