vendor/rails/actionpack/lib/action_controller/middleware_stack.rb

   1 module ActionController
   2   class MiddlewareStack < Array
   3     class Middleware
   4       def self.new(klass, *args, &block)
   5         if klass.is_a?(self)
   6           klass
   7         else
   8           super
   9         end
  10       end
  11
  12       attr_reader :args, :block
  13
  14       def initialize(klass, *args, &block)
  15         @klass = klass
  16
  17         options = args.extract_options!
  18         if options.has_key?(:if)
  19           @conditional = options.delete(:if)
  20         else
  21           @conditional = true
  22         end
  23         args << options unless options.empty?
  24
  25         @args = args
  26         @block = block
  27       end
  28
  29       def klass
  30         if @klass.respond_to?(:call)
  31           @klass.call
  32         elsif @klass.is_a?(Class)
  33           @klass
  34         else
  35           @klass.to_s.constantize
  36         end
  37       rescue NameError
  38         @klass
  39       end
  40
  41       def active?
  42         return false unless klass
  43
  44         if @conditional.respond_to?(:call)
  45           @conditional.call
  46         else
  47           @conditional
  48         end
  49       end
  50
  51       def ==(middleware)
  52         case middleware
  53         when Middleware
  54           klass == middleware.klass
  55         when Class
  56           klass == middleware
  57         else
  58           klass == middleware.to_s.constantize
  59         end
  60       end
  61
  62       def inspect
  63         str = klass.to_s
  64         args.each { |arg| str += ", #{arg.inspect}" }
  65         str
  66       end
  67
  68       def build(app)
  69         if block
  70           klass.new(app, *build_args, &block)
  71         else
  72           klass.new(app, *build_args)
  73         end
  74       end
  75
  76       private
  77
  78         def build_args
  79           Array(args).map { |arg| arg.respond_to?(:call) ? arg.call : arg }
  80         end
  81     end
  82
  83     def initialize(*args, &block)
  84       super(*args)
  85       block.call(self) if block_given?
  86     end
  87
  88     def insert(index, *args, &block)
  89       index = self.index(index) unless index.is_a?(Integer)
  90       middleware = Middleware.new(*args, &block)
  91       super(index, middleware)
  92     end
  93
  94     alias_method :insert_before, :insert
  95
  96     def insert_after(index, *args, &block)
  97       index = self.index(index) unless index.is_a?(Integer)
  98       insert(index + 1, *args, &block)
  99     end
 100
 101     def swap(target, *args, &block)
 102       insert_before(target, *args, &block)
 103       delete(target)
 104     end
 105
 106     def use(*args, &block)
 107       middleware = Middleware.new(*args, &block)
 108       push(middleware)
 109     end
 110
 111     def active
 112       find_all { |middleware| middleware.active? }
 113     end
 114
 115     def build(app)
 116       active.reverse.inject(app) { |a, e| e.build(a) }
 117     end
 118   end
 119 end