X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=catagits%2FCatalyst-Runtime.git;a=blobdiff_plain;f=lib%2FCatalyst.pm;h=9183864fe422500e4214e96695e67bbce3fb9576;hp=02af3c1154933ba2a1534a8a91f2b30f1d832023;hb=059c085bfcead450e70ace9ef193aa99ac2ab37d;hpb=e7ad3b811c9462cdf2596461066e370f9ea4fa95

diff --git a/lib/Catalyst.pm b/lib/Catalyst.pm
index 02af3c1..9183864 100644
--- a/lib/Catalyst.pm
+++ b/lib/Catalyst.pm
@@ -19,12 +19,14 @@ use Path::Class::Dir ();
 use Path::Class::File ();
 use Time::HiRes qw/gettimeofday tv_interval/;
 use URI ();
+use URI::http;
+use URI::https;
 use Scalar::Util qw/weaken blessed/;
 use Tree::Simple qw/use_weak_refs/;
 use Tree::Simple::Visitor::FindByUID;
 use attributes;
 use utf8;
-use Carp qw/croak/;
+use Carp qw/croak carp/;
 
 BEGIN { require 5.008001; }
 
@@ -52,16 +54,18 @@ our $DETACH    = "catalyst_detach\n";
 
 __PACKAGE__->mk_classdata($_)
   for qw/components arguments dispatcher engine log dispatcher_class
-  engine_class context_class request_class response_class setup_finished/;
+  engine_class context_class request_class response_class stats_class 
+  setup_finished/;
 
 __PACKAGE__->dispatcher_class('Catalyst::Dispatcher');
 __PACKAGE__->engine_class('Catalyst::Engine::CGI');
 __PACKAGE__->request_class('Catalyst::Request');
 __PACKAGE__->response_class('Catalyst::Response');
+__PACKAGE__->stats_class('Catalyst::Stats');
 
 # Remember to update this in Catalyst::Runtime as well!
 
