lib/Catalyst/IOC/Container.pm

   1 package Catalyst::IOC::Container;
   2 use Bread::Board;
   3 use Moose;
   4 use Config::Any;
   5 use Data::Visitor::Callback;
   6 use Catalyst::Utils ();
   7 use Devel::InnerPackage ();
   8 use Hash::Util qw/lock_hash/;
   9 use MooseX::Types::LoadableClass qw/ LoadableClass /;
  10 use Moose::Util;
  11 use Catalyst::IOC::ConstructorInjection;
  12 use Module::Pluggable::Object ();
  13 use namespace::autoclean;
  14
  15 extends 'Bread::Board::Container';
  16
  17 has config_local_suffix => (
  18     is      => 'ro',
  19     isa     => 'Str',
  20     default => 'local',
  21 );
  22
  23 has driver => (
  24     is      => 'ro',
  25     isa     => 'HashRef',
  26     default => sub { +{} },
  27 );
  28
  29 has file => (
  30     is      => 'ro',
  31     isa     => 'Str',
  32     default => '',
  33 );
  34
  35 has substitutions => (
  36     is      => 'ro',
  37     isa     => 'HashRef',
  38     default => sub { +{} },
  39 );
  40
  41 has application_name => (
  42     is      => 'ro',
  43     isa     => 'Str',
  44     default => 'MyApp',
  45 );
  46
  47 has sub_container_class => (
  48     isa     => LoadableClass,
  49     is      => 'ro',
  50     coerce  => 1,
  51     default => 'Catalyst::IOC::SubContainer',
  52     handles => {
  53         new_sub_container => 'new',
  54     }
  55 );
  56
  57 sub BUILD {
  58     my ( $self, $params ) = @_;
  59
  60     $self->add_service(
  61         $self->${\"build_${_}_service"}
  62     ) for qw/
  63         substitutions
  64         file
  65         driver
  66         application_name
  67         prefix
  68         extensions
  69         path
  70         config
  71         raw_config
  72         global_files
  73         local_files
  74         global_config
  75         local_config
  76         config_local_suffix
  77         config_path
  78         locate_components
  79     /;
  80
  81     $self->add_sub_container(
  82         $self->build_controller_subcontainer
  83     );
  84
  85     # FIXME - the config should be merged at this point
  86     my $config        = $self->resolve( service => 'config' );
  87     my $default_view  = $params->{default_view}  || $config->{default_view};
  88     my $default_model = $params->{default_model} || $config->{default_model};
  89
  90     $self->add_sub_container(
  91         $self->build_view_subcontainer(
  92             default_component => $default_view,
  93         )
  94     );
  95
  96     $self->add_sub_container(
  97         $self->build_model_subcontainer(
  98             default_component => $default_model,
  99         )
 100     );
 101 }
 102
 103 sub build_model_subcontainer {
 104     my $self = shift;
 105
 106     return $self->new_sub_container( @_,
 107         name => 'model',
 108     );
 109 }
 110
 111 sub build_view_subcontainer {
 112     my $self = shift;
 113
 114     return $self->new_sub_container( @_,
 115         name => 'view',
 116     );
 117 }
 118
 119 sub build_controller_subcontainer {
 120     my $self = shift;
 121
 122     return $self->new_sub_container(
 123         name => 'controller',
 124     );
 125 }
 126
 127 sub build_application_name_service {
 128     my $self = shift;
 129
 130     return Bread::Board::Literal->new( name => 'application_name', value => $self->application_name );
 131 }
 132
 133 sub build_driver_service {
 134     my $self = shift;
 135
 136     return Bread::Board::Literal->new( name => 'driver', value => $self->driver );
 137 }
 138
 139 sub build_file_service {
 140     my $self = shift;
 141
 142     return Bread::Board::Literal->new( name => 'file', value => $self->file );
 143 }
 144
 145 sub build_substitutions_service {
 146     my $self = shift;
 147
 148     return Bread::Board::Literal->new( name => 'substitutions', value => $self->substitutions );
 149 }
 150
 151 sub build_extensions_service {
 152     my $self = shift;
 153
 154     return Bread::Board::BlockInjection->new(
 155         lifecycle => 'Singleton',
 156         name => 'extensions',
 157         block => sub {
 158             return \@{Config::Any->extensions};
 159         },
 160     );
 161 }
 162
 163 sub build_prefix_service {
 164     my $self = shift;
 165
 166     return Bread::Board::BlockInjection->new(
 167         lifecycle => 'Singleton',
 168         name => 'prefix',
 169         block => sub {
 170             return Catalyst::Utils::appprefix( shift->param('application_name') );
 171         },
 172         dependencies => [ depends_on('application_name') ],
 173     );
 174 }
 175
 176 sub build_path_service {
 177     my $self = shift;
 178
 179     return Bread::Board::BlockInjection->new(
 180         lifecycle => 'Singleton',
 181         name => 'path',
 182         block => sub {
 183             my $s = shift;
 184
 185             return Catalyst::Utils::env_value( $s->param('application_name'), 'CONFIG' )
 186             || $s->param('file')
 187             || $s->param('application_name')->path_to( $s->param('prefix') );
 188         },
 189         dependencies => [ depends_on('file'), depends_on('application_name'), depends_on('prefix') ],
 190     );
 191 }
 192
 193 sub build_config_service {
 194     my $self = shift;
 195
 196     return Bread::Board::BlockInjection->new(
 197         lifecycle => 'Singleton',
 198         name => 'config',
 199         block => sub {
 200             my $s = shift;
 201
 202             my $v = Data::Visitor::Callback->new(
 203                 plain_value => sub {
 204                     return unless defined $_;
 205                     return $self->_config_substitutions( $s->param('application_name'), $s->param('substitutions'), $_ );
 206                 }
 207
 208             );
 209             $v->visit( $s->param('raw_config') );
 210         },
 211         dependencies => [ depends_on('application_name'), depends_on('raw_config'), depends_on('substitutions') ],
 212     );
 213 }
 214
 215 sub build_raw_config_service {
 216     my $self = shift;
 217
 218     return Bread::Board::BlockInjection->new(
 219         lifecycle => 'Singleton',
 220         name => 'raw_config',
 221         block => sub {
 222             my $s = shift;
 223
 224             my @global = @{$s->param('global_config')};
 225             my @locals = @{$s->param('local_config')};
 226
 227             my $config = {};
 228             for my $cfg (@global, @locals) {
 229                 for (keys %$cfg) {
 230                     $config = Catalyst::Utils::merge_hashes( $config, $cfg->{$_} );
 231                 }
 232             }
 233             return $config;
 234         },
 235         dependencies => [ depends_on('global_config'), depends_on('local_config') ],
 236     );
 237 }
 238
 239 sub build_global_files_service {
 240     my $self = shift;
 241
 242     return Bread::Board::BlockInjection->new(
 243         lifecycle => 'Singleton',
 244         name => 'global_files',
 245         block => sub {
 246             my $s = shift;
 247
 248             my ( $path, $extension ) = @{$s->param('config_path')};
 249
 250             my @extensions = @{$s->param('extensions')};
 251
 252             my @files;
 253             if ( $extension ) {
 254                 die "Unable to handle files with the extension '${extension}'" unless grep { $_ eq $extension } @extensions;
 255                 push @files, $path;
 256             } else {
 257                 @files = map { "$path.$_" } @extensions;
 258             }
 259             return \@files;
 260         },
 261         dependencies => [ depends_on('extensions'), depends_on('config_path') ],
 262     );
 263 }
 264
 265 sub build_local_files_service {
 266     my $self = shift;
 267
 268     return Bread::Board::BlockInjection->new(
 269         lifecycle => 'Singleton',
 270         name => 'local_files',
 271         block => sub {
 272             my $s = shift;
 273
 274             my ( $path, $extension ) = @{$s->param('config_path')};
 275             my $suffix = $s->param('config_local_suffix');
 276
 277             my @extensions = @{$s->param('extensions')};
 278
 279             my @files;
 280             if ( $extension ) {
 281                 die "Unable to handle files with the extension '${extension}'" unless grep { $_ eq $extension } @extensions;
 282                 $path =~ s{\.$extension}{_$suffix.$extension};
 283                 push @files, $path;
 284             } else {
 285                 @files = map { "${path}_${suffix}.$_" } @extensions;
 286             }
 287             return \@files;
 288         },
 289         dependencies => [ depends_on('extensions'), depends_on('config_path'), depends_on('config_local_suffix') ],
 290     );
 291 }
 292
 293 sub build_global_config_service {
 294     my $self = shift;
 295
 296     return Bread::Board::BlockInjection->new(
 297         lifecycle => 'Singleton',
 298         name => 'global_config',
 299         block => sub {
 300             my $s = shift;
 301
 302             return Config::Any->load_files({
 303                 files       => $s->param('global_files'),
 304                 filter      => \&_fix_syntax,
 305                 use_ext     => 1,
 306                 driver_args => $s->param('driver'),
 307             });
 308         },
 309         dependencies => [ depends_on('global_files') ],
 310     );
 311 }
 312
 313 sub build_local_config_service {
 314     my $self = shift;
 315
 316     return Bread::Board::BlockInjection->new(
 317         lifecycle => 'Singleton',
 318         name => 'local_config',
 319         block => sub {
 320             my $s = shift;
 321
 322             return Config::Any->load_files({
 323                 files       => $s->param('local_files'),
 324                 filter      => \&_fix_syntax,
 325                 use_ext     => 1,
 326                 driver_args => $s->param('driver'),
 327             });
 328         },
 329         dependencies => [ depends_on('local_files') ],
 330     );
 331 }
 332
 333 sub build_config_path_service {
 334     my $self = shift;
 335
 336     return Bread::Board::BlockInjection->new(
 337         lifecycle => 'Singleton',
 338         name => 'config_path',
 339         block => sub {
 340             my $s = shift;
 341
 342             my $path = $s->param('path');
 343             my $prefix = $s->param('prefix');
 344
 345             my ( $extension ) = ( $path =~ m{\.(.{1,4})$} );
 346
 347             if ( -d $path ) {
 348                 $path =~ s{[\/\\]$}{};
 349                 $path .= "/$prefix";
 350             }
 351
 352             return [ $path, $extension ];
 353         },
 354         dependencies => [ depends_on('prefix'), depends_on('path') ],
 355     );
 356 }
 357
 358 sub build_config_local_suffix_service {
 359     my $self = shift;
 360
 361     return Bread::Board::BlockInjection->new(
 362         lifecycle => 'Singleton',
 363         name => 'config_local_suffix',
 364         block => sub {
 365             my $s = shift;
 366             my $suffix = Catalyst::Utils::env_value( $s->param('application_name'), 'CONFIG_LOCAL_SUFFIX' ) || $self->config_local_suffix;
 367
 368             return $suffix;
 369         },
 370         dependencies => [ depends_on('application_name') ],
 371     );
 372 }
 373
 374 sub build_locate_components_service {
 375     my $self = shift;
 376
 377     return Bread::Board::BlockInjection->new(
 378         lifecycle => 'Singleton',
 379         name      => 'locate_components',
 380         block     => sub {
 381             my $s      = shift;
 382             my $class  = $s->param('application_name');
 383             my $config = $s->param('config')->{ setup_components };
 384
 385             Catalyst::Exception->throw(
 386                 qq{You are using search_extra config option. That option is\n} .
 387                 qq{deprecated, please refer to the documentation for\n} .
 388                 qq{other ways of achieving the same results.\n}
 389             ) if delete $config->{ search_extra };
 390
 391             my @paths = qw( ::Controller ::C ::Model ::M ::View ::V );
 392
 393             my $locator = Module::Pluggable::Object->new(
 394                 search_path => [ map { s/^(?=::)/$class/; $_; } @paths ],
 395                 %$config
 396             );
 397
 398             return [ $locator->plugins ];
 399         },
 400         dependencies => [ depends_on('application_name'), depends_on('config') ],
 401     );
 402 }
 403
 404 sub setup_components {
 405     my $self = shift;
 406     my $class = $self->resolve( service => 'application_name' );
 407     my @comps = @{ $self->resolve( service => 'locate_components' ) };
 408     my %comps = map { $_ => 1 } @comps;
 409     my $deprecatedcatalyst_component_names = 0;
 410
 411     for my $component ( @comps ) {
 412
 413         # We pass ignore_loaded here so that overlay files for (e.g.)
 414         # Model::DBI::Schema sub-classes are loaded - if it's in @comps
 415         # we know M::P::O found a file on disk so this is safe
 416
 417         Catalyst::Utils::ensure_class_loaded( $component, { ignore_loaded => 1 } );
 418     }
 419
 420     for my $component (@comps) {
 421         $self->add_component( $component );
 422         # FIXME - $instance->expand_modules() is broken
 423         my @expanded_components = $self->expand_component_module( $component );
 424
 425         if (
 426             !$deprecatedcatalyst_component_names &&
 427             ($deprecatedcatalyst_component_names = $component =~ m/::[CMV]::/) ||
 428             ($deprecatedcatalyst_component_names = grep { /::[CMV]::/ } @expanded_components)
 429         ) {
 430             # FIXME - should I be calling warn here?
 431             # Maybe it's time to remove it, or become fatal
 432             $class->log->warn(qq{Your application is using the deprecated ::[MVC]:: type naming scheme.\n}.
 433                 qq{Please switch your class names to ::Model::, ::View:: and ::Controller: as appropriate.\n}
 434             );
 435         }
 436
 437         for my $component (@expanded_components) {
 438             $self->add_component( $component )
 439                 unless $comps{$component};
 440         }
 441     }
 442
 443     $self->get_sub_container('model')->make_single_default;
 444     $self->get_sub_container('view')->make_single_default;
 445 }
 446
 447 sub _fix_syntax {
 448     my $config     = shift;
 449     my @components = (
 450         map +{
 451             prefix => $_ eq 'Component' ? '' : $_ . '::',
 452             values => delete $config->{ lc $_ } || delete $config->{ $_ }
 453         },
 454         grep { ref $config->{ lc $_ } || ref $config->{ $_ } }
 455             qw( Component Model M View V Controller C Plugin )
 456     );
 457
 458     foreach my $comp ( @components ) {
 459         my $prefix = $comp->{ prefix };
 460         foreach my $element ( keys %{ $comp->{ values } } ) {
 461             $config->{ "$prefix$element" } = $comp->{ values }->{ $element };
 462         }
 463     }
 464 }
 465
 466 sub _config_substitutions {
 467     my ( $self, $name, $subs, $arg ) = @_;
 468
 469     $subs->{ HOME } ||= sub { shift->path_to( '' ); };
 470     $subs->{ ENV } ||=
 471         sub {
 472             my ( $c, $v ) = @_;
 473             if (! defined($ENV{$v})) {
 474                 Catalyst::Exception->throw( message =>
 475                     "Missing environment variable: $v" );
 476                 return "";
 477             } else {
 478                 return $ENV{ $v };
 479             }
 480         };
 481     $subs->{ path_to } ||= sub { shift->path_to( @_ ); };
 482     $subs->{ literal } ||= sub { return $_[ 1 ]; };
 483     my $subsre = join( '|', keys %$subs );
 484
 485     $arg =~ s{__($subsre)(?:\((.+?)\))?__}{ $subs->{ $1 }->( $name, $2 ? split( /,/, $2 ) : () ) }eg;
 486     return $arg;
 487 }
 488
 489 sub get_component_from_sub_container {
 490     my ( $self, $sub_container_name, $name, $c, @args ) = @_;
 491
 492     my $sub_container = $self->get_sub_container( $sub_container_name );
 493
 494     if (!$name) {
 495         my $default = $sub_container->default_component;
 496
 497         return $sub_container->get_component( $default, $c, @args )
 498             if $default && $sub_container->has_service( $default );
 499
 500         # FIXME - should I be calling $c->log->warn here?
 501         # this is never a controller, so this is safe
 502         $c->log->warn( "Calling \$c->$sub_container_name() is not supported unless you specify one of:" );
 503         $c->log->warn( "* \$c->config(default_$sub_container_name => 'the name of the default $sub_container_name to use')" );
 504         $c->log->warn( "* \$c->stash->{current_$sub_container_name} # the name of the view to use for this request" );
 505         $c->log->warn( "* \$c->stash->{current_${sub_container_name}_instance} # the instance of the $sub_container_name to use for this request" );
 506
 507         return;
 508     }
 509
 510     return $sub_container->get_component_regexp( $name, $c, @args )
 511         if ref $name;
 512
 513     return $sub_container->get_component( $name, $c, @args )
 514         if $sub_container->has_service( $name );
 515
 516     $c->log->warn(
 517         "Attempted to use $sub_container_name '$name', " .
 518         "but it does not exist"
 519     );
 520
 521     return;
 522 }
 523
 524 sub find_component {
 525     my ( $self, $component, $c, @args ) = @_;
 526     my ( $type, $name ) = _get_component_type_name($component);
 527     my @result;
 528
 529     return $self->get_component_from_sub_container(
 530         $type, $name, $c, @args
 531     ) if $type;
 532
 533     my $query = ref $component
 534               ? $component
 535               : qr{^$component$}
 536               ;
 537
 538     for my $subcontainer_name (qw/model view controller/) {
 539         my $subcontainer = $self->get_sub_container( $subcontainer_name );
 540         my @components   = $subcontainer->get_service_list;
 541         @result          = grep { m{$component} } @components;
 542
 543         return map { $subcontainer->get_component( $_, $c, @args ) } @result
 544             if @result;
 545     }
 546
 547     # FIXME - I guess I shouldn't be calling $c->components here
 548     # one last search for things like $c->comp(qr/::M::/)
 549     @result = $self->find_component_regexp(
 550         $c->components, $component, $c, @args
 551     ) if !@result and ref $component;
 552
 553     # it expects an empty list on failed searches
 554     return @result;
 555 }
 556
 557 sub find_component_regexp {
 558     my ( $self, $components, $component, @args ) = @_;
 559     my @result;
 560
 561     my @components = grep { m{$component} } keys %{ $components };
 562
 563     for (@components) {
 564         my ($type, $name) = _get_component_type_name($_);
 565
 566         push @result, $self->get_component_from_sub_container(
 567             $type, $name, @args
 568         ) if $type;
 569     }
 570
 571     return @result;
 572 }
 573
 574 # FIXME sorry for the name again :)
 575 sub get_components_types {
 576     my ( $self ) = @_;
 577     my @comps_types;
 578
 579     for my $sub_container_name (qw/model view controller/) {
 580         my $sub_container = $self->get_sub_container($sub_container_name);
 581         for my $service ( $sub_container->get_service_list ) {
 582             my $comp     = $self->resolve(service => $service);
 583             my $compname = ref $comp || $comp;
 584             my $type     = ref $comp ? 'instance' : 'class';
 585             push @comps_types, [ $compname, $type ];
 586         }
 587     }
 588
 589     return @comps_types;
 590 }
 591
 592 sub get_all_components {
 593     my $self = shift;
 594     my %components;
 595
 596     my $containers = {
 597         map { $_ => $self->get_sub_container($_) } qw(model view controller)
 598     };
 599
 600     for my $container (keys %$containers) {
 601         for my $component ($containers->{$container}->get_service_list) {
 602             my $comp = $containers->{$container}->resolve(
 603                 service => $component
 604             );
 605             my $comp_name = ref $comp || $comp;
 606             $components{$comp_name} = $comp;
 607         }
 608     }
 609
 610     return lock_hash %components;
 611 }
 612
 613 sub add_component {
 614     my ( $self, $component ) = @_;
 615     my ( $type, $name ) = _get_component_type_name($component);
 616
 617     return unless $type;
 618
 619     $self->get_sub_container($type)->add_service(
 620         Catalyst::IOC::ConstructorInjection->new(
 621             name      => $name,
 622             class     => $component,
 623             dependencies => [
 624                 depends_on( '/application_name' ),
 625                 depends_on( '/config' ),
 626             ],
 627             parameters => {
 628                 suffix => {
 629                     isa => 'Str',
 630                     default => Catalyst::Utils::class2classsuffix( $component ),
 631                 },
 632                 accept_context_args => {
 633                     isa => 'ArrayRef|Undef',
 634                     required => 0,
 635                     default => undef,
 636                 },
 637             },
 638         )
 639     );
 640 }
 641
 642 # FIXME: should this sub exist?
 643 # should it be moved to Catalyst::Utils,
 644 # or replaced by something already existing there?
 645 sub _get_component_type_name {
 646     my ( $component ) = @_;
 647
 648     my @parts = split /::/, $component;
 649
 650     while (my $type = shift @parts) {
 651         return ('controller', join '::', @parts)
 652             if $type =~ /^(c|controller)$/i;
 653
 654         return ('model', join '::', @parts)
 655             if $type =~ /^(m|model)$/i;
 656
 657         return ('view', join '::', @parts)
 658             if $type =~ /^(v|view)$/i;
 659     }
 660
 661     return (undef, $component);
 662 }
 663
 664 sub expand_component_module {
 665     my ( $class, $module ) = @_;
 666     return Devel::InnerPackage::list_packages( $module );
 667 }
 668
 669 1;
 670
 671 __END__
 672
 673 =pod
 674
 675 =head1 NAME
 676
 677 Catalyst::Container - IOC for Catalyst components
 678
 679 =head1 SYNOPSIS
 680
 681 =head1 DESCRIPTION
 682
 683 =head1 METHODS
 684
 685 =head1 Building Containers
 686
 687 =head2 build_model_subcontainer
 688
 689 Container that stores all models.
 690
 691 =head2 build_view_subcontainer
 692
 693 Container that stores all views.
 694
 695 =head2 build_controller_subcontainer
 696
 697 Container that stores all controllers.
 698
 699 =head1 Building Services
 700
 701 =head2 build_application_name_service
 702
 703 Name of the application (such as MyApp).
 704
 705 =head2 build_driver_service
 706
 707 Config options passed directly to the driver being used.
 708
 709 =head2 build_file_service
 710
 711 ?
 712
 713 =head2 build_substitutions_service
 714
 715 This method substitutes macros found with calls to a function. There are a
 716 number of default macros:
 717
 718 =over
 719
 720 =item * C<__HOME__> - replaced with C<$c-E<gt>path_to('')>
 721
 722 =item * C<__ENV(foo)__> - replaced with the value of C<$ENV{foo}>
 723
 724 =item * C<__path_to(foo/bar)__> - replaced with C<$c-E<gt>path_to('foo/bar')>
 725
 726 =item * C<__literal(__FOO__)__> - leaves __FOO__ alone (allows you to use
 727 C<__DATA__> as a config value, for example)
 728
 729 =back
 730
 731 The parameter list is split on comma (C<,>). You can override this method to
 732 do your own string munging, or you can define your own macros in
 733 C<MyApp-E<gt>config-E<gt>{ 'Plugin::ConfigLoader' }-E<gt>{ substitutions }>.
 734 Example:
 735
 736     MyApp->config->{ 'Plugin::ConfigLoader' }->{ substitutions } = {
 737         baz => sub { my $c = shift; qux( @_ ); }
 738     }
 739
 740 The above will respond to C<__baz(x,y)__> in config strings.
 741
 742 =head2 build_extensions_service
 743
 744 Config::Any's available config file extensions (e.g. xml, json, pl, etc).
 745
 746 =head2 build_prefix_service
 747
 748 The prefix, based on the application name, that will be used to lookup the
 749 config files (which will be in the format $prefix.$extension). If the app is
 750 MyApp::Foo, the prefix will be myapp_foo.
 751
 752 =head2 build_path_service
 753
 754 The path to the config file (or environment variable, if defined).
 755
 756 =head2 build_config_service
 757
 758 The resulting configuration for the application, after it has successfully
 759 been loaded, and all substitutions have been made.
 760
 761 =head2 build_raw_config_service
 762
 763 The merge of local_config and global_config hashes, before substitutions.
 764
 765 =head2 build_global_files_service
 766
 767 Gets all files for config that don't have the local_suffix, such as myapp.conf.
 768
 769 =head2 build_local_files_service
 770
 771 Gets all files for config that have the local_suffix, such as myapp_local.conf.
 772
 773 =head2 build_global_config_service
 774
 775 Reads config from global_files.
 776
 777 =head2 build_local_config_service
 778
 779 Reads config from local_files.
 780
 781 =head2 build_config_path_service
 782
 783 Splits the path to the config file, and returns on array ref containing
 784 the path to the config file minus the extension in the first position,
 785 and the extension in the second.
 786
 787 =head2 build_config_local_suffix_service
 788
 789 Determines the suffix of files used to override the main config. By default
 790 this value is C<local>, which will load C<myapp_local.conf>.  The suffix can
 791 be specified in the following order of preference:
 792
 793 =over
 794
 795 =item * C<$ENV{ MYAPP_CONFIG_LOCAL_SUFFIX }>
 796
 797 =item * C<$ENV{ CATALYST_CONFIG_LOCAL_SUFFIX }>
 798
 799 =back
 800
 801 The first one of these values found replaces the default of C<local> in the
 802 name of the local config file to be loaded.
 803
 804 For example, if C< $ENV{ MYAPP_CONFIG_LOCAL_SUFFIX }> is set to C<testing>,
 805 ConfigLoader will try and load C<myapp_testing.conf> instead of
 806 C<myapp_local.conf>.
 807
 808 =head2 build_locate_components_service
 809
 810 This method is meant to provide a list of component modules that should be
 811 setup for the application.  By default, it will use L<Module::Pluggable>.
 812
 813 Specify a C<setup_components> config option to pass additional options directly
 814 to L<Module::Pluggable>.
 815
 816 =head1 Other methods
 817
 818 =head2 get_component_from_sub_container($sub_container, $name, $c, @args)
 819
 820 Looks for components in a given subcontainer (such as controller, model or view), and returns the searched component. If $name is undef, it returns the default component (such as default_view, if $sub_container is 'view'). If $name is a regexp, it returns an array of matching components. Otherwise, it looks for the component with name $name.
 821
 822 =head2 get_components_types
 823
 824 =head2 get_all_components
 825
 826 Fetches all the components, in each of the sub_containers model, view and controller, and returns a readonly hash. The keys are the class names, and the values are the blessed objects. This is what is returned by $c->components.
 827
 828 =head2 add_component
 829
 830 Adds a component to the appropriate subcontainer. The subcontainer is guessed by the component name given.
 831
 832 =head2 find_component
 833
 834 Searches for components in all containers. If $component is the full class name, the subcontainer is guessed, and it gets the searched component in there. Otherwise, it looks for a component with that name in all subcontainers. If $component is a regexp, it calls the method below, find_component_regexp, and matches all components against that regexp.
 835
 836 =head2 find_component_regexp
 837
 838 Finds components that match a given regexp. Used internally, by find_component.
 839
 840 =head2 expand_component_module
 841
 842 Components found by C<locate_components> will be passed to this method, which
 843 is expected to return a list of component (package) names to be set up.
 844
 845 =head2 setup_components
 846
 847 =head1 AUTHORS
 848
 849 Catalyst Contributors, see Catalyst.pm
 850
 851 =head1 COPYRIGHT
 852
 853 This library is free software. You can redistribute it and/or modify it under
 854 the same terms as Perl itself.
 855
 856 =cut