package Catalyst;
-# we don't need really need this, but if we load it before MRO::Compat gets
-# loaded (via Moose and Class::MOP), we can avoid some nasty warnings
-use Class::C3;
-
use Moose;
-use Class::MOP::Object ();
extends 'Catalyst::Component';
use bytes;
-use B::Hooks::EndOfScope;
+use Scope::Upper ();
use Catalyst::Exception;
use Catalyst::Log;
use Catalyst::Request;
use URI ();
use URI::http;
use URI::https;
-use Scalar::Util qw/weaken blessed/;
+use Scalar::Util qw/weaken/;
use Tree::Simple qw/use_weak_refs/;
use Tree::Simple::Visitor::FindByUID;
use attributes;
use utf8;
-use Carp qw/croak carp/;
+use Carp qw/croak carp shortmess/;
BEGIN { require 5.008001; }
# Remember to update this in Catalyst::Runtime as well!
-our $VERSION = '5.8000_04';
+our $VERSION = '5.8000_06';
sub import {
my ( $class, @arguments ) = @_;
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
# don't warn if we didn't find any results, it just might not exist
if( @result ) {
- $c->log->warn( qq(Found results for "${name}" using regexp fallback.) );
- $c->log->warn( 'Relying on the regexp fallback behavior for component resolution is unreliable and unsafe.' );
- $c->log->warn( 'If you really want to search, pass in a regexp as the argument.' );
+ my $msg = "Used regexp fallback for \$c->model('${name}'), which found '" .
+ (join '", "', @result) . "'. Relying on regexp fallback behavior for " .
+ "component resolution is unreliable and unsafe.";
+ my $short = $result[0];
+ $short =~ s/.*?Model:://;
+ my $shortmess = Carp::shortmess('');
+ if ($shortmess =~ m#Catalyst/Plugin#) {
+ $msg .= " You probably need to set '$short' instead of '${name}' in this " .
+ "plugin's config";
+ } elsif ($shortmess =~ m#Catalyst/lib/(View|Controller)#) {
+ $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}'}, " .
+ "but if you really wanted to search, pass in a regexp as the argument " .
+ "like so: \$c->model(qr/${name}/)";
+ }
+ $c->log->warn( "${msg}$shortmess" );
}
return @result;
my( $comp, $rest ) = $c->_comp_search_prefixes( undef, qw/Model M/);
if( $rest ) {
- $c->log->warn( 'Calling $c->model() will return a random model unless you specify one of:' );
+ $c->log->warn( Carp::shortmess('Calling $c->model() will return a random model unless you specify one of:') );
$c->log->warn( '* $c->config->{default_model} # the name of the default model to use' );
$c->log->warn( '* $c->stash->{current_model} # the name of the model to use for this request' );
$c->log->warn( '* $c->stash->{current_model_instance} # the instance of the model to use for this request' );
- $c->log->warn( 'NB: in version 5.80, the "random" behavior will not work at all.' );
+ $c->log->warn( 'NB: in version 5.81, the "random" behavior will not work at all.' );
}
return $c->_filter_component( $comp );
$c->log->warn( '* $c->config->{default_view} # the name of the default view to use' );
$c->log->warn( '* $c->stash->{current_view} # the name of the view to use for this request' );
$c->log->warn( '* $c->stash->{current_view_instance} # the instance of the view to use for this request' );
- $c->log->warn( 'NB: in version 5.80, the "random" behavior will not work at all.' );
+ $c->log->warn( 'NB: in version 5.81, the "random" behavior will not work at all.' );
}
return $c->_filter_component( $comp );
return map { $c->_filter_component( $_, @args ) } @result if ref $name;
if( $result[ 0 ] ) {
- $c->log->warn( qq(Found results for "${name}" using regexp fallback.) );
+ $c->log->warn( Carp::shortmess(qq(Found results for "${name}" using regexp fallback)) );
$c->log->warn( 'Relying on the regexp fallback behavior for component resolution' );
$c->log->warn( 'is unreliable and unsafe. You have been warned' );
return $c->_filter_component( $result[ 0 ], @args );
my $orig = shift;
my $c = shift;
- $c->log->warn("Setting config after setup has been run is not a good idea.")
- if ( @_ and $c->setup_finished );
+ croak('Setting config after setup has been run is not allowed.')
+ if ( @_ and $c->setup_finished );
$c->$orig(@_);
};
=head2 $c->dispatcher
-Returns the dispatcher instance. Stringifies to class name. See
-L<Catalyst::Dispatcher>.
+Returns the dispatcher instance. See L<Catalyst::Dispatcher>.
=head2 $c->engine
-Returns the engine instance. Stringifies to the class name. See
-L<Catalyst::Engine>.
+Returns the engine instance. See L<Catalyst::Engine>.
=head2 UTILITY METHODS
=head2 $c->plugin( $name, $class, @args )
-Helper method for plugins. It creates a classdata accessor/mutator and
+Helper method for plugins. It creates a class data accessor/mutator and
loads and instantiates the given class.
MyApp->plugin( 'prototype', 'HTML::Prototype' );
$c->prototype->define_javascript_functions;
+
+B<Note:> This method of adding plugins is deprecated. The ability
+to add plugins like this B<will be removed> in a Catalyst 5.9.
+Please do not use this functionality in new code.
=cut
sub plugin {
my ( $class, $name, $plugin, @args ) = @_;
+
+ # See block comment in t/unit_core_plugin.t
+ $class->log->debug(qq/Adding plugin using the ->plugin method is deprecated, and will be removed in Catalyst 5.9/);
+
$class->_register_plugin( $plugin, 1 );
eval { $plugin->import };
sub setup {
my ( $class, @arguments ) = @_;
- $class->log->warn("Running setup twice is not a good idea.")
- if ( $class->setup_finished );
+ croak('Running setup more than once')
+ if ( $class->setup_finished );
unless ( $class->isa('Catalyst') ) {
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 );
# Note however that we have to do the work on scope end, so that method
# modifiers work correctly in MyApp (as you have to call setup _before_
# applying modifiers).
- on_scope_end {
- my $meta = $class->Moose::Object::meta();
+ Scope::Upper::reap(sub {
+ my $meta = Class::MOP::get_metaclass_by_name($class);
$meta->make_immutable unless $meta->is_immutable;
- };
+ }, Scope::Upper::SCOPE(1));
+
+ $class->setup_finalize;
+}
+
+
+=head2 $app->setup_finalize
+
+A hook to attach modifiers to.
+Using C< after setup => sub{}; > doesn't work, because of quirky things done for plugin setup.
+Also better than C< setup_finished(); >, as that is a getter method.
+
+ sub setup_finalize {
+ my $app = shift;
+
+ ## do stuff, i.e., determine a primary key column for sessions stored in a DB
+
+ $app->next::method(@_);
+
+
+ }
+
+=cut
+
+sub setup_finalize {
+ my ($class) = @_;
$class->setup_finished(1);
}
}
if ( $ENV{MOD_PERL} ) {
- my $meta = $class->Class::MOP::Object::meta();
+ my $meta = Class::MOP::get_metaclass_by_name($class);
# create the apache method
$meta->add_method('apache' => sub { shift->engine->apache });
Note that if the log has already been setup, by either a previous call to
C<setup_log> or by a call such as C<< __PACKAGE__->log( MyLogger->new ) >>,
-that this method won't actually set up the log.
+that this method won't actually set up the log object.
=cut
sub setup_log {
my ( $class, $levels ) = @_;
- my %levels;
+ $levels ||= '';
+ $levels =~ s/^\s+//;
+ $levels =~ s/\s+$//;
+ my %levels = map { $_ => 1 } split /\s*,\s*/, $levels || '';
+
unless ( $class->log ) {
- $levels ||= '';
- $levels =~ s/^\s+//;
- $levels =~ s/\s+$//;
- %levels = map { $_ => 1 } split /\s*,\s*/, $levels || '';
$class->log( Catalyst::Log->new(keys %levels) );
}
my $env_debug = Catalyst::Utils::env_value( $class, 'DEBUG' );
if ( defined($env_debug) or $levels{debug} ) {
- $class->Class::MOP::Object::meta()->add_method('debug' => sub { 1 });
+ Class::MOP::get_metaclass_by_name($class)->add_method('debug' => sub { 1 });
$class->log->debug('Debug messages enabled');
}
}
my $env = Catalyst::Utils::env_value( $class, 'STATS' );
if ( defined($env) ? $env : ($stats || $class->debug ) ) {
- $class->Class::MOP::Object::meta()->add_method('use_stats' => sub { 1 });
+ Class::MOP::get_metaclass_by_name($class)->add_method('use_stats' => sub { 1 });
$class->log->debug('Statistics enabled');
}
}
$proto->_plugins->{$plugin} = 1;
unless ($instant) {
no strict 'refs';
- if ( my $meta = $class->Class::MOP::Object::meta() ) {
+ if ( my $meta = Class::MOP::get_metaclass_by_name($class) ) {
my @superclasses = ($plugin, $meta->superclasses );
$meta->superclasses(@superclasses);
} else {
jcamacho: Juan Camacho
+jhannah: Jay Hannah <jay@jays.net>
+
Jody Belka
Johan Lindstrom
omega: Andreas Marienborg
+Oleg Kostyuk <cub.uanic@gmail.com>
+
phaylon: Robert Sedlacek <phaylon@dunkelheit.at>
rafl: Florian Ragwitz <rafl@debian.org>
the_jester: Jesse Sheidlower
+t0m: Tomas Doran <bobtfish@bobtfish.net>
+
Ulf Edvinsson
willert: Sebastian Willert <willert@cpan.org>