Class | Merb::AbstractController |
In: |
lib/merb-core/controller/abstract_controller.rb
|
Parent: | Object |
Note that the over-use of "_" in Controller methods is to avoid collisions with helpers, which will be pulled directly into controllers from now on.
before is a class method that allows you to specify before filters in your controllers. Filters can either be a symbol or string that corresponds to a method name to call, or a proc object. if it is a method name that method will be called and if it is a proc it will be called with an argument of self where self is the current controller object. When you use a proc as a filter it needs to take one parameter.
after is identical, but the filters are run after the action is invoked.
before :some_filter before :authenticate, :exclude => [:login, :signup] before :has_role, :with => ["Admin"], :exclude => [:index,:show] before Proc.new {|c| c.some_method }, :only => :foo before :authorize, :unless => logged_in?
You can use either :only => :actionname or :exclude => [:this, :that] but not both at once. :only will only run before the listed actions and :exclude will run for every action that is not listed.
Merb‘s before filter chain is very flexible. To halt the filter chain you use throw :halt. If throw is called with only one argument of :halt the return of the method filters_halted will be what is rendered to the view. You can overide filters_halted in your own controllers to control what it outputs. But the throw construct is much more powerful then just that. throw :halt can also take a second argument. Here is what that second arg can be and the behavior each type can have:
throw :halt, "You don't have permissions to do that!" throw :halt, render(:action => :access_denied)
throw :halt, :must_click_disclaimer
If the second arg is a Proc, it will be called and its return value will be what is rendered to the browser:
throw :halt, proc {|c| c.access_denied } throw :halt, proc {|c| Tidy.new(c.index) }
:only<Symbol, Array[Symbol]>: | A list of actions that this filter should apply to |
:exclude<Symbol, Array[Symbol]: | A list of actions that this filter should not apply to |
:if<Symbol, Proc>: | Only apply the filter if the method named after the symbol or calling the proc evaluates to true |
:unless<Symbol, Proc>: | Only apply the filter if the method named after the symbol or calling the proc evaluates to false |
Filter: | <Array[Symbol, (Symbol, String, Proc)]> |
_benchmarks | [RW] | |
_thrown_content | [RW] | |
action_name | [RW] | |
body | [RW] | |
content_type | [RW] | Stub so content-type support in RenderMixin doesn‘t throw errors |
roots<Array[Array]>: | Template roots as pairs of template root path and template location method. |
roots<Array[Array]>: | Template roots as pairs of template root path and template location method. |
Handles the template cache (which is used by BootLoader to cache the list of all templates).
template<String>: | The full path to a template to add to the list of available templates |
filter<Symbol, Proc>: | The filter to add. Defaults to nil. |
opts<Hash>: | Filter options (see class documentation under Filter Options). |
&block: | Currently ignored. |
If the filter already exists, its options will be replaced with opts.
filter<Symbol, Proc>: | The filter to add. Defaults to nil. |
opts<Hash>: | Filter options (see class documentation under Filter Options). |
&block: | A block to use as a filter if filter is nil. |
If the filter already exists, its options will be replaced with opts.
klass<Merb::AbstractController>: | The controller that is being inherited from Merb::AbstractController |
Skip an after filter that has been previously defined (perhaps in a superclass)
filter<Symbol>: | A filter name to skip. |
Skip a before filter that has been previously defined (perhaps in a superclass).
filter<Symbol>: | A filter name to skip. |
This method exists to provide an overridable hook for ActionArgs
action<~to_s>: | the action method to dispatch to |
rule<Hash>: | Rules for the filter (see below). |
action_name<~to_s>: | The name of the action to be called. |
:only<Array>: | Optional list of actions to fire. If given, action_name must be a part of it for this function to return true. |
:exclude<Array>: | Optional list of actions not to fire. If given, action_name must not be a part of it for this function to return true. |
Boolean: | True if the action should be called. |
filter_set<Array[Filter]>: | A set of filters in the form [[:filter, rule], [:filter, rule]] |
Symbol: | :filter_chain_completed. |
Filter rules can be Symbols, Strings, or Procs.
Symbols or Strings: | Call the method represented by the Symbol or String. |
Procs: | Execute the Proc, in the context of the controller (self will be the controller) |
This will dispatch the request, calling setup_session and finalize_session
action<~to_s>: | The action to dispatch to. This will be send‘ed in _call_action. Defaults to :to_s. |
MerbControllerError: | Invalid body content caught. |
condition<Symbol, Proc>: | The condition to evaluate. |
ArgumentError: | condition not a Symbol or Proc. |
Boolean: | True if the condition is met. |
If condition is a symbol, it will be send‘ed. If it is a Proc it will be called directly with self as an argument.
rule<Hash>: | Rules for the filter (see below). |
:if<Array>: | Optional conditions that must be met for the filter to fire. |
:unless<Array>: | Optional conditions that must not be met for the filter to fire. |
Boolean: | True if the conditions are met. |
This is called after the controller is instantiated to figure out where to for templates under the _template_root. Override this to define a new structure for your app.
context<~to_s>: | The controller context (the action or template name). |
type<~to_s>: | The content type. Defaults to nil. |
controller<~to_s>: | The name of the controller. Defaults to controller_name. |
String: | Indicating where to look for the template for the current controller, context, and content-type. |
The type is irrelevant for controller-types that don‘t support content-type negotiation, so we default to not include it in the superclass.
def _template_location "#{params[:controller]}.#{params[:action]}.#{content_type}" end
This would look for templates at controller.action.mime.type instead of controller/action.mime.type