Class: Merb::Controller

Class | Merb::Controller
In: | lib/merb-core/controller/merb_controller.rb
Parent: | Merb::AbstractController

### Methods

_absolute_template_location _callable_methods _dispatch _filter_params _template_location absolute_url abstract! abstract? callable_actions hide_action inherited new overridable override! params rack_response relative_url resource show_action status status= subclasses_list url

### Included Modules

Merb::ResponderMixin Merb::ControllerMixin Merb::AuthenticationMixin Merb::ConditionalGetMixin

### Attributes

headers | [R] | :api: public
request | [R] | :api: public

### Public Class methods

_callable_methods()

All methods that are callable as actions.

#### Returns

Array: | A list of method names that are also actions

:api: private

_filter_params(params)

This is a stub method so plugins can implement param filtering if they want.

#### Parameters

params<Hash{Symbol => String}>: | A list of params

#### Returns

Hash{Symbol => String}: | A new list of params, filtered as desired

:api: plugin @overridable

abstract!()

Sets a controller to be "abstract" This controller will not be able to be routed to and is used for super classing only

:api: public

abstract?()

Asks a controller if it is abstract

### Returns

Boolean

     true if the controller has been set as abstract

:api: public

callable_actions()

The list of actions that are callable, after taking defaults, _hidden_actions and _shown_actions into consideration. It is calculated once, the first time an action is dispatched for this controller.

#### Returns

SimpleSet[String]: | A set of actions that should be callable.

:api: public

hide_action(*names)

Hide each of the given methods from being callable as actions.

#### Parameters

*names<~to-s>: | Actions that should be added to the list.

#### Returns

Array[String]: | An array of actions that should not be possible to dispatch to.

:api: public

inherited(klass)

#### Parameters

klass<Merb::Controller>: | The Merb::Controller inheriting from the base class.

:api: private

new(request, status=200, headers={'Content-Type' => 'text/html; charset=utf-8'})

Build a new controller.

Sets the variables that came in through the dispatch as available to the controller.

#### Parameters

request<Merb::Request>: | The Merb::Request that came in from Rack.
status<Integer>: | An integer code for the status. Defaults to 200.
headers<Hash{header => value}>: | A hash of headers to start the controller with. These headers can be overridden later by the headers method.

:api: plugin @overridable

overridable(*names)

#### Parameters

*names<Array[Symbol]>: | an Array of method names that should be overridable in application controllers.

#### Returns

Array: | The list of methods that are overridable

:api: plugin

override!(*names)

In an application controller, call override! before a method to indicate that you want to override a method in Merb::Controller that is not normally overridable.

Doing this may potentially break your app in a future release of Merb, and this is provided for users who are willing to take that risk. Without using override!, Merb will raise an error if you attempt to override a method defined on Merb::Controller.

This is to help users avoid a common mistake of defining an action that overrides a core method on Merb::Controller.

#### Parameters

*names<Array[Symbol]>: | An Array of methods that will override Merb core classes on purpose

#### Example

        class Kontroller < Application
          def status
            render
          end
        end

will raise a Merb::ReservedError, because status is a method on Merb::Controller.

        class Kontroller < Application
          override! :status
          def status
            some_code || super
          end
        end

will not raise a Merb::ReservedError, because the user specifically decided to override the status method.

:api: public

show_action(*names)

Makes each of the given methods being callable as actions. You can use this to make methods included from modules callable as actions.

#### Parameters

*names<~to-s>: | Actions that should be added to the list.

#### Returns

Array[String]: | An array of actions that should be dispatched to even if they would not otherwise be.

#### Example

      module Foo
        def self.included(base)
          base.show_action(:foo)
        end

        def foo
          # some actiony stuff
        end

        def foo_helper
          # this should not be an action
        end
      end

:api: public

subclasses_list()

:api: private

### Public Instance methods

_absolute_template_location(template, type)

The location to look for a template and mime-type. This is overridden from AbstractController, which defines a version of this that does not involve mime-types.

#### Parameters

template<String>: | The absolute path to a template - without mime and template extension. The mime-type extension is optional - it will be appended from the current content type if it hasn‘t been added already.
type<~to_s>: | The mime-type of the template that will be rendered. Defaults to nil.

:api: public

_dispatch(action=:index)

Dispatch the action.

#### Parameters

action<~to_s>: | An action to dispatch to. Defaults to :index.

#### Returns

String: | The string sent to the logger for time spent.

#### Raises

ActionNotFound: | The requested action was not found in class.

:api: plugin

_template_location(context, type, controller)

The location to look for a template for a particular controller, context, and mime-type. This is overridden from AbstractController, which defines a version of this that does not involve mime-types.

#### Parameters

context<~to_s>: | The name of the action or template basename that will be rendered.
type<~to_s>: | The mime-type of the template that will be rendered. Defaults to nil.
controller<~to_s>: | The name of the controller that will be rendered. Defaults to controller_name. This will be "layout" for rendering a layout.

#### Notes

By default, this renders ":controller/:action.:type". To change this, override it in your application class or in individual controllers.

:api: public @overridable

absolute_url(*args)

Returns the absolute url including the passed protocol and host.

This uses the same arguments as the url method, with added requirements of protocol and host options.

:api: public

params()

#### Returns

Hash: | The parameters from the request object

:api: public

rack_response()

The results of the controller‘s render, to be returned to Rack.

#### Returns

Array[Integer, Hash, String]: | The controller‘s status code, headers, and body

:api: private

relative_url(name, *args)

Alias for url

resource(*args)

Generates a URL for a single or nested resource.

#### Parameters

resources<Symbol,Object>: | The resources for which the URL

      should be generated. These resources should be specified
      in the router.rb file using #resources and #resource.

options<Hash>: | Any extra parameters that are needed to

      generate the URL.

#### Returns

String: | The generated URL.

#### Examples

Merb::Router.prepare do

      resources :users do
        resources :comments
      end

end

resource(:users) # => /users resource(@user) # => /users/10 resource(@user, :comments) # => /users/10/comments resource(@user, @comment) # => /users/10/comments/15 resource(:users, :new) # => /users/new resource(:@user, :edit) # => /users/10/edit

:api: public

status()

#### Returns

Fixnum: | The response status code

:api: public

status=(s)

Set the response status code.

#### Parameters

s<Fixnum, Symbol>: | A status-code or named http-status

:api: public

url(name, *args)

There are three possible ways to use this method. First, if you have a named route, you can specify the route as the first parameter as a symbol and any paramters in a hash. Second, you can generate the default route by just passing the params hash, just passing the params hash. Finally, you can use the anonymous parameters. This allows you to specify the parameters to a named route in the order they appear in the router.

#### Parameters(Named Route)

name<Symbol>: | The name of the route.
args<Hash>: | Parameters for the route generation.

#### Parameters(Default Route)

args<Hash>: | Parameters for the route generation. This route will use the default route.

#### Parameters(Anonymous Parameters)

name<Symbol>: | The name of the route.
args<Array>: | An array of anonymous parameters to generate the route with. These parameters are assigned to the route parameters in the order that they are passed.

#### Returns

String: | The generated URL.

#### Examples

Named Route

Merb::Router.prepare do

      match("/articles/:title").to(:controller => :articles, :action => :show).name("articles")

end

url(:articles, :title => "new_article")

Default Route

Merb::Router.prepare do

      default_routes

end

url(:controller => "articles", :action => "new")

Anonymous Paramters

Merb::Router.prepare do

      match("/articles/:year/:month/:title").to(:controller => :articles, :action => :show).name("articles")

end

url(:articles, 2008, 10, "test_article")

:api: public

[Validate]