our $START = time;
our $RECURSION = 1000;
our $DETACH = "catalyst_detach\n";
+our $GO = "catalyst_go\n";
__PACKAGE__->mk_classdata($_)
for qw/components arguments dispatcher engine log dispatcher_class
# Remember to update this in Catalyst::Runtime as well!
-our $VERSION = '5.7099_03';
+our $VERSION = '5.71000';
sub import {
my ( $class, @arguments ) = @_;
sub detach { my $c = shift; $c->dispatcher->detach( $c, @_ ) }
+=head2 $c->visit( $action [, \@captures, \@arguments ] )
+
+=head2 $c->visit( $class, $method, [, \@captures, \@arguments ] )
+
+Almost the same as C<forward>, but does a full dispatch, instead of just
+calling the new C<$action> / C<$class-E<gt>$method>. This means that C<begin>,
+C<auto> and the method you go to are called, just like a new request.
+
+In addition both C<< $c->action >> and C<< $c->namespace >> are localized.
+This means, for example, that $c->action methods such as C<name>, C<class> and
+C<reverse> return information for the visited action when they are invoked
+within the visited action. This is different from the behavior of C<forward>
+which continues to use the $c->action object from the caller action even when
+invoked from the callee.
+
+C<$c-E<gt>stash> is kept unchanged.
+
+In effect, C<visit> allows you to "wrap" another action, just as it
+would have been called by dispatching from a URL, while the analogous
+C<go> allows you to transfer control to another action as if it had
+been reached directly from a URL.
+
+=cut
+
+sub visit { my $c = shift; $c->dispatcher->visit( $c, @_ ) }
+
+=head2 $c->go( $action [, \@captures, \@arguments ] )
+
+=head2 $c->go( $class, $method, [, \@captures, \@arguments ] )
+
+Almost the same as C<detach>, but does a full dispatch like C<visit>,
+instead of just calling the new C<$action> /
+C<$class-E<gt>$method>. This means that C<begin>, C<auto> and the
+method you visit are called, just like a new request.
+
+C<$c-E<gt>stash> is kept unchanged.
+
+=cut
+
+sub go { my $c = shift; $c->dispatcher->go( $c, @_ ) }
+
=head2 $c->response
=head2 $c->res
my ( $c, $name, @prefixes ) = @_;
my $appclass = ref $c || $c;
my $filter = "^${appclass}::(" . join( '|', @prefixes ) . ')::';
+ $filter = qr/$filter/; # Compile regex now rather than once per loop
# map the original component name to the sub part that we will search against
my %eligible = map { my $n = $_; $n =~ s{^$appclass\::[^:]+::}{}; $_ => $n; }
# don't warn if we didn't find any results, it just might not exist
if( @result ) {
- my $msg = "Used regexp fallback for \$c->model('${name}'), which found '" .
+ # Disgusting hack to work out correct method name
+ my $warn_for = lc $prefixes[0];
+ my $msg = "Used regexp fallback for \$c->{$warn_for}('${name}'), which found '" .
(join '", "', @result) . "'. Relying on regexp fallback behavior for " .
"component resolution is unreliable and unsafe.";
my $short = $result[0];
$msg .= " You probably need to set '$short' instead of '${name}' in this " .
"component's config";
} else {
- $msg .= " You probably meant \$c->model('$short') instead of \$c->model{'${name}'}, " .
+ $msg .= " You probably meant \$c->${warn_for}('$short') instead of \$c->${warn_for}({'${name}'}), " .
"but if you really wanted to search, pass in a regexp as the argument " .
- "like so: \$c->model(qr/${name}/)";
+ "like so: \$c->${warn_for}(qr/${name}/)";
}
$c->log->warn( "${msg}$shortmess" );
}
my @plugins = map { "$_ " . ( $_->VERSION || '' ) } $class->registered_plugins;
if (@plugins) {
- my $t = Text::SimpleTable->new(74);
+ my $column_width = Catalyst::Utils::term_width() - 6;
+ my $t = Text::SimpleTable->new($column_width);
$t->row($_) for @plugins;
$class->log->debug( "Loaded plugins:\n" . $t->draw . "\n" );
}
$class->setup_components;
if ( $class->debug ) {
- my $t = Text::SimpleTable->new( [ 63, 'Class' ], [ 8, 'Type' ] );
+ my $column_width = Catalyst::Utils::term_width() - 8 - 9;
+ my $t = Text::SimpleTable->new( [ $column_width, 'Class' ], [ 8, 'Type' ] );
for my $comp ( sort keys %{ $class->components } ) {
my $type = ref $class->components->{$comp} ? 'instance' : 'class';
$t->row( $comp, $type );
=item $action
A Catalyst::Action object representing the Catalyst action you want to
-create a URI for. To get one for an action in the current controller,
-use C<< $c->action('someactionname') >>. To get one from different
-controller, fetch the controller using C<< $c->controller() >>, then
-call C<action_for> on it.
+create a URI for.
+
+To get an action object:
+
+ From another controller, anywhere:
+ C<< $c->controller('ControllerName')->action_for('someactionname') >>
+ Shorter styles useful in particular places:
+ In the current controller's action method:
+ C<< $self->action_for('someactionname') >>
+ From the view for currently dispatched action:
+ C<< $c->controller->action_for('someactionname') >>
+
This method must be used to create URIs for
L<Catalyst::DispatchType::Chained> actions.
Returns a L<URI> object.
## Ex 1: a path with args and a query parameter
- $c->uri_for('user/list', 'short', { page => 2});
+ $c->uri_for($c->controller('User')->action_for('list'), 'short', { page => 2});
## -> ($c->req->base is 'http://localhost:3000/'
URI->new('http://localhost:3000/user/list/short?page=2)
## outputs:
URI->new('http://localhost:3000/myuser/42/view')
+ ## Ex 3: this style is deprecated and should be omitted
+ $c->uri_for('user/list', 'short', { page => 2});
+ ## -> ($c->req->base is 'http://localhost:3000/'
+ URI->new('http://localhost:3000/user/list/short?page=2)
+
Creates a URI object using C<< $c->request->base >> and a path. If an
Action object is given instead of a path, the path is constructed
using C<< $c->dispatcher->uri_for_action >> and passing it the
they can save you a lot of work.</p>
<pre><code>script/${prefix}_create.pl -help</code></pre>
<p>Also, be sure to check out the vast and growing
- collection of <a href="http://cpansearch.perl.org/search?query=Catalyst%3A%3APlugin%3A%3A&mode=all">plugins for Catalyst on CPAN</a>;
+ collection of <a href="http://search.cpan.org/search?query=Catalyst">plugins for Catalyst on CPAN</a>;
you are likely to find what you need there.
</p>
if ( !ref($error) and $error eq $DETACH ) {
die $DETACH if($c->depth > 1);
}
+ elsif ( !ref($error) and $error eq $GO ) {
+ die $GO if($c->depth > 0);
+ }
else {
unless ( ref $error ) {
no warnings 'uninitialized';
omega: Andreas Marienborg
+Oleg Kostyuk <cub.uanic@gmail.com>
+
phaylon: Robert Sedlacek <phaylon@dunkelheit.at>
sky: Arthur Bergman
willert: Sebastian Willert <willert@cpan.org>
+batman: Jan Henning Thorsen <pm@flodhest.net>
+
=head1 LICENSE
This library is free software, you can redistribute it and/or modify it under
projects / catagits/Catalyst-Runtime.git / blobdiff