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',
 633                     default => sub { [] },
 634                 },
 635             },
 636         )
 637     );
 638 }
 639
 640 # FIXME: should this sub exist?
 641 # should it be moved to Catalyst::Utils,
 642 # or replaced by something already existing there?
 643 sub _get_component_type_name {
 644     my ( $component ) = @_;
 645
 646     my @parts = split /::/, $component;
 647
 648     while (my $type = shift @parts) {
 649         return ('controller', join '::', @parts)
 650             if $type =~ /^(c|controller)$/i;
 651
 652         return ('model', join '::', @parts)
 653             if $type =~ /^(m|model)$/i;
 654
 655         return ('view', join '::', @parts)
 656             if $type =~ /^(v|view)$/i;
 657     }
 658
 659     return (undef, $component);
 660 }
 661
 662 sub expand_component_module {
 663     my ( $class, $module ) = @_;
 664     return Devel::InnerPackage::list_packages( $module );
 665 }
 666
 667 1;
 668
 669 __END__
 670
 671 =pod
 672
 673 =head1 NAME
 674
 675 Catalyst::Container - IOC for Catalyst components
 676
 677 =head1 SYNOPSIS
 678
 679 =head1 DESCRIPTION
 680
 681 =head1 METHODS
 682
 683 =head1 Containers
 684
 685 =head2 build_model_subcontainer
 686
 687 Container that stores all models.
 688
 689 =head2 build_view_subcontainer
 690
 691 Container that stores all views.
 692
 693 =head2 build_controller_subcontainer
 694
 695 Container that stores all controllers.
 696
 697 =head1 Services
 698
 699 =head2 build_application_name_service
 700
 701 Name of the application (such as MyApp).
 702
 703 =head2 build_driver_service
 704
 705 Config options passed directly to the driver being used.
 706
 707 =head2 build_file_service
 708
 709 ?
 710
 711 =head2 build_substitutions_service
 712
 713 Executes all the substitutions in config. See L</_config_substitutions> method.
 714
 715 =head2 build_extensions_service
 716
 717 =head2 build_prefix_service
 718
 719 =head2 build_path_service
 720
 721 =head2 build_config_service
 722
 723 =head2 build_raw_config_service
 724
 725 =head2 build_global_files_service
 726
 727 =head2 build_local_files_service
 728
 729 =head2 build_global_config_service
 730
 731 =head2 build_local_config_service
 732
 733 =head2 build_config_path_service
 734
 735 =head2 build_config_local_suffix_service
 736
 737 Determines the suffix of files used to override the main config. By default
 738 this value is C<local>, which will load C<myapp_local.conf>.  The suffix can
 739 be specified in the following order of preference:
 740
 741 =over
 742
 743 =item * C<$ENV{ MYAPP_CONFIG_LOCAL_SUFFIX }>
 744
 745 =item * C<$ENV{ CATALYST_CONFIG_LOCAL_SUFFIX }>
 746
 747 =back
 748
 749 The first one of these values found replaces the default of C<local> in the
 750 name of the local config file to be loaded.
 751
 752 For example, if C< $ENV{ MYAPP_CONFIG_LOCAL_SUFFIX }> is set to C<testing>,
 753 ConfigLoader will try and load C<myapp_testing.conf> instead of
 754 C<myapp_local.conf>.
 755
 756 =head2 get_component_from_sub_container($sub_container, $name, $c, @args)
 757
 758 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.
 759
 760 =head2 get_components_types
 761
 762 =head2 get_all_components
 763
 764 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.
 765
 766 =head2 add_component
 767
 768 Adds a component to the appropriate subcontainer. The subcontainer is guessed by the component name given.
 769
 770 =head2 find_component
 771
 772 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.
 773
 774 =head2 find_component_regexp
 775
 776 Finds components that match a given regexp. Used internally, by find_component.
 777
 778 =head2 _fix_syntax
 779
 780 =head2 _config_substitutions
 781
 782 This method substitutes macros found with calls to a function. There are a
 783 number of default macros:
 784
 785 =over
 786
 787 =item * C<__HOME__> - replaced with C<$c-E<gt>path_to('')>
 788
 789 =item * C<__ENV(foo)__> - replaced with the value of C<$ENV{foo}>
 790
 791 =item * C<__path_to(foo/bar)__> - replaced with C<$c-E<gt>path_to('foo/bar')>
 792
 793 =item * C<__literal(__FOO__)__> - leaves __FOO__ alone (allows you to use
 794 C<__DATA__> as a config value, for example)
 795
 796 =back
 797
 798 The parameter list is split on comma (C<,>). You can override this method to
 799 do your own string munging, or you can define your own macros in
 800 C<MyApp-E<gt>config-E<gt>{ 'Plugin::ConfigLoader' }-E<gt>{ substitutions }>.
 801 Example:
 802
 803     MyApp->config->{ 'Plugin::ConfigLoader' }->{ substitutions } = {
 804         baz => sub { my $c = shift; qux( @_ ); }
 805     }
 806
 807 The above will respond to C<__baz(x,y)__> in config strings.
 808
 809 =head2 $c->expand_component_module( $component, $setup_component_config )
 810
 811 Components found by C<locate_components> will be passed to this method, which
 812 is expected to return a list of component (package) names to be set up.
 813
 814 =head2 build_locate_components_service
 815
 816 This method is meant to provide a list of component modules that should be
 817 setup for the application.  By default, it will use L<Module::Pluggable>.
 818
 819 Specify a C<setup_components> config option to pass additional options directly
 820 to L<Module::Pluggable>.
 821
 822 =head2 setup_components
 823
 824 =head1 AUTHORS
 825
 826 Catalyst Contributors, see Catalyst.pm
 827
 828 =head1 COPYRIGHT
 829
 830 This library is free software. You can redistribute it and/or modify it under
 831 the same terms as Perl itself.
 832
 833 =cut