Mojolicious::Controller - Controller Base Class
use base 'Mojolicious::Controller';
Mojolicous::Controller is the base class for your Mojolicious controllers. It is also the default controller class for Mojolicious unless you set controller_class in your application.
controller_class
Mojolicious::Controller inherits all attributes from Mojo::Base and implements the following new ones.
app
my $app = $c->app; $c = $c->app(Mojolicious->new);
A reference back to the Mojolicious application that dispatched to this controller.
match
my $m = $c->match;
A Mojolicious::Routes::Match object containing the routes results for the current request.
tx
my $tx = $c->tx;
The transaction that is currently being processed, defaults to a Mojo::Transaction::HTTP object.
Mojolicious::Controller inherits all methods from Mojo::Base and implements the following new ones.
client
my $client = $c->client;
A Mojo::Client prepared for the current environment.
my $tx = $c->client->get('http://mojolicio.us'); $c->client->post_form('http://kraih.com/login' => {user => 'mojo'}); $c->client->get('http://mojolicio.us' => sub { my $client = shift; $c->render_data($client->res->body); })->start;
Some environments such as Mojo::Server::Daemon even allow async requests.
$c->client->async->get('http://mojolicio.us' => sub { my $client = shift; $c->render_data($client->res->body); })->start;
cookie
$c = $c->cookie(foo => 'bar'); $c = $c->cookie(foo => 'bar', {path => '/'}); my $value = $c->cookie('foo'); my @values = $c->cookie('foo');
Access request cookie values and create new response cookies.
finish
$c->finish;
Gracefully end WebSocket connection.
flash
my $flash = $c->flash; my $foo = $c->flash('foo'); $c = $c->flash({foo => 'bar'}); $c = $c->flash(foo => 'bar');
Data storage persistent for the next request, stored in the session.
$c->flash->{foo} = 'bar'; my $foo = $c->flash->{foo}; delete $c->flash->{foo};
on_finish
$c->on_finish(sub {...});
Callback signaling that the transaction has been finished.
$c->on_finish(sub { my $self = shift; });
on_message
$c = $c->on_message(sub {...});
Receive messages via WebSocket, only works if there is currently a WebSocket connection in progress.
$c->on_message(sub { my ($self, $message) = @_; });
param
my @names = $c->param; my $foo = $c->param('foo'); my @foo = $c->param('foo'); $c = $c->param(foo => 'ba;r');
Request parameters and routes captures.
redirect_to
$c = $c->redirect_to('named'); $c = $c->redirect_to('named', foo => 'bar'); $c = $c->redirect_to('/path'); $c = $c->redirect_to('http://127.0.0.1/foo/bar');
Prepare a 302 redirect response.
302
render
$c->render; $c->render(controller => 'foo', action => 'bar'); $c->render({controller => 'foo', action => 'bar'}); $c->render(text => 'Hello!'); $c->render(template => 'index'); $c->render(template => 'foo/index'); $c->render(template => 'index', format => 'html', handler => 'epl'); $c->render(handler => 'something'); $c->render('foo/bar'); $c->render('foo/bar', format => 'html');
This is a wrapper around Mojolicious::Renderer exposing pretty much all functionality provided by it. It will set a default template to use based on the controller and action name or fall back to the route name. You can call it with a hash of options which can be preceded by an optional template name. Note that all render arguments get localized, so stash values won't be changed after the render call.
render_data
$c->render_data($bits);
Render binary data, similar to render_text but data will not be encoded.
render_text
render_exception
$c->render_exception('Oops!'); $c->render_exception(Mojo::Exception->new('Oops!'));
Render the exception template exception.html.$handler and set the response status code to 500.
exception.html.$handler
500
render_inner
my $output = $c->render_inner; my $output = $c->render_inner('content'); my $output = $c->render_inner(content => 'Hello world!'); my $output = $c->render_inner(content => sub { 'Hello world!' });
Contains partial rendered templates, used for the renderers layout and extends features.
layout
extends
render_json
$c->render_json({foo => 'bar'}); $c->render_json([1, 2, -3]);
Render a data structure as JSON.
render_later
$c->render_later;
Disable auto rendering. Note that this method is EXPERIMENTAL and might change without warning!
render_not_found
$c->render_not_found; $c->render_not_found($resource);
Render the not found template not_found.html.$handler and set the response status code to 404.
not_found.html.$handler
404
render_partial
my $output = $c->render_partial; my $output = $c->render_partial(action => 'foo');
Same as render but returns the rendered result.
render_static
$c->render_static('images/logo.png'); $c->render_static('../lib/MyApp.pm');
Render a static file using Mojolicious::Static relative to the public directory of your application.
public
$c->render_text('Hello World!'); $c->render_text('Hello World', layout => 'green');
Render the given content as plain text, note that text will be encoded. See render_data for an alternative without encoding.
rendered
$c->rendered;
Finalize response and run after_dispatch plugin hook. Note that this method is EXPERIMENTAL and might change without warning!
after_dispatch
req
my $req = $c->req;
Alias for $c->tx->req. Usually refers to a Mojo::Message::Request object.
$c->tx->req
res
my $res = $c->res;
Alias for $c->tx->res. Usually refers to a Mojo::Message::Response object.
$c->tx->res
send_message
$c = $c->send_message('Hi there!');
Send a message via WebSocket, only works if there is currently a WebSocket connection in progress.
session
my $session = $c->session; my $foo = $c->session('foo'); $c = $c->session({foo => 'bar'}); $c = $c->session(foo => 'bar');
Persistent data storage, by default stored in a signed cookie. Note that cookies are generally limited to 4096 bytes of data.
$c->session->{foo} = 'bar'; my $foo = $c->session->{foo}; delete $c->session->{foo};
signed_cookie
$c = $c->signed_cookie(foo => 'bar'); $c = $c->signed_cookie(foo => 'bar', {path => '/'}); my $value = $c->signed_cookie('foo'); my @values = $c->signed_cookie('foo');
Access signed request cookie values and create new signed response cookies. Cookies failing signature verification will be automatically discarded.
stash
my $stash = $c->stash; my $foo = $c->stash('foo'); $c = $c->stash({foo => 'bar'}); $c = $c->stash(foo => 'bar');
Non persistent data storage and exchange.
$c->stash->{foo} = 'bar'; my $foo = $c->stash->{foo}; delete $c->stash->{foo};
url_for
my $url = $c->url_for; my $url = $c->url_for(controller => 'bar', action => 'baz'); my $url = $c->url_for('named', controller => 'bar', action => 'baz');
Generate a Mojo::URL for the current or a named route.
write
$c->write; $c->write('Hello!'); $c->write(sub {...}); $c->write('Hello!', sub {...});
Write dynamic content matching the corresponding Content-Length header chunk wise, the optional drain callback will be invoked once all data has been written to the kernel send buffer or equivalent.
Content-Length
$c->res->headers->content_length(6); $c->write('Hel'); $c->write('lo!');
Note that this method is EXPERIMENTAL and might change without warning!
write_chunk
$c->write_chunk; $c->write_chunk('Hello!'); $c->write_chunk(sub {...}); $c->write_chunk('Hello!', sub {...});
Write dynamic content chunk wise with the chunked Transfer-Encoding which doesn't require a Content-Length header, the optional drain callback will be invoked once all data has been written to the kernel send buffer or equivalent. Note that this method is EXPERIMENTAL and might change without warning!
chunked
Transfer-Encoding
$c->write_chunk('Hel'); $c->write_chunk('lo!'); $c->write_chunk('');
An empty chunk marks the end of the stream.
3 Hel 3 lo! 0
Mojolicious, Mojolicious::Guides, http://mojolicio.us.
To install Mojolicious, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Mojolicious
CPAN shell
perl -MCPAN -e shell install Mojolicious
For more information on module installation, please visit the detailed CPAN module installation guide.