stack.rb in actionpack-3.1.0.beta1

- old
+ new

@@ -1,29 +1,39 @@
 require "active_support/inflector/methods"
+require "active_support/dependencies"
 
 module ActionDispatch
-  class MiddlewareStack < Array
+  class MiddlewareStack
     class Middleware
-      attr_reader :args, :block
+      attr_reader :args, :block, :name, :classcache
 
       def initialize(klass_or_name, *args, &block)
-        @ref = ActiveSupport::Dependencies::Reference.new(klass_or_name)
+        @klass = nil
+
+        if klass_or_name.respond_to?(:name)
+          @klass = klass_or_name
+          @name  = @klass.name
+        else
+          @name  = klass_or_name.to_s
+        end
+
+        @classcache = ActiveSupport::Dependencies::Reference
         @args, @block = args, block
       end
 
       def klass
-        @ref.get
+        @klass || classcache[@name]
       end
 
       def ==(middleware)
         case middleware
         when Middleware
           klass == middleware.klass
         when Class
           klass == middleware
         else
-          normalize(@ref.name) == normalize(middleware)
+          normalize(@name) == normalize(middleware)
         end
       end
 
       def inspect
         klass.to_s
@@ -38,19 +48,43 @@
       def normalize(object)
         object.to_s.strip.sub(/^::/, '')
       end
     end
 
-    def initialize(*args, &block)
-      super(*args)
-      block.call(self) if block_given?
+    include Enumerable
+
+    attr_accessor :middlewares
+
+    def initialize(*args)
+      @middlewares = []
+      yield(self) if block_given?
     end
 
+    def each
+      @middlewares.each { |x| yield x }
+    end
+
+    def size
+      middlewares.size
+    end
+
+    def last
+      middlewares.last
+    end
+
+    def [](i)
+      middlewares[i]
+    end
+
+    def initialize_copy(other)
+      self.middlewares = other.middlewares.dup
+    end
+
     def insert(index, *args, &block)
       index = assert_index(index, :before)
       middleware = self.class::Middleware.new(*args, &block)
-      super(index, middleware)
+      middlewares.insert(index, middleware)
     end
 
     alias_method :insert_before, :insert
 
     def insert_after(index, *args, &block)
@@ -61,29 +95,28 @@
     def swap(target, *args, &block)
       insert_before(target, *args, &block)
       delete(target)
     end
 
+    def delete(target)
+      middlewares.delete target
+    end
+
     def use(*args, &block)
       middleware = self.class::Middleware.new(*args, &block)
-      push(middleware)
+      middlewares.push(middleware)
     end
 
-    def active
-      ActiveSupport::Deprecation.warn "All middlewares in the chain are active since the laziness " <<
-        "was removed from the middleware stack", caller
-    end
-
     def build(app = nil, &block)
       app ||= block
       raise "MiddlewareStack#build requires an app" unless app
-      reverse.inject(app) { |a, e| e.build(a) }
+      middlewares.reverse.inject(app) { |a, e| e.build(a) }
     end
 
   protected
 
     def assert_index(index, where)
-      i = index.is_a?(Integer) ? index : self.index(index)
+      i = index.is_a?(Integer) ? index : middlewares.index(index)
       raise "No such middleware to insert #{where}: #{index.inspect}" unless i
       i
     end
   end
 end