X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FManual%2FIntro.pod;h=f1b1f033c0dc270033ebb5e10d41f06f1be23074;hb=e5429fee2de5b8f0046ea53dd5a2ede04bcb1a9d;hp=cb09eebda97ca105334a0ea8e2e3b33cc6901277;hpb=6b10c72bff517a4eab3b52aa7f31e1a4cd499484;p=catagits%2FCatalyst-Runtime.git

diff --git a/lib/Catalyst/Manual/Intro.pod b/lib/Catalyst/Manual/Intro.pod
index cb09eeb..f1b1f03 100644
--- a/lib/Catalyst/Manual/Intro.pod
+++ b/lib/Catalyst/Manual/Intro.pod
@@ -43,11 +43,11 @@ control. Catalyst!
 
 =back
 
-If you're unfamiliar with MVC and design patterns, you may want to check out the
-original book on the subject, I<Design Patterns>, by Gamma, Helm, Johson and
-Vlissides, also known as the Gang of Four (GoF). You can also just google it.
-Many, many web application frameworks are based on MVC, including all those
-listed above.
+If you're unfamiliar with MVC and design patterns, you may want to check
+out the original book on the subject, I<Design Patterns>, by Gamma,
+Helm, Johnson, and Vlissides, also known as the Gang of Four (GoF). You
+can also just Google it.  Many, many web application frameworks are
+based on MVC, including all those listed above.
 
 =head3 Flexibility
 
@@ -84,7 +84,7 @@ With Catalyst you register your actions and address them directly. For example:
 
     sub hello : Global {
         my ( $self, $context ) = @_;
-        $context->response->output('Hello World!');
+        $context->response->body('Hello World!');
     }
 
 Now http://localhost:3000/hello prints "Hello World!".
