X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FController.pm;h=e3c537722fa3674e6850c4ba7f83aab4723ffb8d;hb=2361ed675dadcf78697c63b6ec89456c5c3c18dc;hp=d31b704666be8dbab83e858a34ca9a537cd707a4;hpb=6323fda2e7ace0fc0aa06305c674957cedc6d025;p=catagits%2FCatalyst-Runtime.git

diff --git a/lib/Catalyst/Controller.pm b/lib/Catalyst/Controller.pm
index d31b704..e3c5377 100644
--- a/lib/Catalyst/Controller.pm
+++ b/lib/Catalyst/Controller.pm
@@ -1,42 +1,36 @@
 package Catalyst::Controller;
 
 use Moose;
-use Class::MOP ();
-#use MooseX::ClassAttribute;
-use Catalyst::Exception;
-use Catalyst::Utils;
-use Class::Inspector;
-use NEXT;
+use Class::MOP;
+use base qw/Catalyst::Component Catalyst::AttrContainer/;
 
+#Why does the following blow up?
 #extends qw/Catalyst::Component Catalyst::AttrContainer/;
-use base qw/Catalyst::Component Catalyst::AttrContainer/;
 
-# class_has _dispatch_steps =>
-#   (
-#    is => 'rw',
-#    isa => 'ArrayRef',
-#    required => 1,
-#    default => sub{ [qw/_BEGIN _AUTO _ACTION/] },
-#   );
-
-# class_has _action_class =>
-#   (
-#    is => 'rw',
-#    isa => 'ClassName',
-#    required => 1,
-#    default => sub{ 'Catalyst::Action' },
-#   );
-
-__PACKAGE__->mk_classdata('_dispatch_steps');
-__PACKAGE__->mk_classdata('_action_class');
+has path => (
+             is => 'ro',
+             isa => 'Str',
+             predicate => 'has_path',
+            );
 
-__PACKAGE__->_action_class('Catalyst::Action');
-__PACKAGE__->_dispatch_steps([qw/_BEGIN _AUTO _ACTION/]);
+#this are frefixed like this because _namespace clases with something in
+#Catalyst.pm . to be fixed later.
+has _namespace => (
+                   is => 'ro',
+                   isa => 'Str',
+                   init_arg => 'namespace',
+                   predicate => '_has_namespace',
+                 );
+
+__PACKAGE__->mk_accessors( qw/_application/ );
 
+has _application => (is => 'rw');
+sub _app{ shift->_application(@_) } # eww
 
-has _application => ( is => 'rw' );
-### _app as alias
-*_app = *_application;
+use Scalar::Util qw/blessed/;
+use Catalyst::Exception;
+use Catalyst::Utils;
+use Class::Inspector;
 
 =head1 NAME
 
@@ -61,16 +55,12 @@ for more info about how Catalyst dispatches to actions.
 
 =cut
 
-# just emulating old behavior. we could probably do this
-# via BUILD later or pass $app as application => $app
-around new => sub {
-    my $orig = shift;
-    my $self = shift;
-    my $app = $_[0];
-    my $new = $self->$orig(@_);
-    $new->_application( $app );
-    return $new;
-};
+#I think both of these could be attributes. doesn't really seem like they need
+#to ble class data. i think that attributes +default would work just fine
+__PACKAGE__->mk_classdata($_) for qw/_dispatch_steps _action_class/;
+
+__PACKAGE__->_dispatch_steps( [qw/_BEGIN _AUTO _ACTION/] );
+__PACKAGE__->_action_class('Catalyst::Action');
 
 
 sub _DISPATCH : Private {
@@ -120,6 +110,16 @@ sub _END : Private {
     return !@{ $c->error };
 }
 
+around new => sub {
+    my $orig = shift;
+    my $self = shift;
+    my $app = $_[0];
+    my $new = $self->$orig(@_);
+    $new->_application( $app );
+    return $new;
+};
+
+
 sub action_for {
     my ( $self, $name ) = @_;
     my $app = ($self->isa('Catalyst') ? $self : $self->_application);
@@ -131,8 +131,11 @@ sub action_namespace {
     unless ( $c ) {
         $c = ($self->isa('Catalyst') ? $self : $self->_application);
     }
-    my $hash = (ref $self ? $self : $self->config); # hate app-is-class
-    return $hash->{namespace} if exists $hash->{namespace};
+    if( ref($self) ){
+      return $self->_namespace if $self->_has_namespace;
+    } # else { #i think this is hacky and it should work with the else enabled
+      return $self->config->{namespace} if exists $self->config->{namespace};
+    #}
     return Catalyst::Utils::class2prefix( ref($self) || $self,
         $c->config->{case_sensitive} )
       || '';
@@ -143,8 +146,11 @@ sub path_prefix {
     unless ( $c ) {
         $c = ($self->isa('Catalyst') ? $self : $self->_application);
     }
-    my $hash = (ref $self ? $self : $self->config); # hate app-is-class
-    return $hash->{path} if exists $hash->{path};
+    if( ref($self) ){
+      return $self->path if $self->has_path;
+    } # else {
+      return $self->config->{path} if exists $self->config->{path};
+    #}
     return shift->action_namespace(@_);
 }
 
@@ -152,15 +158,21 @@ sub path_prefix {
 sub register_actions {
     my ( $self, $c ) = @_;
     my $class = ref $self || $self;
+    #this is still not correct for some reason.
     my $namespace = $self->action_namespace($c);
     my %methods;
-    {
-      my $meth_map = $class->meta->get_method_map;
-      @methods{values %$meth_map} = (keys %$meth_map);
+    if( $self->can('meta') ){
+      my $meta = $self->meta;
+      %methods = map{ $_->{code}->body => $_->{name} }
+        grep {$_->{class} ne 'Moose::Object'} #ignore Moose::Object methods
+          $meta->compute_all_applicable_methods;
+    } else { #until we are sure there's no moose stuff left...
+      $methods{ $self->can($_) } = $_
+        for @{ Class::Inspector->methods($class) || [] };
     }
 
-    #Moose TODO: something tells me that roles could kill the directly code below
     # Advanced inheritance support for plugins and the like
+    #to be modified to use meta->superclasses
     my @action_cache;
     {
         no strict 'refs';
@@ -182,7 +194,7 @@ sub register_actions {
               if $c->debug;
             next;
         }
-        my $reverse = $namespace ? "$namespace/$method" : $method;
+        my $reverse = $namespace ? "${namespace}/${method}" : $method;
         my $action = $self->create_action(
             name       => $method,
             code       => $code,
@@ -204,11 +216,10 @@ sub create_action {
                     ? $args{attributes}{ActionClass}[0]
                     : $self->_action_class);
 
-    #can we replace with a single call to Class::MOP::load_class() ?
+    Class::MOP::load_class($class);
     #unless ( Class::Inspector->loaded($class) ) {
     #    require Class::Inspector->filename($class);
     #}
-    Class::MOP::load_class($class);
 
     return $class->new( \%args );
 }
@@ -232,7 +243,10 @@ sub _parse_attrs {
         }
     }
 
-    my $hash = (ref $self ? $self : $self->config); # hate app-is-class
+    #this will not work under moose
+    #my $hash = (ref $self ? $self : $self->config); # hate app-is-class
+    #action / actions should be an attribute  of Controller
+    my $hash = $self->config;
 
     if (exists $hash->{actions} || exists $hash->{action}) {
       my $a = $hash->{actions} || $hash->{action};