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, $class );
 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             $class->log->warn(qq{Your application is using the deprecated ::[MVC]:: type naming scheme.\n}.
 432                 qq{Please switch your class names to ::Model::, ::View:: and ::Controller: as appropriate.\n}
 433             );
 434         }
 435
 436         for my $component (@expanded_components) {
 437             $self->add_component( $component, $class )
 438                 unless $comps{$component};
 439         }
 440     }
 441
 442     $self->get_sub_container('model')->make_single_default;
 443     $self->get_sub_container('view')->make_single_default;
 444 }
 445
 446 sub _fix_syntax {
 447     my $config     = shift;
 448     my @components = (
 449         map +{
 450             prefix => $_ eq 'Component' ? '' : $_ . '::',
 451             values => delete $config->{ lc $_ } || delete $config->{ $_ }
 452         },
 453         grep { ref $config->{ lc $_ } || ref $config->{ $_ } }
 454             qw( Component Model M View V Controller C Plugin )
 455     );
 456
 457     foreach my $comp ( @components ) {
 458         my $prefix = $comp->{ prefix };
 459         foreach my $element ( keys %{ $comp->{ values } } ) {
 460             $config->{ "$prefix$element" } = $comp->{ values }->{ $element };
 461         }
 462     }
 463 }
 464
 465 sub _config_substitutions {
 466     my ( $self, $name, $subs, $arg ) = @_;
 467
 468     $subs->{ HOME } ||= sub { shift->path_to( '' ); };
 469     $subs->{ ENV } ||=
 470         sub {
 471             my ( $c, $v ) = @_;
 472             if (! defined($ENV{$v})) {
 473                 Catalyst::Exception->throw( message =>
 474                     "Missing environment variable: $v" );
 475                 return "";
 476             } else {
 477                 return $ENV{ $v };
 478             }
 479         };
 480     $subs->{ path_to } ||= sub { shift->path_to( @_ ); };
 481     $subs->{ literal } ||= sub { return $_[ 1 ]; };
 482     my $subsre = join( '|', keys %$subs );
 483
 484     $arg =~ s{__($subsre)(?:\((.+?)\))?__}{ $subs->{ $1 }->( $name, $2 ? split( /,/, $2 ) : () ) }eg;
 485     return $arg;
 486 }
 487
 488 sub get_component_from_sub_container {
 489     my ( $self, $sub_container_name, $name, $c, @args ) = @_;
 490
 491     my $sub_container = $self->get_sub_container( $sub_container_name );
 492
 493     if (!$name) {
 494         my $default = $sub_container->default_component;
 495
 496         return $sub_container->get_component( $default, $c, @args )
 497             if $default && $sub_container->has_service( $default );
 498
 499         # FIXME - should I be calling $c->log->warn here?
 500         # this is never a controller, so this is safe
 501         $c->log->warn( "Calling \$c->$sub_container_name() is not supported unless you specify one of:" );
 502         $c->log->warn( "* \$c->config(default_$sub_container_name => 'the name of the default $sub_container_name to use')" );
 503         $c->log->warn( "* \$c->stash->{current_$sub_container_name} # the name of the view to use for this request" );
 504         $c->log->warn( "* \$c->stash->{current_${sub_container_name}_instance} # the instance of the $sub_container_name to use for this request" );
 505
 506         return;
 507     }
 508
 509     return $sub_container->get_component_regexp( $name, $c, @args )
 510         if ref $name;
 511
 512     return $sub_container->get_component( $name, $c, @args )
 513         if $sub_container->has_service( $name );
 514
 515     $c->log->warn(
 516         "Attempted to use $sub_container_name '$name', " .
 517         "but it does not exist"
 518     );
 519
 520     return;
 521 }
 522
 523 sub find_component {
 524     my ( $self, $component, $c, @args ) = @_;
 525     my ( $type, $name ) = _get_component_type_name($component);
 526     my @result;
 527
 528     return $self->get_component_from_sub_container(
 529         $type, $name, $c, @args
 530     ) if $type;
 531
 532     my $query = ref $component
 533               ? $component
 534               : qr{^$component$}
 535               ;
 536
 537     for my $subcontainer_name (qw/model view controller/) {
 538         my $subcontainer = $self->get_sub_container( $subcontainer_name );
 539         my @components   = $subcontainer->get_service_list;
 540         @result          = grep { m{$component} } @components;
 541
 542         return map { $subcontainer->get_component( $_, $c, @args ) } @result
 543             if @result;
 544     }
 545
 546     # FIXME - I guess I shouldn't be calling $c->components here
 547     # one last search for things like $c->comp(qr/::M::/)
 548     @result = $self->find_component_regexp(
 549         $c->components, $component, $c, @args
 550     ) if !@result and ref $component;
 551
 552     # it expects an empty list on failed searches
 553     return @result;
 554 }
 555
 556 sub find_component_regexp {
 557     my ( $self, $components, $component, @args ) = @_;
 558     my @result;
 559
 560     my @components = grep { m{$component} } keys %{ $components };
 561
 562     for (@components) {
 563         my ($type, $name) = _get_component_type_name($_);
 564
 565         push @result, $self->get_component_from_sub_container(
 566             $type, $name, @args
 567         ) if $type;
 568     }
 569
 570     return @result;
 571 }
 572
 573 # FIXME sorry for the name again :)
 574 sub get_components_types {
 575     my ( $self ) = @_;
 576     my @comps_types;
 577
 578     for my $sub_container_name (qw/model view controller/) {
 579         my $sub_container = $self->get_sub_container($sub_container_name);
 580         for my $service ( $sub_container->get_service_list ) {
 581             my $comp     = $self->resolve(service => $service);
 582             my $compname = ref $comp || $comp;
 583             my $type     = ref $comp ? 'instance' : 'class';
 584             push @comps_types, [ $compname, $type ];
 585         }
 586     }
 587
 588     return @comps_types;
 589 }
 590
 591 sub get_all_components {
 592     my $self = shift;
 593     my %components;
 594
 595     my $containers = {
 596         map { $_ => $self->get_sub_container($_) } qw(model view controller)
 597     };
 598
 599     for my $container (keys %$containers) {
 600         for my $component ($containers->{$container}->get_service_list) {
 601             my $comp = $containers->{$container}->resolve(
 602                 service => $component
 603             );
 604             my $comp_name = ref $comp || $comp;
 605             $components{$comp_name} = $comp;
 606         }
 607     }
 608
 609     return lock_hash %components;
 610 }
 611
 612 sub add_component {
 613     my ( $self, $component, $class ) = @_;
 614     my ( $type, $name ) = _get_component_type_name($component);
 615
 616     return unless $type;
 617
 618     $self->get_sub_container($type)->add_service(
 619         Catalyst::IOC::ConstructorInjection->new(
 620             name      => $name,
 621             class     => $component,
 622             dependencies => [
 623                 depends_on( '/application_name' ),
 624                 depends_on( '/config' ),
 625             ],
 626             parameters => {
 627                 suffix => {
 628                     isa => 'Str',
 629                     default => Catalyst::Utils::class2classsuffix( $component ),
 630                 },
 631                 accept_context_args => {
 632                     isa => 'ArrayRef|Undef',
 633                     required => 0,
 634                     default => undef,
 635                 },
 636             },
 637         )
 638     );
 639 }
 640
 641 # FIXME: should this sub exist?
 642 # should it be moved to Catalyst::Utils,
 643 # or replaced by something already existing there?
 644 sub _get_component_type_name {
 645     my ( $component ) = @_;
 646
 647     my @parts = split /::/, $component;
 648
 649     while (my $type = shift @parts) {
 650         return ('controller', join '::', @parts)
 651             if $type =~ /^(c|controller)$/i;
 652
 653         return ('model', join '::', @parts)
 654             if $type =~ /^(m|model)$/i;
 655
 656         return ('view', join '::', @parts)
 657             if $type =~ /^(v|view)$/i;
 658     }
 659
 660     return (undef, $component);
 661 }
 662
 663 sub expand_component_module {
 664     my ( $class, $module ) = @_;
 665     return Devel::InnerPackage::list_packages( $module );
 666 }
 667
 668 1;
 669
 670 __END__
 671
 672 =pod
 673
 674 =head1 NAME
 675
 676 Catalyst::Container - IOC for Catalyst components
 677
 678 =head1 SYNOPSIS
 679
 680 =head1 DESCRIPTION
 681
 682 =head1 METHODS
 683
 684 =head1 Building Containers
 685
 686 =head2 build_model_subcontainer
 687
 688 Container that stores all models.
 689
 690 =head2 build_view_subcontainer
 691
 692 Container that stores all views.
 693
 694 =head2 build_controller_subcontainer
 695
 696 Container that stores all controllers.
 697
 698 =head1 Building Services
 699
 700 =head2 build_application_name_service
 701
 702 Name of the application (such as MyApp).
 703
 704 =head2 build_driver_service
 705
 706 Config options passed directly to the driver being used.
 707
 708 =head2 build_file_service
 709
 710 ?
 711
 712 =head2 build_substitutions_service
 713
 714 This method substitutes macros found with calls to a function. There are a
 715 number of default macros:
 716
 717 =over
 718
 719 =item * C<__HOME__> - replaced with C<$c-E<gt>path_to('')>
 720
 721 =item * C<__ENV(foo)__> - replaced with the value of C<$ENV{foo}>
 722
 723 =item * C<__path_to(foo/bar)__> - replaced with C<$c-E<gt>path_to('foo/bar')>
 724
 725 =item * C<__literal(__FOO__)__> - leaves __FOO__ alone (allows you to use
 726 C<__DATA__> as a config value, for example)
 727
 728 =back
 729
 730 The parameter list is split on comma (C<,>). You can override this method to
 731 do your own string munging, or you can define your own macros in
 732 C<MyApp-E<gt>config-E<gt>{ 'Plugin::ConfigLoader' }-E<gt>{ substitutions }>.
 733 Example:
 734
 735     MyApp->config->{ 'Plugin::ConfigLoader' }->{ substitutions } = {
 736         baz => sub { my $c = shift; qux( @_ ); }
 737     }
 738
 739 The above will respond to C<__baz(x,y)__> in config strings.
 740
 741 =head2 build_extensions_service
 742
 743 Config::Any's available config file extensions (e.g. xml, json, pl, etc).
 744
 745 =head2 build_prefix_service
 746
 747 The prefix, based on the application name, that will be used to lookup the
 748 config files (which will be in the format $prefix.$extension). If the app is
 749 MyApp::Foo, the prefix will be myapp_foo.
 750
 751 =head2 build_path_service
 752
 753 The path to the config file (or environment variable, if defined).
 754
 755 =head2 build_config_service
 756
 757 The resulting configuration for the application, after it has successfully
 758 been loaded, and all substitutions have been made.
 759
 760 =head2 build_raw_config_service
 761
 762 The merge of local_config and global_config hashes, before substitutions.
 763
 764 =head2 build_global_files_service
 765
 766 Gets all files for config that don't have the local_suffix, such as myapp.conf.
 767
 768 =head2 build_local_files_service
 769
 770 Gets all files for config that have the local_suffix, such as myapp_local.conf.
 771
 772 =head2 build_global_config_service
 773
 774 Reads config from global_files.
 775
 776 =head2 build_local_config_service
 777
 778 Reads config from local_files.
 779
 780 =head2 build_config_path_service
 781
 782 Splits the path to the config file, and returns on array ref containing
 783 the path to the config file minus the extension in the first position,
 784 and the extension in the second.
 785
 786 =head2 build_config_local_suffix_service
 787
 788 Determines the suffix of files used to override the main config. By default
 789 this value is C<local>, which will load C<myapp_local.conf>.  The suffix can
 790 be specified in the following order of preference:
 791
 792 =over
 793
 794 =item * C<$ENV{ MYAPP_CONFIG_LOCAL_SUFFIX }>
 795
 796 =item * C<$ENV{ CATALYST_CONFIG_LOCAL_SUFFIX }>
 797
 798 =back
 799
 800 The first one of these values found replaces the default of C<local> in the
 801 name of the local config file to be loaded.
 802
 803 For example, if C< $ENV{ MYAPP_CONFIG_LOCAL_SUFFIX }> is set to C<testing>,
 804 ConfigLoader will try and load C<myapp_testing.conf> instead of
 805 C<myapp_local.conf>.
 806
 807 =head2 build_locate_components_service
 808
 809 This method is meant to provide a list of component modules that should be
 810 setup for the application.  By default, it will use L<Module::Pluggable>.
 811
 812 Specify a C<setup_components> config option to pass additional options directly
 813 to L<Module::Pluggable>.
 814
 815 =head1 Other methods
 816
 817 =head2 get_component_from_sub_container($sub_container, $name, $c, @args)
 818
 819 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.
 820
 821 =head2 get_components_types
 822
 823 =head2 get_all_components
 824
 825 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.
 826
 827 =head2 add_component
 828
 829 Adds a component to the appropriate subcontainer. The subcontainer is guessed by the component name given.
 830
 831 =head2 find_component
 832
 833 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.
 834
 835 =head2 find_component_regexp
 836
 837 Finds components that match a given regexp. Used internally, by find_component.
 838
 839 =head2 $c->expand_component_module( $component, $setup_component_config )
 840
 841 Components found by C<locate_components> will be passed to this method, which
 842 is expected to return a list of component (package) names to be set up.
 843
 844 =head2 setup_components
 845
 846 =head1 AUTHORS
 847
 848 Catalyst Contributors, see Catalyst.pm
 849
 850 =head1 COPYRIGHT
 851
 852 This library is free software. You can redistribute it and/or modify it under
 853 the same terms as Perl itself.
 854
 855 =cut