lib/action_dispatch/middleware/stack.rb in actionpack-4.2.11.3 vs lib/action_dispatch/middleware/stack.rb in actionpack-5.0.0.beta1

@@ -2,54 +2,31 @@
 require "active_support/dependencies"
 
 module ActionDispatch
   class MiddlewareStack
     class Middleware
-      attr_reader :args, :block, :name, :classcache
+      attr_reader :args, :block, :klass
 
-      def initialize(klass_or_name, *args, &block)
-        @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
+      def initialize(klass, args, block)
+        @klass = klass
+        @args  = args
+        @block = block
       end
 
-      def klass
-        @klass || classcache[@name]
-      end
+      def name; klass.name; end
 
-      def ==(middleware)
-        case middleware
-        when Middleware
-          klass == middleware.klass
-        when Class
-          klass == middleware
+      def inspect
+        if klass.is_a?(Class)
+          klass.to_s
         else
-          normalize(@name) == normalize(middleware)
+          klass.class.to_s
         end
       end
 
-      def inspect
-        klass.to_s
-      end
-
       def build(app)
         klass.new(app, *args, &block)
       end
-
-    private
-
-      def normalize(object)
-        object.to_s.strip.sub(/^::/, '')
-      end
     end
 
     include Enumerable
 
     attr_accessor :middlewares
@@ -73,23 +50,21 @@
 
     def [](i)
       middlewares[i]
     end
 
-    def unshift(*args, &block)
-      middleware = self.class::Middleware.new(*args, &block)
-      middlewares.unshift(middleware)
+    def unshift(klass, *args, &block)
+      middlewares.unshift(build_middleware(klass, args, block))
     end
 
     def initialize_copy(other)
       self.middlewares = other.middlewares.dup
     end
 
-    def insert(index, *args, &block)
+    def insert(index, klass, *args, &block)
       index = assert_index(index, :before)
-      middleware = self.class::Middleware.new(*args, &block)
-      middlewares.insert(index, middleware)
+      middlewares.insert(index, build_middleware(klass, args, block))
     end
 
     alias_method :insert_before, :insert
 
     def insert_after(index, *args, &block)
@@ -102,28 +77,48 @@
       insert(index, *args, &block)
       middlewares.delete_at(index + 1)
     end
 
     def delete(target)
-      middlewares.delete target
+      target = get_class target
+      middlewares.delete_if { |m| m.klass == target }
     end
 
-    def use(*args, &block)
-      middleware = self.class::Middleware.new(*args, &block)
-      middlewares.push(middleware)
+    def use(klass, *args, &block)
+      middlewares.push(build_middleware(klass, args, block))
     end
 
-    def build(app = nil, &block)
-      app ||= block
-      raise "MiddlewareStack#build requires an app" unless app
+    def build(app = Proc.new)
       middlewares.freeze.reverse.inject(app) { |a, e| e.build(a) }
     end
 
-  protected
+    private
 
     def assert_index(index, where)
-      i = index.is_a?(Integer) ? index : middlewares.index(index)
+      index = get_class index
+      i = index.is_a?(Integer) ? index : middlewares.index { |m| m.klass == index }
       raise "No such middleware to insert #{where}: #{index.inspect}" unless i
       i
+    end
+
+    def get_class(klass)
+      if klass.is_a?(String) || klass.is_a?(Symbol)
+        classcache = ActiveSupport::Dependencies::Reference
+        converted_klass = classcache[klass.to_s]
+        ActiveSupport::Deprecation.warn <<-eowarn
+Passing strings or symbols to the middleware builder is deprecated, please change
+them to actual class references.  For example:
+
+  "#{klass}" => #{converted_klass}
+
+        eowarn
+        converted_klass
+      else
+        klass
+      end
+    end
+
+    def build_middleware(klass, args, block)
+      Middleware.new(get_class(klass), args, block)
     end
   end
 end