require 'active_support/core_ext/array/extract_options' require 'action_dispatch/middleware/stack' require 'active_support/deprecation' require 'action_dispatch/http/request' require 'action_dispatch/http/response' module ActionController # Extend ActionDispatch middleware stack to make it aware of options # allowing the following syntax in controllers: # # class PostsController < ApplicationController # use AuthenticationMiddleware, except: [:index, :show] # end # class MiddlewareStack < ActionDispatch::MiddlewareStack #:nodoc: class Middleware < ActionDispatch::MiddlewareStack::Middleware #:nodoc: def initialize(klass, args, actions, strategy, block) @actions = actions @strategy = strategy super(klass, args, block) end def valid?(action) @strategy.call @actions, action end end def build(action, app = Proc.new) action = action.to_s middlewares.reverse.inject(app) do |a, middleware| middleware.valid?(action) ? middleware.build(a) : a end end private INCLUDE = ->(list, action) { list.include? action } EXCLUDE = ->(list, action) { !list.include? action } NULL = ->(list, action) { true } def build_middleware(klass, args, block) options = args.extract_options! only = Array(options.delete(:only)).map(&:to_s) except = Array(options.delete(:except)).map(&:to_s) args << options unless options.empty? strategy = NULL list = nil if only.any? strategy = INCLUDE list = only elsif except.any? strategy = EXCLUDE list = except end Middleware.new(get_class(klass), args, list, strategy, block) end end # ActionController::Metal is the simplest possible controller, providing a # valid Rack interface without the additional niceties provided by # ActionController::Base. # # A sample metal controller might look like this: # # class HelloController < ActionController::Metal # def index # self.response_body = "Hello World!" # end # end # # And then to route requests to your metal controller, you would add # something like this to config/routes.rb: # # get 'hello', to: HelloController.action(:index) # # The +action+ method returns a valid Rack application for the \Rails # router to dispatch to. # # == Rendering Helpers # # ActionController::Metal by default provides no utilities for rendering # views, partials, or other responses aside from explicitly calling of # response_body=, content_type=, and status=. To # add the render helpers you're used to having in a normal controller, you # can do the following: # # class HelloController < ActionController::Metal # include AbstractController::Rendering # include ActionView::Layouts # append_view_path "#{Rails.root}/app/views" # # def index # render "hello/index" # end # end # # == Redirection Helpers # # To add redirection helpers to your metal controller, do the following: # # class HelloController < ActionController::Metal # include ActionController::Redirecting # include Rails.application.routes.url_helpers # # def index # redirect_to root_url # end # end # # == Other Helpers # # You can refer to the modules included in ActionController::Base to see # other features you can bring into your metal controller. # class Metal < AbstractController::Base abstract! def env @_request.env end deprecate :env # Returns the last part of the controller's name, underscored, without the ending # Controller. For instance, PostsController returns posts. # Namespaces are left out, so Admin::PostsController returns posts as well. # # ==== Returns # * string def self.controller_name @controller_name ||= name.demodulize.sub(/Controller$/, '').underscore end def self.make_response!(request) ActionDispatch::Response.new.tap do |res| res.request = request end end def self.build_with_env(env = {}) #:nodoc: new.tap { |c| c.set_request! ActionDispatch::Request.new(env) c.set_response! make_response!(c.request) } end # Delegates to the class' controller_name def controller_name self.class.controller_name end attr_internal :response, :request delegate :session, :to => "@_request" delegate :headers, :status=, :location=, :content_type=, :status, :location, :content_type, :to => "@_response" def initialize @_request = nil @_response = nil @_routes = nil super end def params @_params ||= request.parameters end def params=(val) @_params = val end alias :response_code :status # :nodoc: # Basic url_for that can be overridden for more robust functionality def url_for(string) string end def response_body=(body) body = [body] unless body.nil? || body.respond_to?(:each) response.body = body super end # Tests if render or redirect has already happened. def performed? response_body || response.committed? end def dispatch(name, request, response) #:nodoc: set_request!(request) set_response!(response) process(name) to_a end def set_response!(response) # :nodoc: @_response = response end def set_request!(request) #:nodoc: @_request = request @_request.controller_instance = self end def to_a #:nodoc: response.to_a end def reset_session @_request.reset_session end class_attribute :middleware_stack self.middleware_stack = ActionController::MiddlewareStack.new def self.inherited(base) # :nodoc: base.middleware_stack = middleware_stack.dup super end # Pushes the given Rack middleware and its arguments to the bottom of the # middleware stack. def self.use(*args, &block) middleware_stack.use(*args, &block) end # Alias for +middleware_stack+. def self.middleware middleware_stack end # Makes the controller a Rack endpoint that runs the action in the given # +env+'s +action_dispatch.request.path_parameters+ key. def self.call(env) req = ActionDispatch::Request.new env action(req.path_parameters[:action]).call(env) end class << self; deprecate :call; end # Returns a Rack endpoint for the given action name. def self.action(name) if middleware_stack.any? middleware_stack.build(name) do |env| req = ActionDispatch::Request.new(env) res = make_response! req new.dispatch(name, req, res) end else lambda { |env| req = ActionDispatch::Request.new(env) res = make_response! req new.dispatch(name, req, res) } end end # Direct dispatch to the controller. Instantiates the controller, then # executes the action named +name+. def self.dispatch(name, req, res) if middleware_stack.any? middleware_stack.build(name) { |env| new.dispatch(name, req, res) }.call req.env else new.dispatch(name, req, res) end end end end