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 - t0m, how do you feel about this name?
 575 # also, do you think I should draw it here, or just return the data structure?
 576 sub get_components_names_types {
 577     my ( $self ) = @_;
 578     my @comps_names_types;
 579
 580     for my $sub_container_name (qw/model view controller/) {
 581         my $sub_container = $self->get_sub_container($sub_container_name);
 582         for my $service ( $sub_container->get_service_list ) {
 583             my $comp     = $self->resolve(service => $service);
 584             my $compname = ref $comp || $comp;
 585             my $type     = ref $comp ? 'instance' : 'class';
 586             push @comps_names_types, [ $compname, $type ];
 587         }
 588     }
 589
 590     return @comps_names_types;
 591 }
 592
 593 sub get_all_components {
 594     my $self = shift;
 595     my %components;
 596
 597     my $containers = {
 598         map { $_ => $self->get_sub_container($_) } qw(model view controller)
 599     };
 600
 601     for my $container (keys %$containers) {
 602         for my $component ($containers->{$container}->get_service_list) {
 603             my $comp = $containers->{$container}->resolve(
 604                 service => $component
 605             );
 606             my $comp_name = ref $comp || $comp;
 607             $components{$comp_name} = $comp;
 608         }
 609     }
 610
 611     return lock_hash %components;
 612 }
 613
 614 sub add_component {
 615     my ( $self, $component ) = @_;
 616     my ( $type, $name ) = _get_component_type_name($component);
 617
 618     return unless $type;
 619
 620     $self->get_sub_container($type)->add_service(
 621         Catalyst::IOC::ConstructorInjection->new(
 622             name      => $name,
 623             class     => $component,
 624             dependencies => [
 625                 depends_on( '/application_name' ),
 626                 depends_on( '/config' ),
 627             ],
 628             parameters => {
 629                 suffix => {
 630                     isa => 'Str',
 631                     default => Catalyst::Utils::class2classsuffix( $component ),
 632                 },
 633                 accept_context_args => {
 634                     isa => 'ArrayRef|Undef',
 635                     required => 0,
 636                     default => undef,
 637                 },
 638             },
 639         )
 640     );
 641 }
 642
 643 # FIXME: should this sub exist?
 644 # should it be moved to Catalyst::Utils,
 645 # or replaced by something already existing there?
 646 sub _get_component_type_name {
 647     my ( $component ) = @_;
 648
 649     my @parts = split /::/, $component;
 650
 651     while (my $type = shift @parts) {
 652         return ('controller', join '::', @parts)
 653             if $type =~ /^(c|controller)$/i;
 654
 655         return ('model', join '::', @parts)
 656             if $type =~ /^(m|model)$/i;
 657
 658         return ('view', join '::', @parts)
 659             if $type =~ /^(v|view)$/i;
 660     }
 661
 662     return (undef, $component);
 663 }
 664
 665 sub expand_component_module {
 666     my ( $class, $module ) = @_;
 667     return Devel::InnerPackage::list_packages( $module );
 668 }
 669
 670 1;
 671
 672 __END__
 673
 674 =pod
 675
 676 =head1 NAME
 677
 678 Catalyst::Container - IOC for Catalyst components
 679
 680 =head1 SYNOPSIS
 681
 682 =head1 DESCRIPTION
 683
 684 =head1 METHODS
 685
 686 =head1 Building Containers
 687
 688 =head2 build_model_subcontainer
 689
 690 Container that stores all models.
 691
 692 =head2 build_view_subcontainer
 693
 694 Container that stores all views.
 695
 696 =head2 build_controller_subcontainer
 697
 698 Container that stores all controllers.
 699
 700 =head1 Building Services
 701
 702 =head2 build_application_name_service
 703
 704 Name of the application (such as MyApp).
 705
 706 =head2 build_driver_service
 707
 708 Config options passed directly to the driver being used.
 709
 710 =head2 build_file_service
 711
 712 ?
 713
 714 =head2 build_substitutions_service
 715
 716 This method substitutes macros found with calls to a function. There are a
 717 number of default macros:
 718
 719 =over
 720
 721 =item * C<__HOME__> - replaced with C<$c-E<gt>path_to('')>
 722
 723 =item * C<__ENV(foo)__> - replaced with the value of C<$ENV{foo}>
 724
 725 =item * C<__path_to(foo/bar)__> - replaced with C<$c-E<gt>path_to('foo/bar')>
 726
 727 =item * C<__literal(__FOO__)__> - leaves __FOO__ alone (allows you to use
 728 C<__DATA__> as a config value, for example)
 729
 730 =back
 731
 732 The parameter list is split on comma (C<,>). You can override this method to
 733 do your own string munging, or you can define your own macros in
 734 C<MyApp-E<gt>config-E<gt>{ 'Plugin::ConfigLoader' }-E<gt>{ substitutions }>.
 735 Example:
 736
 737     MyApp->config->{ 'Plugin::ConfigLoader' }->{ substitutions } = {
 738         baz => sub { my $c = shift; qux( @_ ); }
 739     }
 740
 741 The above will respond to C<__baz(x,y)__> in config strings.
 742
 743 =head2 build_extensions_service
 744
 745 Config::Any's available config file extensions (e.g. xml, json, pl, etc).
 746
 747 =head2 build_prefix_service
 748
 749 The prefix, based on the application name, that will be used to lookup the
 750 config files (which will be in the format $prefix.$extension). If the app is
 751 MyApp::Foo, the prefix will be myapp_foo.
 752
 753 =head2 build_path_service
 754
 755 The path to the config file (or environment variable, if defined).
 756
 757 =head2 build_config_service
 758
 759 The resulting configuration for the application, after it has successfully
 760 been loaded, and all substitutions have been made.
 761
 762 =head2 build_raw_config_service
 763
 764 The merge of local_config and global_config hashes, before substitutions.
 765
 766 =head2 build_global_files_service
 767
 768 Gets all files for config that don't have the local_suffix, such as myapp.conf.
 769
 770 =head2 build_local_files_service
 771
 772 Gets all files for config that have the local_suffix, such as myapp_local.conf.
 773
 774 =head2 build_global_config_service
 775
 776 Reads config from global_files.
 777
 778 =head2 build_local_config_service
 779
 780 Reads config from local_files.
 781
 782 =head2 build_config_path_service
 783
 784 Splits the path to the config file, and returns on array ref containing
 785 the path to the config file minus the extension in the first position,
 786 and the extension in the second.
 787
 788 =head2 build_config_local_suffix_service
 789
 790 Determines the suffix of files used to override the main config. By default
 791 this value is C<local>, which will load C<myapp_local.conf>.  The suffix can
 792 be specified in the following order of preference:
 793
 794 =over
 795
 796 =item * C<$ENV{ MYAPP_CONFIG_LOCAL_SUFFIX }>
 797
 798 =item * C<$ENV{ CATALYST_CONFIG_LOCAL_SUFFIX }>
 799
 800 =back
 801
 802 The first one of these values found replaces the default of C<local> in the
 803 name of the local config file to be loaded.
 804
 805 For example, if C< $ENV{ MYAPP_CONFIG_LOCAL_SUFFIX }> is set to C<testing>,
 806 ConfigLoader will try and load C<myapp_testing.conf> instead of
 807 C<myapp_local.conf>.
 808
 809 =head2 build_locate_components_service
 810
 811 This method is meant to provide a list of component modules that should be
 812 setup for the application.  By default, it will use L<Module::Pluggable>.
 813
 814 Specify a C<setup_components> config option to pass additional options directly
 815 to L<Module::Pluggable>.
 816
 817 =head1 Other methods
 818
 819 =head2 get_component_from_sub_container($sub_container, $name, $c, @args)
 820
 821 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.
 822
 823 =head2 get_components_names_types
 824
 825 Gets all components from all containers and returns them as an array of arrayrefs containing the component name and the component type (i.e., whether it's an instance or a class).
 826
 827 =head2 get_all_components
 828
 829 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.
 830
 831 =head2 add_component
 832
 833 Adds a component to the appropriate subcontainer. The subcontainer is guessed by the component name given.
 834
 835 =head2 find_component
 836
 837 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.
 838
 839 =head2 find_component_regexp
 840
 841 Finds components that match a given regexp. Used internally, by find_component.
 842
 843 =head2 expand_component_module
 844
 845 Components found by C<locate_components> will be passed to this method, which
 846 is expected to return a list of component (package) names to be set up.
 847
 848 =head2 setup_components
 849
 850 =head1 AUTHORS
 851
 852 Catalyst Contributors, see Catalyst.pm
 853
 854 =head1 COPYRIGHT
 855
 856 This library is free software. You can redistribute it and/or modify it under
 857 the same terms as Perl itself.
 858
 859 =cut