a couple more details

[catagits/Catalyst-Runtime.git] / lib / Catalyst / Controller.pm

diff --git a/lib/Catalyst/Controller.pm b/lib/Catalyst/Controller.pm
index ab77e21..e3c5377 100644 (file)
--- a/lib/Catalyst/Controller.pm
+++ b/lib/Catalyst/Controller.pm
@@ -1,12 +1,36 @@
 package Catalyst::Controller;
 
-use strict;
-use base qw/Catalyst::Component Catalyst::AttrContainer Class::Accessor::Fast/;
+use Moose;
+use Class::MOP;
+use base qw/Catalyst::Component Catalyst::AttrContainer/;
+
+#Why does the following blow up?
+#extends qw/Catalyst::Component Catalyst::AttrContainer/;
+
+has path => (
+             is => 'ro',
+             isa => 'Str',
+             predicate => 'has_path',
+            );
+
+#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
+
+use Scalar::Util qw/blessed/;
 use Catalyst::Exception;
 use Catalyst::Utils;
 use Class::Inspector;
-use NEXT;
 
 =head1 NAME
 
@@ -17,9 +41,9 @@ Catalyst::Controller - Catalyst Controller base class
   package MyApp::Controller::Search
   use base qw/Catalyst::Controller/;
 
-  sub foo : Local { 
+  sub foo : Local {
     my ($self,$c,@args) = @_;
-    ... 
+    ...
   } # Dispatches to /search/foo
 
 =head1 DESCRIPTION
@@ -31,15 +55,13 @@ for more info about how Catalyst dispatches to actions.
 
 =cut
 
+#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');
 
-__PACKAGE__->mk_accessors( qw/_application/ );
-
-### _app as alias
-*_app = *_application;
 
 sub _DISPATCH : Private {
     my ( $self, $c ) = @_;
@@ -88,13 +110,14 @@ sub _END : Private {
     return !@{ $c->error };
 }
 
-sub new {
+around new => sub {
+    my $orig = shift;
     my $self = shift;
     my $app = $_[0];
-    my $new = $self->NEXT::new(@_);
+    my $new = $self->$orig(@_);
     $new->_application( $app );
     return $new;
-}
+};
 
 
 sub action_for {
@@ -108,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} )
       || '';
@@ -120,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(@_);
 }
 
@@ -129,12 +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;
-    $methods{ $self->can($_) } = $_
-      for @{ Class::Inspector->methods($class) || [] };
+    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) || [] };
+    }
 
     # Advanced inheritance support for plugins and the like
+    #to be modified to use meta->superclasses
     my @action_cache;
     {
         no strict 'refs';
@@ -156,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,
@@ -178,10 +216,11 @@ sub create_action {
                     ? $args{attributes}{ActionClass}[0]
                     : $self->_action_class);
 
-    unless ( Class::Inspector->loaded($class) ) {
-        require Class::Inspector->filename($class);
-    }
-    
+    Class::MOP::load_class($class);
+    #unless ( Class::Inspector->loaded($class) ) {
+    #    require Class::Inspector->filename($class);
+    #}
+
     return $class->new( \%args );
 }
 
@@ -204,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};
@@ -310,7 +352,7 @@ controller name. For instance controller 'MyApp::Controller::Foo::Bar'
 will be bound to 'foo/bar'. The default Root controller is an example
 of setting namespace to '' (the null string).
 
-=head2 path 
+=head2 path
 
 Sets 'path_prefix', as described below.