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.
last parameter.
* `callbacks` - An array of callbacks, with an optional options hash as the
#### Parameters

across several methods that use it.
the block with each callback. This allows us to abstract the normalization
Take callback names and an optional callback proc, normalize them, then call 
def _insert_callbacks(callbacks, block = nil)
  options = callbacks.extract_options!
  callbacks.push(block) if block
  options[:filters] = callbacks
  _normalize_callback_options(options)
  options.delete(:filters)
  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_value = options.delete(from)
    filters = options[:filters]
    from_value = ActionFilter.new(filters, from, from_value)
    options[to] = Array(options[to]).unshift(from_value)
  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.

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

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

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

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

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