- Made Action accessor names more consistent (namespace -> class, prefix -> namespace)

diff --git a/lib/Catalyst/Action.pm b/lib/Catalyst/Action.pm
index 0bc165a..9b2ea9f 100644 (file)
--- a/lib/Catalyst/Action.pm
+++ b/lib/Catalyst/Action.pm
@@ -3,7 +3,7 @@ package Catalyst::Action;
 use strict;
 use base qw/Class::Accessor::Fast/;
 
-__PACKAGE__->mk_accessors(qw/code namespace reverse prefix attributes name/);
+__PACKAGE__->mk_accessors(qw/class namespace reverse attributes name code/);
 
 use overload (
 
@@ -31,6 +31,8 @@ See L<Catalyst>.
 
 =item attributes
 
+=item class
+
 =item code
 
 =item execute
@@ -39,7 +41,7 @@ See L<Catalyst>.
 
 sub execute {    # Execute ourselves against a context
     my ( $self, $c ) = @_;
-    return $c->execute( $self->namespace, $self );
+    return $c->execute( $self->class, $self );
 }
 
 =item namespace

diff --git a/lib/Catalyst/DispatchType/Path.pm b/lib/Catalyst/DispatchType/Path.pm
index 67ea411..81603d5 100644 (file)
--- a/lib/Catalyst/DispatchType/Path.pm
+++ b/lib/Catalyst/DispatchType/Path.pm
@@ -47,7 +47,7 @@ sub match {
         $c->req->action($path);
         $c->req->match($path);
         $c->action($action);
-        $c->namespace( $action->prefix );
+        $c->namespace( $action->namespace );
         return 1;
     }
 
@@ -66,7 +66,7 @@ sub register {
 
     foreach my $r ( @{ $attrs->{Path} || [] } ) {
         unless ( $r =~ m!^/! ) {    # It's a relative path
-            $r = $action->prefix . "/$r";
+            $r = $action->namespace . "/$r";
         }
         push( @register, $r );
     }
@@ -76,7 +76,7 @@ sub register {
     }
 
     if ( $attrs->{Local} || $attrs->{Relative} ) {
-        push( @register, join( '/', $action->prefix, $action->name ) );
+        push( @register, join( '/', $action->namespace, $action->name ) );
 
         # Register sub name as a relative path
     }

diff --git a/lib/Catalyst/DispatchType/Regex.pm b/lib/Catalyst/DispatchType/Regex.pm
index 975aebb..a1224c5 100644 (file)
--- a/lib/Catalyst/DispatchType/Regex.pm
+++ b/lib/Catalyst/DispatchType/Regex.pm
@@ -54,7 +54,7 @@ sub match {
             $c->req->match($path);
             $c->req->snippets( \@snippets );
             $c->action( $compiled->{action} );
-            $c->namespace( $compiled->{action}->prefix );
+            $c->namespace( $compiled->{action}->namespace );
             return 1;
         }
     }

diff --git a/lib/Catalyst/Dispatcher.pm b/lib/Catalyst/Dispatcher.pm
index 66e8721..0fa02b5 100644 (file)
--- a/lib/Catalyst/Dispatcher.pm
+++ b/lib/Catalyst/Dispatcher.pm
@@ -184,8 +184,8 @@ qq/Couldn't forward to command "$command". Invalid action or component./;
                     name      => $method,
                     code      => $code,
                     reverse   => "$class->$method",
+                    class     => $class,
                     namespace => $class,
-                    prefix    => $class,
                 }
             );
             $results = [ [$action] ];
@@ -271,7 +271,7 @@ sub get_action {
         my $node = $match[-1]->actions;    # Only bother looking at the last one
 
         if ( defined $node->{$action}
-            && ( $node->{$action}->prefix eq $namespace ) )
+            && ( $node->{$action}->namespace eq $namespace ) )
         {
             return [ [ $node->{$action} ] ];
         }
@@ -323,15 +323,15 @@ sub get_containers {
     return map { $_->getNodeValue } @match;
 }
 
