package Catalyst;
use Moose;
-extends 'Catalyst::Component';
+extends 'Catalyst::Component', 'Class::Accessor::Fast';
+use Moose::Util qw/find_meta/;
use bytes;
use Scope::Upper ();
use Catalyst::Exception;
sub comp { shift->component(@_) }
sub req {
- # carp "the use of req() is deprecated in favour of request()";
my $self = shift; return $self->request(@_);
}
sub res {
- # carp "the use of res() is deprecated in favour of response()";
my $self = shift; return $self->response(@_);
}
# Remember to update this in Catalyst::Runtime as well!
-our $VERSION = '5.8000_06';
+our $VERSION = '5.80002';
{
my $dev_version = $VERSION =~ /_\d{2}$/;
sub detach { my $c = shift; $c->dispatcher->detach( $c, @_ ) }
-=head2 $c->visit( $action [, \@arguments ] )
+=head2 $c->visit( $action [, \@captures, \@arguments ] )
-=head2 $c->visit( $class, $method, [, \@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>,
sub visit { my $c = shift; $c->dispatcher->visit( $c, @_ ) }
-=head2 $c->go( $action [, \@arguments ] )
+=head2 $c->go( $action [, \@captures, \@arguments ] )
-=head2 $c->go( $class, $method, [, \@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> /
__PACKAGE__->config( { db => 'dsn:SQLite:foo.db' } );
You can also use a C<YAML>, C<XML> or C<Config::General> config file
-like myapp.yml in your applications home directory. See
+like myapp.conf in your applications home directory. See
L<Catalyst::Plugin::ConfigLoader>.
- ---
- db: dsn:SQLite:foo.db
+=head3 Cascading configuration.
+The config method is present on all Catalyst components, and configuration
+will be merged when an application is started. Configuration loaded with
+L<Catalyst::Plugin::ConfigLoader> takes precedence over other configuration,
+followed by configuration in your top level C<MyApp> class. These two
+configurations are merged, and then configuration data whos hash key matches a
+component name is merged with configuration for that component.
+
+The configuration for a component is then passed to the C<new> method when a
+component is constructed.
+
+For example:
+
+ MyApp->config({ 'Model::Foo' => { bar => 'baz', overrides => 'me' } });
+ MyApp::Model::Foo->config({ quux => 'frob', 'overrides => 'this' });
+
+will mean that C<MyApp::Model::Foo> receives the following data when
+constructed:
+
+ MyApp::Model::Foo->new({
+ bar => 'baz',
+ quux => 'frob',
+ overrides => 'me',
+ });
=cut
=head2 $c->debug
-Overload to enable debug messages (same as -Debug option).
+Returns 1 if debug mode is enabled, 0 otherwise.
-Note that this is a static method, not an accessor and should be overloaded
-by declaring "sub debug { 1 }" in your MyApp.pm, not by calling $c->debug(1).
+You can enable debug mode in several ways:
+
+=over
+
+=item With the environment variables MYAPP_DEBUG, or CATALYST_DEBUG
+
+=item The -Debug option in your MyApp.pm
+
+=item By declaring "sub debug { 1 }" in your MyApp.pm.
+
+=back
+
+Calling $c->debug(1) has no effect.
=cut
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.
+to add plugins like this B<will be removed> in a Catalyst 5.81.
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->warn(qq/Adding plugin using the ->plugin method is deprecated, and will be removed in Catalyst 5.9/);
-
+ # See block comment in t/unit_core_plugin.t
+ $class->log->warn(qq/Adding plugin using the ->plugin method is deprecated, and will be removed in Catalyst 5.81/);
+
$class->_register_plugin( $plugin, 1 );
eval { $plugin->import };
}
# Call plugins setup, this is stupid and evil.
+ # Also screws C3 badly on 5.10, hack to avoid.
{
no warnings qw/redefine/;
local *setup = sub { };
- $class->setup;
+ $class->setup unless $Catalyst::__AM_RESTARTING;
}
# Initialize our data structure
# applying modifiers).
Scope::Upper::reap(sub {
my $meta = Class::MOP::get_metaclass_by_name($class);
- $meta->make_immutable unless $meta->is_immutable;
+ $meta->make_immutable(replace_constructor => 1) 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.
+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 $captures = ( scalar @args && ref $args[0] eq 'ARRAY'
? shift(@args)
: [] );
- $path = $c->dispatcher->uri_for_action($path, $captures);
- return undef unless defined($path);
+ my $action = $path;
+ $path = $c->dispatcher->uri_for_action($action, $captures);
+ if (not defined $path) {
+ $c->log->debug(qq/Can't find uri_for action '$action' @$captures/)
+ if $c->debug;
+ return undef;
+ }
$path = '/' if $path eq '';
}
$res;
}
+=head2 $c->uri_for_action( $path, \@captures?, @args?, \%query_values? )
+
+=head2 $c->uri_for_action( $action, \@captures?, @args?, \%query_values? )
+
+=over
+
+=item $path
+
+A private path to the Catalyst action you want to create a URI for.
+
+This is a shortcut for calling C<< $c->dispatcher->get_action_by_path($path)
+>> and passing the resulting C<$action> and the remaining arguments to C<<
+$c->uri_for >>.
+
+You can also pass in a Catalyst::Action object, in which case it is passed to
+C<< $c->uri_for >>.
+
+=back
+
+=cut
+
+sub uri_for_action {
+ my ( $c, $path, @args ) = @_;
+ my $action = blessed($path)
+ ? $path
+ : $c->dispatcher->get_action_by_path($path);
+ unless (defined $action) {
+ croak "Can't find action for path '$path'";
+ }
+ return $c->uri_for( $action, @args );
+}
+
=head2 $c->welcome_message
Returns the Catalyst welcome HTML page.
push( @{ $c->stack }, $code );
+ no warnings 'recursion';
eval { $c->state( $code->execute( $class, $c, @{ $c->req->args } ) || 0 ) };
$c->_stats_finish_execute( $stats_info ) if $c->use_stats and $stats_info;
=cut
+sub _controller_init_base_classes {
+ my ($class, $component) = @_;
+ foreach my $class ( reverse @{ mro::get_linear_isa($component) } ) {
+ Moose->init_meta( for_class => $class )
+ unless find_meta($class);
+ }
+}
+
sub setup_component {
my( $class, $component ) = @_;
return $component;
}
+ # FIXME - Ugly, ugly hack to ensure the we force initialize non-moose base classes
+ # nearest to Catalyst::Controller first, no matter what order stuff happens
+ # to be loaded. There are TODO tests in Moose for this, see
+ # f2391d17574eff81d911b97be15ea51080500003
+ if ($component->isa('Catalyst::Controller')) {
+ $class->_controller_init_base_classes($component);
+ }
+
my $suffix = Catalyst::Utils::class2classsuffix( $component );
my $config = $class->config->{ $suffix } || {};
);
}
- Catalyst::Exception->throw(
- message =>
- qq/Couldn't instantiate component "$component", "COMPONENT() didn't return an object-like value"/
- ) unless blessed($instance);
-
+ unless (blessed $instance) {
+ my $metaclass = Moose::Util::find_meta($component);
+ my $method_meta = $metaclass->find_method_by_name('COMPONENT');
+ my $component_method_from = $method_meta->associated_metaclass->name;
+ my $value = defined($instance) ? $instance : 'undef';
+ Catalyst::Exception->throw(
+ message =>
+ qq/Couldn't instantiate component "$component", COMPONENT() method (from $component_method_from) didn't return an object-like value (value was $value)./
+ );
+ }
return $instance;
}
projects / catagits/Catalyst-Runtime.git / blobdiff