1
0
Fork 0
mirror of https://github.com/rails/rails.git synced 2022-11-09 12:12:34 -05:00
rails--rails/actionpack/lib/action_controller/metal.rb

240 lines
6.5 KiB
Ruby
Raw Normal View History

require 'active_support/core_ext/array/extract_options'
require 'action_dispatch/middleware/stack'
2009-09-14 15:47:31 -04:00
module ActionController
# Extend ActionDispatch middleware stack to make it aware of options
# allowing the following syntax in controllers:
#
# class PostsController < ApplicationController
2012-10-27 16:05:27 -04:00
# use AuthenticationMiddleware, except: [:index, :show]
# end
#
class MiddlewareStack < ActionDispatch::MiddlewareStack #:nodoc:
class Middleware < ActionDispatch::MiddlewareStack::Middleware #:nodoc:
def initialize(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?
super
end
def valid?(action)
if @only.present?
@only.include?(action)
elsif @except.present?
!@except.include?(action)
else
true
end
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
end
2011-02-02 17:03:17 -05:00
# <tt>ActionController::Metal</tt> is the simplest possible controller, providing a
# valid Rack interface without the additional niceties provided by
2011-02-02 17:03:17 -05:00
# <tt>ActionController::Base</tt>.
#
2011-02-02 17:03:17 -05:00
# A sample metal controller might look like this:
#
# class HelloController < ActionController::Metal
# def index
# self.response_body = "Hello World!"
# end
# end
#
2011-02-02 17:03:17 -05:00
# And then to route requests to your metal controller, you would add
# something like this to <tt>config/routes.rb</tt>:
#
# get 'hello', to: HelloController.action(:index)
#
2011-02-02 17:03:17 -05:00
# The +action+ method returns a valid Rack application for the \Rails
# router to dispatch to.
#
# == Rendering Helpers
#
2011-02-02 17:03:17 -05:00
# <tt>ActionController::Metal</tt> by default provides no utilities for rendering
# views, partials, or other responses aside from explicitly calling of
2011-02-02 17:03:17 -05:00
# <tt>response_body=</tt>, <tt>content_type=</tt>, and <tt>status=</tt>. 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
2011-02-02 17:03:17 -05:00
# append_view_path "#{Rails.root}/app/views"
#
# def index
# render "hello/index"
# end
# end
#
# == Redirection Helpers
#
2011-02-02 17:03:17 -05:00
# To add redirection helpers to your metal controller, do the following:
#
# class HelloController < ActionController::Metal
# include ActionController::Redirecting
2011-02-02 17:27:27 -05:00
# include Rails.application.routes.url_helpers
#
# def index
2011-02-02 17:27:27 -05:00
# redirect_to root_url
# end
# end
#
# == Other Helpers
#
2011-02-02 17:27:27 -05:00
# You can refer to the modules included in <tt>ActionController::Base</tt> to see
# other features you can bring into your metal controller.
#
class Metal < AbstractController::Base
abstract!
attr_internal_writer :env
def env
@_env ||= {}
end
# Returns the last part of the controller's name, underscored, without the ending
# <tt>Controller</tt>. For instance, PostsController returns <tt>posts</tt>.
# Namespaces are left out, so Admin::PostsController returns <tt>posts</tt> as well.
#
# ==== Returns
# * <tt>string</tt>
def self.controller_name
2012-09-17 01:43:46 -04:00
@controller_name ||= name.demodulize.sub(/Controller$/, '').underscore
end
# Delegates to the class' <tt>controller_name</tt>
def controller_name
self.class.controller_name
end
# The details below can be overridden to support a specific
# Request and Response object. The default ActionController::Base
# implementation includes RackDelegation, which makes a request
# and response object available. You might wish to control the
# environment and response manually for performance reasons.
2010-03-17 02:24:00 -04:00
attr_internal :headers, :response, :request
delegate :session, :to => "@_request"
def initialize
@_headers = {"Content-Type" => "text/html"}
@_status = 200
2010-09-24 15:52:47 -04:00
@_request = nil
@_response = nil
2010-09-27 18:39:10 -04:00
@_routes = nil
super
end
def params
@_params ||= request.parameters
end
def params=(val)
@_params = val
end
# Basic implementations for content_type=, location=, and headers are
# provided to reduce the dependency on the RackDelegation module
# in Renderer and Redirector.
2010-09-24 15:52:47 -04:00
def content_type=(type)
headers["Content-Type"] = type.to_s
end
def content_type
headers["Content-Type"]
end
def location
headers["Location"]
end
def location=(url)
headers["Location"] = url
end
# basic url_for that can be overridden for more robust functionality
def url_for(string)
string
end
2010-03-17 02:24:00 -04:00
def status
@_status
end
def status=(status)
@_status = Rack::Utils.status_code(status)
end
def response_body=(body)
body = [body] unless body.nil? || body.respond_to?(:each)
super
end
2012-01-19 13:52:10 -05:00
def performed?
response_body || (response && response.committed?)
2012-01-19 13:52:10 -05:00
end
def dispatch(name, request) #:nodoc:
@_request = request
@_env = request.env
@_env['action_controller.instance'] = self
process(name)
to_a
end
def to_a #:nodoc:
response ? response.to_a : [status, headers, response_body]
end
2010-01-31 21:32:28 -05:00
class_attribute :middleware_stack
self.middleware_stack = ActionController::MiddlewareStack.new
2010-01-31 21:32:28 -05:00
2012-09-17 02:15:03 -04:00
def self.inherited(base) # :nodoc:
2012-09-17 04:42:22 -04:00
base.middleware_stack = middleware_stack.dup
super
2010-01-31 21:32:28 -05:00
end
2009-09-12 14:51:15 -04:00
2012-09-17 02:15:03 -04:00
# 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)
2009-09-12 14:51:15 -04:00
end
2012-09-17 02:15:03 -04:00
# Alias for +middleware_stack+.
2009-09-12 14:51:15 -04:00
def self.middleware
middleware_stack
end
2012-09-17 02:15:03 -04:00
# 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
2012-09-17 02:15:03 -04:00
# Returns a Rack endpoint for the given action name.
def self.action(name, klass = ActionDispatch::Request)
middleware_stack.build(name.to_s) do |env|
new.dispatch(name, klass.new(env))
end
end
def _status_code
@_status
end
end
end