-=item $self->set_action( $c, $action, $code, $namespace, $attrs )
+=item $self->set_action( $c, $action, $code, $class, $attrs )
 
 =cut
 
 sub set_action {
-    my ( $self, $c, $method, $code, $namespace, $attrs ) = @_;
+    my ( $self, $c, $method, $code, $class, $attrs ) = @_;
 
-    my $prefix =
-      Catalyst::Utils::class2prefix( $namespace, $c->config->{case_sensitive} )
+    my $namespace =
+      Catalyst::Utils::class2prefix( $class, $c->config->{case_sensitive} )
       || '';
     my %attributes;
 
@@ -362,7 +362,7 @@ sub set_action {
     if ( $attributes{Private} && ( keys %attributes > 1 ) ) {
         $c->log->debug( 'Bad action definition "'
               . join( ' ', @{$attrs} )
-              . qq/" for "$namespace->$method"/ )
+              . qq/" for "$class->$method"/ )
           if $c->debug;
         return;
     }
@@ -371,8 +371,8 @@ sub set_action {
     my $parent  = $self->tree;
     my $visitor = Tree::Simple::Visitor::FindByPath->new;
 
-    if ($prefix) {
-        for my $part ( split '/', $prefix ) {
+    if ($namespace) {
+        for my $part ( split '/', $namespace ) {
             $visitor->setSearchPath($part);
             $parent->accept($visitor);
             my $child = $visitor->getResult;
@@ -395,7 +395,7 @@ sub set_action {
         }
     }
 
-    my $reverse = $prefix ? "$prefix/$method" : $method;
+    my $reverse = $namespace ? "$namespace/$method" : $method;
 
     my $action = Catalyst::Action->new(
         {
@@ -403,7 +403,7 @@ sub set_action {
             code       => $code,
             reverse    => $reverse,
             namespace  => $namespace,
-            prefix     => $prefix,
+            class      => $class,
             attributes => \%attributes,
         }
     );
@@ -422,7 +422,7 @@ sub set_action {
 =cut
 
 sub setup_actions {
-    my ( $self, $class ) = @_;
+    my ( $self, $c ) = @_;
 
     $self->dispatch_types( [] );
 
@@ -440,7 +440,7 @@ sub setup_actions {
       Catalyst::ActionContainer->new( { part => '/', actions => {} } );
     $self->tree( Tree::Simple->new( $container, Tree::Simple->ROOT ) );
 
-    for my $comp ( keys %{ $class->components } ) {
+    for my $comp ( keys %{ $c->components } ) {
 
         # We only setup components that inherit from Catalyst::Base
         next unless $comp->isa('Catalyst::Base');
@@ -450,22 +450,22 @@ sub setup_actions {
             my $name = '';
             no strict 'refs';
             my @cache = ( $comp, @{"$comp\::ISA"} );
-            my %namespaces;
+            my %classes;
 
-            while ( my $namespace = shift @cache ) {
-                $namespaces{$namespace}++;
+            while ( my $class = shift @cache ) {
+                $classes{$class}++;
                 for my $isa ( @{"$comp\::ISA"} ) {
-                    next if $namespaces{$isa};
+                    next if $classes{$isa};
                     push @cache, $isa;
-                    $namespaces{$isa}++;
+                    $classes{$isa}++;
                 }
             }
 
-            for my $namespace ( keys %namespaces ) {
-                for my $sym ( values %{ $namespace . '::' } ) {
+            for my $class ( keys %classes ) {
+                for my $sym ( values %{ $class . '::' } ) {
                     if ( *{$sym}{CODE} && *{$sym}{CODE} == $code ) {
                         $name = *{$sym}{NAME};
-                        $class->set_action( $name, $code, $comp, $attrs );
+                        $self->set_action( $c, $name, $code, $comp, $attrs );
                         last;
                     }
                 }
@@ -482,7 +482,7 @@ sub setup_actions {
         push @{ $self->dispatch_types }, $class->new;
     }
 
-    return unless $class->debug;
+    return unless $c->debug;
 
     my $privates = Text::ASCIITable->new;
     $privates->setCols( 'Private', 'Class' );
@@ -497,18 +497,18 @@ sub setup_actions {
 
         for my $action ( keys %{$node} ) {
             my $action_obj = $node->{$action};
-            $privates->addRow( "$prefix$action", $action_obj->namespace );
+            $privates->addRow( "$prefix$action", $action_obj->class );
         }
 
         $walker->( $walker, $_, $prefix ) for $parent->getAllChildren;
     };
 
     $walker->( $walker, $self->tree, '' );
-    $class->log->debug( "Loaded Private actions:\n" . $privates->draw )
+    $c->log->debug( "Loaded Private actions:\n" . $privates->draw )
       if ( @{ $privates->{tbl_rows} } );
 
     # List all public actions
-    $_->list($class) for @{ $self->dispatch_types };
+    $_->list($c) for @{ $self->dispatch_types };
 }
 
 =back