module AbstractController::Callbacks::ClassMethods

def _insert_callbacks(callbacks, block = nil)

* options - A hash of options to be used when adding the callback.
* name - The callback to be added.
==== Block Parameters

* block - A proc that should be added to the callbacks.
options hash as the last parameter.
* callbacks - An array of callbacks, with an optional
==== Parameters

the normalization across several methods that use it.
then call the block with each callback. This allows us to abstract
Take callback names and an optional callback proc, normalize them, 
def _insert_callbacks(callbacks, block = nil)
  options = callbacks.extract_options!
  _normalize_callback_options(options)
  callbacks.push(block) if block
  callbacks.each do |callback|
    yield callback, options
  end
end

def _normalize_callback_option(options, from, to) # :nodoc:

:nodoc: 
def _normalize_callback_option(options, from, to) # :nodoc:
  if from = options[from]
    _from = Array(from).map(&:to_s).to_set
    from = proc {|c| _from.include? c.action_name }
    options[to] = Array(options[to]).unshift(from)
  end
end

def _normalize_callback_options(options)

* except - The callback should be run for all actions except this action.
* only - The callback should be run only for this action.
==== Options

except: :index, if: -> { true } # the :except option will be ignored.

are used together.
Note that :if has priority over :except in case they

only: :index, if: -> { true } # the :if option will be ignored.

are used together.
Note that :only has priority over :if in case they

:if => proc {|c| c.action_name == "index" }.
The basic idea is that :only => :index gets converted to

+:if+ and +:unless+ options of ActiveSupport::Callbacks.
If +:only+ or +:except+ are used, convert the options into the 
def _normalize_callback_options(options)
  _normalize_callback_option(options, :only, :if)
  _normalize_callback_option(options, :except, :unless)
end

def skip_action_callback(*names)

using #skip_action_callback.
impossible to skip a callback defined using an anonymous proc
callbacks. Note that skipping uses Ruby equality, so it's
* names - A list of valid names that could be used for
==== Parameters

Skip before, after, and around action callbacks matching any of the names. 
def skip_action_callback(*names)
  ActiveSupport::Deprecation.warn('`skip_action_callback` is deprecated and will be removed in Rails 5.1. Please use skip_before_action, skip_after_action or skip_around_action instead.')
  skip_before_action(*names, raise: false)
  skip_after_action(*names, raise: false)
  skip_around_action(*names, raise: false)
end

def skip_filter(*names) 

def skip_filter(*names)
  ActiveSupport::Deprecation.warn("`skip_filter` is deprecated and will be removed in Rails 5.1. Use skip_before_action, skip_after_action or skip_around_action instead.")
  skip_action_callback(*names)
end