@@ -184,7 +184,6 @@ application, load plugins, define application-wide actions, and extend Catalyst.
 
     MyApp->config(
         name => 'My Application',
-        root => '/home/joeuser/myapp/root',
 
         # You can put anything else you want in here:
         my_configuration_variable => 'something',
@@ -192,13 +191,13 @@ application, load plugins, define application-wide actions, and extend Catalyst.
 
     sub default : Private {
         my ( $self, $context ) = @_;
-        $context->response->output('Catalyst rockz!');
+        $context->response->body('Catalyst rockz!');
     }
 
     1;
 
-For most applications, Catalyst requires you to define only two config
-parameters:
+For most applications, Catalyst requires you to define only one config
+parameter:
 
 =over 4
 
@@ -206,15 +205,13 @@ parameters:
 
 Name of your application.
 
-=item * B<root>
-
-Path to additional files such as templates, images, or other static data.
-
 =back
 
-However, you can define as many parameters as you want for plugins or whatever
-you need. You can access them anywhere in your application via
-C<$context-E<gt>config-E<gt>{$param_name}>.
+Optionally, you can specify a B<root> parameter for templates and static data.
+If omitted, Catalyst will try to auto-detect the directory's location. You
+can define as many parameters as you want for plugins or whatever you
+need. You can access them anywhere in your application
+via C<$context-E<gt>config-E<gt>{$param_name}>.
 
 =head3 Context
 
@@ -233,7 +230,7 @@ Catalyst developers just call it C<$c>:
 
     sub hello : Global {
         my ( $self, $c ) = @_;
-        $c->res->output('Hello World!');
+        $c->res->body('Hello World!');
     }
 
 The Context contains several important objects:
@@ -261,7 +258,7 @@ query parameters, cookies, uploads, headers, and more.
 The response is like the request, but contains just response-specific
 information.
 
-    $c->res->output('Hello World');
+    $c->res->body('Hello World');
     $c->res->status(404);
     $c->res->redirect('http://oook.de');
 
@@ -298,7 +295,7 @@ application components. For an example, we return to our 'hello' action:
 
     sub show_message : Private {
         my ( $self, $c ) = @_;
-        $c->res->output( $c->stash->{message} );
+        $c->res->body( $c->stash->{message} );
     }
 
 Note that the stash should be used only for passing data in an individual
@@ -320,10 +317,24 @@ Catalyst supports several types of actions:
 
 =item * B<Literal>
 
+    package MyApp::C::My::Controller;
     sub bar : Path('foo/bar') { }
 
+Literal C<Path> actions will act relative to their current namespace. The above
+example matches only http://localhost:3000/my/controller/foo/bar. If you start
+your path with a forward slash, it will match from the root. Example:
+
+    package MyApp::C::My::Controller;
+    sub bar : Path('/foo/bar') { }
+
 Matches only http://localhost:3000/foo/bar.
 
+    package MyApp::C::My::Controller;
+    sub bar : Path { }
+
+By leaving the C<Path> definition empty, it will match on the namespace root.
+The above code matches http://localhost:3000/my/controller.
+
 =item * B<Regex>
 
     sub bar : Regex('^item(\d+)/order(\d+)$') { }
@@ -336,12 +347,29 @@ Regex matches act globally, i.e. without reference to the namespace from which
 it is called, so that a C<bar> method in the
 C<MyApp::Controller::Catalog::Order::Process> namespace won't match any form of
 C<bar>, C<Catalog>, C<Order>, or C<Process> unless you explicitly put this in
-the regex.
+the regex. To achieve the above, you should consider using a C<LocalRegex> action.
+
+=item * B<LocalRegex>
 
-If you use capturing parentheses to extract values within the matching URL (23,
-42 in the above example), those values are available in the $c->req->snippets
+    sub bar : LocalRegex('^widget(\d+)$') { }
+
+LocalRegex actions act locally. If you were to use C<bar> in
+C<MyApp::Controller::Catalog>, the above example would match urls like
+http://localhost:3000/catalog/widget23.
+
+If you omit the "C<^>" from your regex, then it will match any depth from the
+controller and not immediately off of the controller name. The following example
+differes from the above code in that it will match
+http://localhost:3000/catalog/foo/widget23 as well.
+
+    package MyApp::Controller::Catalog;
+    sub bar : LocalRegex('widget(\d+)$') { }
+
+For both LocalRegex and Regex actions, if you use capturing parentheses to
+extract values within the matching URL ("widget23" would capture "23" in the
+above example), those values are available in the $c->req->snippets
 array. If you want to pass arguments at the end of your URL, you must use regex
-action keys. See L</URL Argument Handling> below.
+action keys. See L</URL Path Handling> below.
 
 =item * B<Top-level>
 
@@ -402,6 +430,16 @@ Called when no other action matches. Could be used, for example, for
 displaying a generic frontpage for the main app, or an error page for
 individual controllers.
 
+If C<default> isn't acting how you would expect, look at using a
+L<Literal> C<Path> action (with an empty path string). The difference
+being that C<Path> takes arguments relative from the namespace and
+C<default> takes arguments relative from the root.
+
+=item * B<index : Private>
+
+C<index> is much like C<default> except that it takes no arguments
+and it is weighted slightly higher in the matching process.
+
 =item * B<begin : Private>
 
 Called at the beginning of a request, before any matching actions are
@@ -556,7 +594,7 @@ debugging enabled).
 
     sub show_message : Private {
         my ( $self, $c ) = @_;
-        $c->res->output( $c->stash->{message} );
+        $c->res->body( $c->stash->{message} );
     }
 
 A C<forward> does not create a new request, so your request
@@ -607,12 +645,12 @@ Here are some examples of how to forward to classes and methods.
 
     sub say_hello {
         my ( $self, $c ) = @_;
-        $c->res->output('Hello World!');
+        $c->res->body('Hello World!');
     }
 
     sub process {
         my ( $self, $c ) = @_;
-        $c->res->output('Goodbye World!');
+        $c->res->body('Goodbye World!');
     }
 
 Note that C<forward> returns to the calling action and continues
@@ -679,8 +717,8 @@ inherit from this class:
 
     script/myapp_create.pl view TT TT
 
-where the first C<TT> tells the script to create a Template Toolkit
-view, and the second tells the script that its name should be C<TT>.)
+where the first C<TT> tells the script that the name of the view should
+be C<TT>, and the second that it should be a Template Toolkit view.)
 
 This gives us a process() method and we can now just do
 $c->forward('MyApp::V::TT') to render our templates. The base class makes
@@ -788,7 +826,7 @@ can always call an outside module that serves as your Model:
 But by using a Model that is part of your Catalyst application, you gain
 several things: you don't have to C<use> each component, Catalyst will
 find and load it automatically at compile-time; you can C<forward> to
-the module, which can only be done to Catalyst componenents; and only
+the module, which can only be done to Catalyst components; and only
 Catalyst components can be fetched with
 C<$c-E<gt>comp('MyApp::M::SomeModel')>.
 
@@ -812,9 +850,9 @@ application.
 
     package MyApp::C::Login;
 
-    sign-in : Local { }
-    new-password : Local { }
-    sign-out : Local { }
+    sub sign-in : Local { }
+    sub new-password : Local { }
+    sub sign-out : Local { }
 
     package MyApp::C::Catalog;