fixing pod
[catagits/Catalyst-Runtime.git] / lib / Catalyst / IOC / Container.pm
index 040dc83..f4e99d3 100644 (file)
@@ -4,10 +4,13 @@ use Moose;
 use Config::Any;
 use Data::Visitor::Callback;
 use Catalyst::Utils ();
+use Devel::InnerPackage ();
 use Hash::Util qw/lock_hash/;
 use MooseX::Types::LoadableClass qw/ LoadableClass /;
 use Moose::Util;
 use Catalyst::IOC::BlockInjection;
+use Catalyst::IOC::ConstructorInjection;
+use Module::Pluggable::Object ();
 use namespace::autoclean;
 
 extends 'Bread::Board::Container';
@@ -36,7 +39,7 @@ has substitutions => (
     default => sub { +{} },
 );
 
-has name => (
+has application_name => (
     is      => 'ro',
     isa     => 'Str',
     default => 'MyApp',
@@ -61,7 +64,7 @@ sub BUILD {
         substitutions
         file
         driver
-        name
+        application_name
         prefix
         extensions
         path
@@ -73,6 +76,7 @@ sub BUILD {
         local_config
         config_local_suffix
         config_path
+        locate_components
     /;
 
     $self->add_sub_container(
@@ -121,10 +125,10 @@ sub build_controller_subcontainer {
     );
 }
 
-sub build_name_service {
+sub build_application_name_service {
     my $self = shift;
 
-    return Bread::Board::Literal->new( name => 'name', value => $self->name );
+    return Bread::Board::Literal->new( name => 'application_name', value => $self->application_name );
 }
 
 sub build_driver_service {
@@ -149,6 +153,7 @@ sub build_extensions_service {
     my $self = shift;
 
     return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
         name => 'extensions',
         block => sub {
             return \@{Config::Any->extensions};
@@ -160,11 +165,12 @@ sub build_prefix_service {
     my $self = shift;
 
     return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
         name => 'prefix',
         block => sub {
-            return Catalyst::Utils::appprefix( shift->param('name') );
+            return Catalyst::Utils::appprefix( shift->param('application_name') );
         },
-        dependencies => [ depends_on('name') ],
+        dependencies => [ depends_on('application_name') ],
     );
 }
 
@@ -172,15 +178,16 @@ sub build_path_service {
     my $self = shift;
 
     return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
         name => 'path',
         block => sub {
             my $s = shift;
 
-            return Catalyst::Utils::env_value( $s->param('name'), 'CONFIG' )
+            return Catalyst::Utils::env_value( $s->param('application_name'), 'CONFIG' )
             || $s->param('file')
-            || $s->param('name')->path_to( $s->param('prefix') );
+            || $s->param('application_name')->path_to( $s->param('prefix') );
         },
-        dependencies => [ depends_on('file'), depends_on('name'), depends_on('prefix') ],
+        dependencies => [ depends_on('file'), depends_on('application_name'), depends_on('prefix') ],
     );
 }
 
@@ -188,6 +195,7 @@ sub build_config_service {
     my $self = shift;
 
     return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
         name => 'config',
         block => sub {
             my $s = shift;
@@ -195,13 +203,13 @@ sub build_config_service {
             my $v = Data::Visitor::Callback->new(
                 plain_value => sub {
                     return unless defined $_;
-                    return $self->_config_substitutions( $s->param('name'), $s->param('substitutions'), $_ );
+                    return $self->_config_substitutions( $s->param('application_name'), $s->param('substitutions'), $_ );
                 }
 
             );
             $v->visit( $s->param('raw_config') );
         },
-        dependencies => [ depends_on('name'), depends_on('raw_config'), depends_on('substitutions') ],
+        dependencies => [ depends_on('application_name'), depends_on('raw_config'), depends_on('substitutions') ],
     );
 }
 
@@ -209,6 +217,7 @@ sub build_raw_config_service {
     my $self = shift;
 
     return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
         name => 'raw_config',
         block => sub {
             my $s = shift;
@@ -232,6 +241,7 @@ sub build_global_files_service {
     my $self = shift;
 
     return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
         name => 'global_files',
         block => sub {
             my $s = shift;
@@ -257,6 +267,7 @@ sub build_local_files_service {
     my $self = shift;
 
     return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
         name => 'local_files',
         block => sub {
             my $s = shift;
@@ -284,6 +295,7 @@ sub build_global_config_service {
     my $self = shift;
 
     return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
         name => 'global_config',
         block => sub {
             my $s = shift;
@@ -303,6 +315,7 @@ sub build_local_config_service {
     my $self = shift;
 
     return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
         name => 'local_config',
         block => sub {
             my $s = shift;
@@ -322,6 +335,7 @@ sub build_config_path_service {
     my $self = shift;
 
     return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
         name => 'config_path',
         block => sub {
             my $s = shift;
@@ -346,17 +360,93 @@ sub build_config_local_suffix_service {
     my $self = shift;
 
     return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
         name => 'config_local_suffix',
         block => sub {
             my $s = shift;
-            my $suffix = Catalyst::Utils::env_value( $s->param('name'), 'CONFIG_LOCAL_SUFFIX' ) || $self->config_local_suffix;
+            my $suffix = Catalyst::Utils::env_value( $s->param('application_name'), 'CONFIG_LOCAL_SUFFIX' ) || $self->config_local_suffix;
 
             return $suffix;
         },
-        dependencies => [ depends_on('name') ],
+        dependencies => [ depends_on('application_name') ],
     );
 }
 
+sub build_locate_components_service {
+    my $self = shift;
+
+    return Bread::Board::BlockInjection->new(
+        lifecycle => 'Singleton',
+        name      => 'locate_components',
+        block     => sub {
+            my $s      = shift;
+            my $class  = $s->param('application_name');
+            my $config = $s->param('config')->{ setup_components };
+
+            Catalyst::Exception->throw(
+                qq{You are using search_extra config option. That option is\n} .
+                qq{deprecated, please refer to the documentation for\n} .
+                qq{other ways of achieving the same results.\n}
+            ) if delete $config->{ search_extra };
+
+            my @paths = qw( ::Controller ::C ::Model ::M ::View ::V );
+
+            my $locator = Module::Pluggable::Object->new(
+                search_path => [ map { s/^(?=::)/$class/; $_; } @paths ],
+                %$config
+            );
+
+            # XXX think about ditching this sort entirely
+            my @comps = sort { length $a <=> length $b } $locator->plugins;
+
+            return \@comps;
+        },
+        dependencies => [ depends_on('application_name'), depends_on('config') ],
+    );
+}
+
+sub setup_components {
+    my $self = shift;
+    my $class = $self->resolve( service => 'application_name' );
+    my @comps = @{ $self->resolve( service => 'locate_components' ) };
+    my %comps = map { $_ => 1 } @comps;
+    my $deprecatedcatalyst_component_names = 0;
+
+    for my $component ( @comps ) {
+
+        # We pass ignore_loaded here so that overlay files for (e.g.)
+        # Model::DBI::Schema sub-classes are loaded - if it's in @comps
+        # we know M::P::O found a file on disk so this is safe
+
+        Catalyst::Utils::ensure_class_loaded( $component, { ignore_loaded => 1 } );
+    }
+
+    for my $component (@comps) {
+        $self->add_component( $component, $class );
+        # FIXME - $instance->expand_modules() is broken
+        my @expanded_components = $self->expand_component_module( $component );
+
+        if (
+            !$deprecatedcatalyst_component_names &&
+            ($deprecatedcatalyst_component_names = $component =~ m/::[CMV]::/) ||
+            ($deprecatedcatalyst_component_names = grep { /::[CMV]::/ } @expanded_components)
+        ) {
+            # FIXME - should I be calling warn here?
+            $class->log->warn(qq{Your application is using the deprecated ::[MVC]:: type naming scheme.\n}.
+                qq{Please switch your class names to ::Model::, ::View:: and ::Controller: as appropriate.\n}
+            );
+        }
+
+        for my $component (@expanded_components) {
+            $self->add_component( $component, $class )
+                unless $comps{$component};
+        }
+    }
+
+    $self->get_sub_container('model')->make_single_default;
+    $self->get_sub_container('view')->make_single_default;
+}
+
 sub _fix_syntax {
     my $config     = shift;
     my @components = (
@@ -530,9 +620,20 @@ sub add_component {
     return unless $type;
 
     $self->get_sub_container($type)->add_service(
-        Catalyst::IOC::BlockInjection->new(
-            name  => $name,
-            block => sub { $self->setup_component( $component, $class ) },
+        Catalyst::IOC::ConstructorInjection->new(
+            lifecycle => 'Singleton', # FIXME?
+            name      => $name,
+            class     => $component,
+            dependencies => [
+                depends_on( '/application_name' ),
+                depends_on( '/config' ),
+            ],
+            parameters => {
+                suffix => {
+                    isa => 'Str',
+                    default => Catalyst::Utils::class2classsuffix( $component ),
+                },
+            },
         )
     );
 }
@@ -559,48 +660,11 @@ sub _get_component_type_name {
     return (undef, $component);
 }
 
-# FIXME ugly and temporary
-# Just moved it here the way it was, so we can work on it here in the container
-sub setup_component {
-    my ( $self, $component, $class ) = @_;
-
-    unless ( $component->can( 'COMPONENT' ) ) {
-        return $component;
-    }
-
-    # FIXME I know this isn't the "Dependency Injection" way of doing things,
-    # its just temporary
-    my $suffix = Catalyst::Utils::class2classsuffix( $component );
-    my $config = $self->resolve(service => 'config')->{ $suffix } || {};
-
-    # Stash catalyst_component_name in the config here, so that custom COMPONENT
-    # methods also pass it. local to avoid pointlessly shitting in config
-    # for the debug screen, as $component is already the key name.
-    local $config->{catalyst_component_name} = $component;
-
-    my $instance = eval { $component->COMPONENT( $class, $config ); };
-
-    if ( my $error = $@ ) {
-        chomp $error;
-        Catalyst::Exception->throw(
-            message => qq/Couldn't instantiate component "$component", "$error"/
-        );
-    }
-    elsif (!blessed $instance) {
-        my $metaclass = Moose::Util::find_meta($component);
-        my $method_meta = $metaclass->find_method_by_name('COMPONENT');
-        my $component_method_from = $method_meta->associated_metaclass->name;
-        my $value = defined($instance) ? $instance : 'undef';
-        Catalyst::Exception->throw(
-            message =>
-            qq/Couldn't instantiate component "$component", COMPONENT() method (from $component_method_from) didn't return an object-like value (value was $value)./
-        );
-    }
-
-    return $instance;
+sub expand_component_module {
+    my ( $class, $module ) = @_;
+    return Devel::InnerPackage::list_packages( $module );
 }
 
-
 1;
 
 __END__
@@ -633,9 +697,9 @@ Container that stores all controllers.
 
 =head1 Services
 
-=head2 build_name_service
+=head2 build_application_name_service
 
-Name of the application.
+Name of the application (such as MyApp).
 
 =head2 build_driver_service
 
@@ -745,6 +809,21 @@ Example:
 
 The above will respond to C<__baz(x,y)__> in config strings.
 
+=head2 $c->expand_component_module( $component, $setup_component_config )
+
+Components found by C<locate_components> will be passed to this method, which
+is expected to return a list of component (package) names to be set up.
+
+=head2 build_locate_components_service
+
+This method is meant to provide a list of component modules that should be
+setup for the application.  By default, it will use L<Module::Pluggable>.
+
+Specify a C<setup_components> config option to pass additional options directly
+to L<Module::Pluggable>.
+
+=head2 setup_components
+
 =head1 AUTHORS
 
 Catalyst Contributors, see Catalyst.pm