class Rails::Configuration::MiddlewareStackProxy


config.middleware.delete ActionDispatch::Flash
And finally they can also be removed from the stack completely:
config.middleware.move_after ActionDispatch::Flash, Magical::Unicorns
ActionDispatch::Flash. You can also move it after:
This will move the Magical::Unicorns middleware before the
config.middleware.move_before ActionDispatch::Flash, Magical::Unicorns
Middlewares can be moved from one place to another:
config.middleware.swap ActionDispatch::Flash, Magical::Unicorns
Middlewares can also be completely swapped out and replaced with others:
config.middleware.insert_after Rack::Head, Magical::Unicorns
There’s also insert_after which will insert a middleware after another:
config.middleware.insert_before Rack::Head, Magical::Unicorns
You can use insert_before if you wish to add a middleware before another:
This will put the Magical::Unicorns middleware on the end of the stack.
config.middleware.use Magical::Unicorns
You can add your own middlewares by using the config.middleware.use method:
middleware in Rails.
over the default middleware stack, so you can add, swap, or remove any
command recorder, saving each command to be applied after initialization
you to configure middlewares in your application. It works basically as a
MiddlewareStackProxy is a proxy for the Rails middleware stack that allows

def +(other) # :nodoc:

:nodoc: 
def +(other) # :nodoc:
  MiddlewareStackProxy.new(@operations + other.operations, @delete_operations + other.delete_operations)
end

def delete(...) 

def delete(...)
  @delete_operations << -> middleware { middleware.delete(...) }
end

def initialize(operations = [], delete_operations = []) 

def initialize(operations = [], delete_operations = [])
  @operations = operations
  @delete_operations = delete_operations
end

def insert_after(...) 

def insert_after(...)
  @operations << -> middleware { middleware.insert_after(...) }
end

def insert_before(...) 

def insert_before(...)
  @operations << -> middleware { middleware.insert_before(...) }
end

def merge_into(other) # :nodoc:

:nodoc: 
def merge_into(other) # :nodoc:
  (@operations + @delete_operations).each do |operation|
    operation.call(other)
  end
  other
end

def move_after(...) 

def move_after(...)
  @delete_operations << -> middleware { middleware.move_after(...) }
end

def move_before(...) 

def move_before(...)
  @delete_operations << -> middleware { middleware.move_before(...) }
end

def swap(...) 

def swap(...)
  @operations << -> middleware { middleware.swap(...) }
end

def unshift(...) 

def unshift(...)
  @operations << -> middleware { middleware.unshift(...) }
end

def use(...) 

def use(...)
  @operations << -> middleware { middleware.use(...) }
end