-our $VERSION = '5.7006';
+our $VERSION = '5.7013';
 
 sub import {
     my ( $class, @arguments ) = @_;
@@ -109,7 +113,7 @@ documentation and tutorials.
     ### in lib/MyApp.pm
     use Catalyst qw/-Debug/; # include plugins here as well
     
-	### In lib/MyApp/Controller/Root.pm (autocreated)
+    ### In lib/MyApp/Controller/Root.pm (autocreated)
     sub foo : Global { # called for /foo, /foo/1, /foo/1/2, etc.
         my ( $self, $c, @args ) = @_; # args are qw/1 2/ for /foo/1/2
         $c->stash->{template} = 'foo.tt'; # set the template
@@ -238,6 +242,17 @@ MYAPP_WEB_HOME. If both variables are set, the MYAPP_HOME one will be used.
 
 Specifies log level.
 
+=head2 -Stats
+
+Enables statistics collection and reporting. You can also force this setting
+from the system environment with CATALYST_STATS or <MYAPP>_STATS. The
+environment settings override the application, with <MYAPP>_STATS having the
+highest priority.
+
+e.g. 
+
+   use Catalyst qw/-Stats=1/
+
 =head1 METHODS
 
 =head2 INFORMATION ABOUT THE CURRENT REQUEST
@@ -343,7 +358,7 @@ sub stash {
     my $c = shift;
     if (@_) {
         my $stash = @_ > 1 ? {@_} : $_[0];
-	croak('stash takes a hash or hashref') unless ref $stash;
+        croak('stash takes a hash or hashref') unless ref $stash;
         foreach my $key ( keys %$stash ) {
             $c->{stash}->{$key} = $stash->{$key};
         }
@@ -511,6 +526,8 @@ Gets a L<Catalyst::Model> instance by name.
 
     $c->model('Foo')->do_stuff;
 
+Any extra arguments are directly passed to ACCEPT_CONTEXT.
+
 If the name is omitted, it will look for 
  - a model object in $c->stash{current_model_instance}, then
  - a model name in $c->stash->{current_model}, then
@@ -529,10 +546,10 @@ sub model {
           if $c->stash->{current_model_instance};
         return $c->model( $c->stash->{current_model} )
           if $c->stash->{current_model};
-        return $c->model( $c->config->{default_model} )
-          if $c->config->{default_model};
     }
-    return $c->_filter_component( $c->_comp_singular(qw/Model M/), @args );
+    return $c->model( $c->config->{default_model} )
+      if $c->config->{default_model};
+    return $c->_filter_component( $c->_comp_singular(qw/Model M/) );
 
 }
 
@@ -554,6 +571,8 @@ Gets a L<Catalyst::View> instance by name.
 
     $c->view('Foo')->do_stuff;
 
+Any extra arguments are directly passed to ACCEPT_CONTEXT.
+
 If the name is omitted, it will look for 
  - a view object in $c->stash{current_view_instance}, then
  - a view name in $c->stash->{current_view}, then
@@ -572,9 +591,9 @@ sub view {
           if $c->stash->{current_view_instance};
         return $c->view( $c->stash->{current_view} )
           if $c->stash->{current_view};
-        return $c->view( $c->config->{default_view} )
-          if $c->config->{default_view};
     }
+    return $c->view( $c->config->{default_view} )
+      if $c->config->{default_view};
     return $c->_filter_component( $c->_comp_singular(qw/View V/) );
 }
 
@@ -807,6 +826,7 @@ sub setup {
     $class->setup_plugins( delete $flags->{plugins} );
     $class->setup_dispatcher( delete $flags->{dispatcher} );
     $class->setup_engine( delete $flags->{engine} );
+    $class->setup_stats( delete $flags->{stats} );
 
     for my $flag ( sort keys %{$flags} ) {
 
@@ -900,6 +920,9 @@ If the last argument to C<uri_for> is a hash reference, it is assumed to
 contain GET parameter key/value pairs, which will be appended to the URI
 in standard fashion.
 
+Note that uri_for is destructive to the passed hashref.  Subsequent calls
+with the same hashref may have unintended results.
+
 Instead of C<$path>, you can also optionally pass a C<$action> object
 which will be resolved to a path using
 C<< $c->dispatcher->uri_for_action >>; if the first element of
@@ -910,11 +933,6 @@ to C<uri_for_action>.
 
 sub uri_for {
     my ( $c, $path, @args ) = @_;
-    my $base     = $c->request->base->clone;
-    my $basepath = $base->path;
-    $basepath =~ s/\/$//;
-    $basepath .= '/';
-    my $namespace = $c->namespace || '';
 
     if ( Scalar::Util::blessed($path) ) { # action object
         my $captures = ( scalar @args && ref $args[0] eq 'ARRAY'
@@ -925,32 +943,53 @@ sub uri_for {
         $path = '/' if $path eq '';
     }
 
-    # massage namespace, empty if absolute path
-    $namespace =~ s/^\/// if $namespace;
-    $namespace .= '/' if $namespace;
-    $path ||= '';
-    $namespace = '' if $path =~ /^\//;
-    $path =~ s/^\///;
-    $path =~ s/\?/%3F/g;
+    undef($path) if (defined $path && $path eq '');
 
     my $params =
       ( scalar @args && ref $args[$#args] eq 'HASH' ? pop @args : {} );
 
-    for my $value ( values %$params ) {
-        next unless defined $value;
-        for ( ref $value eq 'ARRAY' ? @$value : $value ) {
-            $_ = "$_";
-            utf8::encode( $_ );
+    carp "uri_for called with undef argument" if grep { ! defined $_ } @args;
+    s/([^$URI::uric])/$URI::Escape::escapes{$1}/go for @args;
+
+    unshift(@args, $path);
+
+    unless (defined $path && $path =~ s!^/!!) { # in-place strip
+        my $namespace = $c->namespace;
+        if (defined $path) { # cheesy hack to handle path '../foo'
+           $namespace =~ s{(?:^|/)[^/]+$}{} while $args[0] =~ s{^\.\./}{};
         }
-    };
+        unshift(@args, $namespace || '');
+    }
     
     # join args with '/', or a blank string
-    my $args = ( scalar @args ? '/' . join( '/', map {s/\?/%3F/g; $_} @args ) : '' );
-    $args =~ s/^\/// unless $path;
-    my $res =
-      URI->new_abs( URI->new_abs( "$path$args", "$basepath$namespace" ), $base )
-      ->canonical;
-    $res->query_form(%$params);
+    my $args = join('/', grep { defined($_) } @args);
+    $args =~ s/\?/%3F/g; # STUPID STUPID SPECIAL CASE
+    $args =~ s!^/!!;
+    my $base = $c->req->base;
+    my $class = ref($base);
+    $base =~ s{(?<!/)$}{/};
+
+    my $query = '';
+
+    if (my @keys = keys %$params) {
+      # somewhat lifted from URI::_query's query_form
+      $query = '?'.join('&', map {
+          s/([;\/?:@&=+,\$\[\]%])/$URI::Escape::escapes{$1}/go;
+          s/ /+/g;
+          my $key = $_;
+          my $val = $params->{$_};
+          $val = '' unless defined $val;
+          (map {
+              $_ = "$_";
+              utf8::encode( $_ ) if utf8::is_utf8($_);
+              # using the URI::Escape pattern here so utf8 chars survive
+              s/([^A-Za-z0-9\-_.!~*'() ])/$URI::Escape::escapes{$1}/go;
+              s/ /+/g;
+              "${key}=$_"; } ( ref $val eq 'ARRAY' ? @$val : $val ));
+      } @keys);
+    }
+
+    my $res = bless(\"${base}${args}${query}", $class);
     $res;
 }
 
@@ -971,8 +1010,8 @@ sub welcome_message {
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
     <head>
-	<meta http-equiv="Content-Language" content="en" />
-	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <meta http-equiv="Content-Language" content="en" />
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
         <title>$name on Catalyst $VERSION</title>
         <style type="text/css">
             body {
@@ -1176,13 +1215,13 @@ sub execute {
         return $c->state;
     }
 
-    my $stats_info = $c->_stats_start_execute( $code ) if $c->debug;
+    my $stats_info = $c->_stats_start_execute( $code ) if $c->use_stats;
 
     push( @{ $c->stack }, $code );
     
     eval { $c->state( &$code( $class, $c, @{ $c->req->args } ) || 0 ) };
 
-    $c->_stats_finish_execute( $stats_info ) if $c->debug and $stats_info;
+    $c->_stats_finish_execute( $stats_info ) if $c->use_stats and $stats_info;
     
     my $last = pop( @{ $c->stack } );
 
@@ -1230,51 +1269,43 @@ sub _stats_start_execute {
         }
     }
 
-    my $node = Tree::Simple->new(
-        {
-            action  => $action,
-            elapsed => undef,     # to be filled in later
-            comment => "",
-        }
-    );
-    $node->setUID( "$code" . $c->counter->{"$code"} );
+    my $uid = "$code" . $c->counter->{"$code"};
 
     # is this a root-level call or a forwarded call?
     if ( $callsub =~ /forward$/ ) {
 
         # forward, locate the caller
         if ( my $parent = $c->stack->[-1] ) {
-            my $visitor = Tree::Simple::Visitor::FindByUID->new;
-            $visitor->searchForUID(
-                "$parent" . $c->counter->{"$parent"} );
-            $c->stats->accept($visitor);
-            if ( my $result = $visitor->getResult ) {
-                $result->addChild($node);
-            }
+            $c->stats->profile(
+                begin  => $action, 
+                parent => "$parent" . $c->counter->{"$parent"},
+                uid    => $uid,
+            );
         }
         else {
 
             # forward with no caller may come from a plugin
-            $c->stats->addChild($node);
+            $c->stats->profile(
+                begin => $action,
+                uid   => $uid,
+            );
         }
     }
     else {
-
+        
         # root-level call
-        $c->stats->addChild($node);
+        $c->stats->profile(
+            begin => $action,
+            uid   => $uid,
+        );
     }
+    return $action;
 
-    return {
-        start   => [gettimeofday],
-        node    => $node,
-    };
 }
 
 sub _stats_finish_execute {
     my ( $c, $info ) = @_;
-    my $elapsed = tv_interval $info->{start};
-    my $value = $info->{node}->getNodeValue;
-    $value->{elapsed} = sprintf( '%fs', $elapsed );
+    $c->stats->profile( end => $info );
 }
 
 =head2 $c->_localize_fields( sub { }, \%keys );
@@ -1330,22 +1361,11 @@ sub finalize {
         $c->finalize_body;
     }
     
-    if ($c->debug) {
-        my $elapsed = sprintf '%f', tv_interval($c->stats->getNodeValue);
-        my $av = sprintf '%.3f', ( $elapsed == 0 ? '??' : ( 1 / $elapsed ) );
-        
-        my $t = Text::SimpleTable->new( [ 62, 'Action' ], [ 9, 'Time' ] );
-        $c->stats->traverse(
-            sub {
-                my $action = shift;
-                my $stat   = $action->getNodeValue;
-                $t->row( ( q{ } x $action->getDepth ) . $stat->{action} . $stat->{comment},
-                    $stat->{elapsed} || '??' );
-            }
-        );
-
+    if ($c->use_stats) {        
+        my $elapsed = sprintf '%f', $c->stats->elapsed;
+        my $av = $elapsed == 0 ? '??' : sprintf '%.3f', 1 / $elapsed;
         $c->log->info(
-            "Request took ${elapsed}s ($av/s)\n" . $t->draw . "\n" );        
+            "Request took ${elapsed}s ($av/s)\n" . $c->stats->report . "\n" );        
     }
 
     return $c->response->status;
@@ -1391,6 +1411,13 @@ sub finalize_headers {
     if ( my $location = $c->response->redirect ) {
         $c->log->debug(qq/Redirecting to "$location"/) if $c->debug;
         $c->response->header( Location => $location );
+        
+        if ( !$c->response->body ) {
+            # Add a default body if none is already present
+            $c->response->body(
+                qq{<html><body><p>This item has moved <a href="$location">here</a>.</p></body></html>}
+            );
+        }
     }
 
     # Content-Length
@@ -1399,7 +1426,8 @@ sub finalize_headers {
         # get the length from a filehandle
         if ( blessed( $c->response->body ) && $c->response->body->can('read') )
         {
-            if ( my $stat = stat $c->response->body ) {
+            my $stat = stat $c->response->body;
+            if ( $stat && $stat->size > 0 ) {
                 $c->response->content_length( $stat->size );
             }
             else {
@@ -1407,6 +1435,7 @@ sub finalize_headers {
             }
         }
         else {
+            # everything should be bytes at this point, but just in case
             $c->response->content_length( bytes::length( $c->response->body ) );
         }
     }
@@ -1537,16 +1566,14 @@ sub prepare {
         }
     );
 
+    $c->stats($class->stats_class->new)->enable($c->use_stats);
     if ( $c->debug ) {
-        $c->stats(Tree::Simple->new([gettimeofday]));
         $c->res->headers->header( 'X-Catalyst' => $Catalyst::VERSION );            
     }
 
     # For on-demand data
-    $c->request->{_context}  = $c;
-    $c->response->{_context} = $c;
-    weaken( $c->request->{_context} );
-    weaken( $c->response->{_context} );
+    $c->request->_context($c);
+    $c->response->_context($c);
 
     # Allow engine to direct the prepare flow (for POE)
     if ( $c->engine->can('prepare') ) {
@@ -1560,8 +1587,14 @@ sub prepare {
         $c->prepare_cookies;
         $c->prepare_path;
 
-        # On-demand parsing
-        $c->prepare_body unless $c->config->{parse_on_demand};
+        # Prepare the body for reading, either by prepare_body
+        # or the user, if they are using $c->read
+        $c->prepare_read;
+        
+        # Parse the body unless the user wants it on-demand
+        unless ( $c->config->{parse_on_demand} ) {
+            $c->prepare_body;
+        }
     }
 
     my $method  = $c->req->method  || '';
@@ -1776,6 +1809,10 @@ C<$maxlength> defaults to the size of the request if not specified.
 You have to set C<< MyApp->config->{parse_on_demand} >> to use this
 directly.
 
+Warning: If you use read(), Catalyst will not process the body,
+so you will not be able to access POST parameters or file uploads via
+$c->request.  You must handle all body parsing yourself.
+
 =cut
 
 sub read { my $c = shift; return $c->engine->read( $c, @_ ) }
@@ -1827,8 +1864,16 @@ sub setup_components {
         search_path => [ map { s/^(?=::)/$class/; $_; } @paths ],
         %$config
     );
+
+    my @comps = sort { length $a <=> length $b } $locator->plugins;
+    my %comps = map { $_ => 1 } @comps;
     
-    for my $component ( sort { length $a <=> length $b } $locator->plugins ) {
+    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 } );
 
         my $module  = $class->setup_component( $component );
@@ -1836,6 +1881,8 @@ sub setup_components {
             $component => $module,
             map {
                 $_ => $class->setup_component( $_ )
+            } grep { 
+              not exists $comps{$_}
             } Devel::InnerPackage::list_packages( $component )
         );
         
@@ -1889,13 +1936,8 @@ sub setup_dispatcher {
         $dispatcher = 'Catalyst::Dispatcher::' . $dispatcher;
     }
 
-    if ( $ENV{CATALYST_DISPATCHER} ) {
-        $dispatcher = 'Catalyst::Dispatcher::' . $ENV{CATALYST_DISPATCHER};
-    }
-
-    if ( $ENV{ uc($class) . '_DISPATCHER' } ) {
-        $dispatcher =
-          'Catalyst::Dispatcher::' . $ENV{ uc($class) . '_DISPATCHER' };
+    if ( my $env = Catalyst::Utils::env_value( $class, 'DISPATCHER' ) ) {
+        $dispatcher = 'Catalyst::Dispatcher::' . $env;
     }
 
     unless ($dispatcher) {
@@ -1923,12 +1965,8 @@ sub setup_engine {
         $engine = 'Catalyst::Engine::' . $engine;
     }
 
-    if ( $ENV{CATALYST_ENGINE} ) {
-        $engine = 'Catalyst::Engine::' . $ENV{CATALYST_ENGINE};
-    }
-
-    if ( $ENV{ uc($class) . '_ENGINE' } ) {
-        $engine = 'Catalyst::Engine::' . $ENV{ uc($class) . '_ENGINE' };
+    if ( my $env = Catalyst::Utils::env_value( $class, 'ENGINE' ) ) {
+        $engine = 'Catalyst::Engine::' . $env;
     }
 
     if ( $ENV{MOD_PERL} ) {
@@ -2043,13 +2081,8 @@ Sets up the home directory.
 sub setup_home {
     my ( $class, $home ) = @_;
 
-    if ( $ENV{CATALYST_HOME} ) {
-        $home = $ENV{CATALYST_HOME};
-    }
-
-    if ( $ENV{ uc($class) . '_HOME' } ) {
-        $class =~ s/::/_/g;
-        $home = $ENV{ uc($class) . '_HOME' };
+    if ( my $env = Catalyst::Utils::env_value( $class, 'HOME' ) ) {
+        $home = $env;
     }
 
     unless ($home) {
@@ -2075,14 +2108,8 @@ sub setup_log {
         $class->log( Catalyst::Log->new );
     }
 
-    my $app_flag = Catalyst::Utils::class2env($class) . '_DEBUG';
-
-    if (
-          ( defined( $ENV{CATALYST_DEBUG} ) || defined( $ENV{$app_flag} ) )
-        ? ( $ENV{CATALYST_DEBUG} || $ENV{$app_flag} )
-        : $debug
-      )
-    {
+    my $env_debug = Catalyst::Utils::env_value( $class, 'DEBUG' );
+    if ( defined($env_debug) ? $env_debug : $debug ) {
         no strict 'refs';
         *{"$class\::debug"} = sub { 1 };
         $class->log->debug('Debug messages enabled');
@@ -2095,6 +2122,26 @@ Sets up plugins.
 
 =cut
 
+=head2 $c->setup_stats
+
+Sets up timing statistics class.
+
+=cut
+
+sub setup_stats {
+    my ( $class, $stats ) = @_;
+
+    Catalyst::Utils::ensure_class_loaded($class->stats_class);
+
+    my $env = Catalyst::Utils::env_value( $class, 'STATS' );
+    if ( defined($env) ? $env : ($stats || $class->debug ) ) {
+        no strict 'refs';
+        *{"$class\::use_stats"} = sub { 1 };
+        $class->log->debug('Statistics enabled');
+    }
+}
+
+
 =head2 $c->registered_plugins 
 
 Returns a sorted list of the plugins which have either been stated in the
@@ -2124,9 +2171,10 @@ the plugin name does not begin with C<Catalyst::Plugin::>.
         my ( $proto, $plugin, $instant ) = @_;
         my $class = ref $proto || $proto;
 
-        unless (Class::Inspector->loaded($plugin)) {
-            require Class::Inspector->filename($plugin);
-        }
+        # no ignore_loaded here, the plugin may already have been
+        # defined in memory and we don't want to error on "no file" if so
+
+        Catalyst::Utils::ensure_class_loaded( $plugin );
 
         $proto->_plugins->{$plugin} = 1;
         unless ($instant) {
@@ -2157,6 +2205,24 @@ the plugin name does not begin with C<Catalyst::Plugin::>.
 Returns an arrayref of the internal execution stack (actions that are
 currently executing).
 
+=head2 $c->stats_class
+
+Returns or sets the stats (timing statistics) class.
+
+=head2 $c->use_stats
+
+Returns 1 when stats collection is enabled.  Stats collection is enabled
+when the -Stats options is set, debug is on or when the <MYAPP>_STATS
+environment variable is set.
+
+Note that this is a static method, not an accessor and should be overloaded
+by declaring "sub use_stats { 1 }" in your MyApp.pm, not by calling $c->use_stats(1).
+
+=cut
+
+sub use_stats { 0 }
+
+
 =head2 $c->write( $data )
 
 Writes $data to the output stream. When using this method directly, you
@@ -2204,8 +2270,8 @@ This causes C<MyApp::C::Foo::Bar> to map to C</Foo/Bar>.
 =head1 ON-DEMAND PARSER
 
 The request body is usually parsed at the beginning of a request,
-but if you want to handle input yourself or speed things up a bit,
-you can enable on-demand parsing with a config parameter.
+but if you want to handle input yourself, you can enable on-demand
+parsing with a config parameter.
 
     MyApp->config->{parse_on_demand} = 1;
     
@@ -2350,6 +2416,8 @@ Sam Vilain
 
 Sascha Kiefer
 
+Sebastian Willert
+
 Tatsuhiko Miyagawa
 
 Ulf Edvinsson