X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FComponent.pm;h=8fe109feb9a101dfa469aba9c26014b3d35a486a;hb=ref-util;hp=13c9323440515f52c485e92a119f84f0402a45ac;hpb=dd5b1dc47018c241cafda7f2b565d6a39257a1bf;p=catagits%2FCatalyst-Runtime.git

diff --git a/lib/Catalyst/Component.pm b/lib/Catalyst/Component.pm
index 13c9323..8fe109f 100644
--- a/lib/Catalyst/Component.pm
+++ b/lib/Catalyst/Component.pm
@@ -11,6 +11,7 @@ use mro 'c3';
 use Scalar::Util 'blessed';
 use Class::Load 'is_class_loaded';
 use Moose::Util 'find_meta';
+use Ref::Util qw(is_plain_hashref);
 use namespace::clean -except => 'meta';
 
 with 'MooseX::Emulate::Class::Accessor::Fast';
@@ -91,12 +92,12 @@ sub BUILDARGS {
     my $args = {};
 
     if (@_ == 1) {
-        $args = $_[0] if ref($_[0]) eq 'HASH';
+        $args = $_[0] if is_plain_hashref($_[0]);
     } elsif (@_ == 2) { # is it ($app, $args) or foo => 'bar' ?
         if (blessed($_[0])) {
-            $args = $_[1] if ref($_[1]) eq 'HASH';
+            $args = $_[1] if is_plain_hashref($_[1]);
         } elsif (is_class_loaded($_[0]) &&
-                $_[0]->isa('Catalyst') && ref($_[1]) eq 'HASH') {
+                $_[0]->isa('Catalyst') && is_plain_hashref($_[1])) {
             $args = $_[1];
         } else {
             $args = +{ @_ };
@@ -112,7 +113,7 @@ sub COMPONENT {
     my ( $class, $c ) = @_;
 
     # Temporary fix, some components does not pass context to constructor
-    my $arguments = ( ref( $_[-1] ) eq 'HASH' ) ? $_[-1] : {};
+    my $arguments = is_plain_hashref($_[-1]) ? $_[-1] : {};
     if ( my $next = $class->next::can ) {
       my ($next_package) = Class::MOP::get_code_info($next);
       warn "There is a COMPONENT method resolving after Catalyst::Component in ${next_package}.\n";
@@ -202,6 +203,19 @@ something like this:
       return $class->new($app, $args);
   }
 
+B<NOTE:> Generally when L<Catalyst> starts, it initializes all the components
+and passes the hashref present in any configuration information to the
+COMPONENT method.  For example
+
+    MyApp->config(
+      'Model::Foo' => {
+        bar => 'baz',
+      });
+
+You would expect COMPONENT to be called like this ->COMPONENT( 'MyApp', +{ bar=>'baz'});
+
+This would happen ONCE during setup.
+
 =head2 $c->config
 
 =head2 $c->config($hashref)
@@ -251,6 +265,39 @@ would cause your MyApp::Model::Foo instance's ACCEPT_CONTEXT to be called with
 ($c, 'bar', 'baz')) and the return value of this method is returned to the
 calling code in the application rather than the component itself.
 
+B<NOTE:> All classes that are L<Catalyst::Component>s will have a COMPONENT
+method, but classes that are intended to be factories or generators will
+have ACCEPT_CONTEXT.  If you have initialization arguments (such as from
+configuration) that you wish to expose to the ACCEPT_CONTEXT you should
+proxy them in the factory instance.  For example:
+
+    MyApp::Model::FooFactory;
+
+    use Moose;
+    extends 'Catalyst::Model';
+
+    has type => (is=>'ro', required=>1);
+
+    sub ACCEPT_CONTEXT {
+      my ($self, $c, @args) = @_;
+      return bless { args=>\@args }, $self->type;
+    }
+
+    MyApp::Model::Foo->meta->make_immutable;
+    MyApp::Model::Foo->config( type => 'Type1' );
+
+And in a controller:
+
+    my $type = $c->model('FooFactory', 1,2,3,4): # $type->isa('Type1')
+
+B<NOTE:> If you define a ACCEPT_CONTEXT method it MUST check to see if the
+second argument is blessed (is a context) or not (is an application class name) and
+it MUST return something valid for the case when the scope is application.  This is
+required because a component maybe be called from the application scope even if it
+requires a context and you must prevent errors from being issued if this happens.
+Remember not all components that ACCEPT_CONTEXT actually need or use context information
+(and there is a school of thought that suggestions doing so is a design error anyway...)
+
 =head1 SEE ALSO
 
 L<Catalyst>, L<Catalyst::Model>, L<Catalyst::View>, L<Catalyst::Controller>.