X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=catagits%2FCatalyst-Manual.git;a=blobdiff_plain;f=lib%2FCatalyst%2FManual%2FTutorial%2F03_MoreCatalystBasics.pod;h=4ac024c498c11727821eb97763bd3ffb80fc7cf0;hp=eb6092cee9a284cb7778e48173912185503601f0;hb=f4e9de4a3171fd75d04fa8e294fd9a0ae367bc18;hpb=01df1cc9a0dbe37b417f64b8f4f4bd0555a99d19

diff --git a/lib/Catalyst/Manual/Tutorial/03_MoreCatalystBasics.pod b/lib/Catalyst/Manual/Tutorial/03_MoreCatalystBasics.pod
index eb6092c..4ac024c 100644
--- a/lib/Catalyst/Manual/Tutorial/03_MoreCatalystBasics.pod
+++ b/lib/Catalyst/Manual/Tutorial/03_MoreCatalystBasics.pod
@@ -64,8 +64,9 @@ will be too limited to be of use to anyone, it should provide a basic
 environment where we can explore a variety of features used in virtually
 all web applications.
 
-You can check out the source code for this example from the Catalyst
-Subversion repository as per the instructions in
+Source code for the tutorial in included in the F</home/catalyst/Final>
+directory of the Tutorial Virtual machine (one subdirectory per
+chapter).  There are also instructions for downloading the code in
 L<Catalyst::Manual::Tutorial::01_Intro>.
 
 Please take a look at
@@ -81,7 +82,7 @@ the most trouble-free way to get started with Catalyst.
 =head1 CREATE A NEW APPLICATION
 
 The remainder of the tutorial will build an application called C<MyApp>.
-First use the Catalyst C<catalyst.pl> script to initialize the framework
+First use the Catalyst F<catalyst.pl> script to initialize the framework
 for the C<MyApp> application (make sure you aren't still inside the
 directory of the C<Hello> application from the previous chapter of the
 tutorial or in a directory that already has a "MyApp" subdirectory):
@@ -108,14 +109,14 @@ if you are using Strawberry Perl.)
 =head1 EDIT THE LIST OF CATALYST PLUGINS
 
 One of the greatest benefits of Catalyst is that it has such a large
-library of bases classes and plugins available that you can use easily
+library of base classes and plugins available that you can use to easily
 add functionality to your application. Plugins are used to seamlessly
 integrate existing Perl modules into the overall Catalyst framework. In
 general, they do this by adding additional methods to the C<context>
 object (generally written as C<$c>) that Catalyst passes to every
 component throughout the framework.
 
-Take a look at the file C<lib/MyApp.pm> that the helper created above.
+Take a look at the file F<lib/MyApp.pm> that the helper created above.
 By default, Catalyst enables three plugins/flags:
 
 =over 4
@@ -125,7 +126,7 @@ By default, Catalyst enables three plugins/flags:
 C<-Debug> Flag
 
 Enables the Catalyst debug output you saw when we started the
-C<script/myapp_server.pl> development server earlier.  You can remove
+F<script/myapp_server.pl> development server earlier.  You can remove
 this item when you place your application into production.
 
 To be technically correct, it turns out that C<-Debug> is not a plugin,
@@ -133,7 +134,7 @@ but a I<flag>.  Although most of the items specified on the C<use
 Catalyst> line of your application class will be plugins, Catalyst
 supports a limited number of flag options (of these, C<-Debug> is the
 most common).  See the documentation for
-C<https://metacpan.org/module/Catalyst|Catalyst.pm> to get details on
+L<https://metacpan.org/module/Catalyst|Catalyst.pm> to get details on
 other flags (currently C<-Engine>, C<-Home>, C<-Log>, and C<-Stats>).
 
 If you prefer, there are several other ways to enable debug output:
@@ -142,22 +143,22 @@ If you prefer, there are several other ways to enable debug output:
 
 =item *
 
-Use the C<$c-E<gt>debug> method on the C<$c> Catalyst context object
+the C<< $c->debug >> method on the C<$c> Catalyst context object
 
 =item *
 
-The C<-d> option to C<script/myapp_server.pl>
+the C<-d> option on the F<script/myapp_server.pl> script
 
 =item *
 
-The C<CATALYST_DEBUG=1> environment variable (or use C<CATALYST_DEBUG=0>
-to temporarily disable debug output).
+the C<CATALYST_DEBUG=1> environment variable (or C<CATALYST_DEBUG=0>
+to temporarily disable debug output)
 
 =back
 
 B<TIP>: Depending on your needs, it can be helpful to permanently remove
 C<-Debug> from C<lib/MyApp.pm> and then use the C<-d> option to
-C<script/myapp_server.pl> to re-enable it when needed.  We will not be
+F<script/myapp_server.pl> to re-enable it when needed.  We will not be
 using that approach in the tutorial, but feel free to make use of it in
 your own projects.
 
@@ -179,13 +180,13 @@ L<Catalyst::Devel> prior to version 1.06, be aware that
 Catalyst changed the default format from YAML to the more
 straightforward C<Config::General> style.  This tutorial uses the newer
 C<myapp.conf> file for C<Config::General>. However, Catalyst supports
-both formats and will automatically use either C<myapp.conf> or
-C<myapp.yml> (or any other format supported by
+both formats and will automatically use either F<myapp.conf> or
+F<myapp.yml> (or any other format supported by
 L<Catalyst::Plugin::ConfigLoader> and
 L<Config::Any>).  If you are using a version of
 Catalyst::Devel prior to 1.06, you can convert to the newer format by
-simply creating the C<myapp.conf> file manually and deleting
-C<myapp.yml>.  The default contents of the C<myapp.conf> you create
+simply creating the F<myapp.conf> file manually and deleting
+F<myapp.yml>.  The default contents of the F<myapp.conf> you create
 should only consist of one line:
 
     name MyApp
@@ -205,8 +206,8 @@ images and CSS files, from the development server.
 
 =back
 
-For our application, we want to add one new plugin into the mix.  To do
-this, edit C<lib/MyApp.pm> (this file is generally referred to as your
+For our application, we want to add one new plugin to the mix.  To do
+this, edit F<lib/MyApp.pm> (this file is generally referred to as your
 I<application class>) and delete the lines with:
 
     use Catalyst qw/
@@ -222,7 +223,7 @@ Then replace it with:
         -Debug
         ConfigLoader
         Static::Simple
-    
+
         StackTrace
     /;
 
@@ -236,9 +237,9 @@ Don't let these variations confuse you -- they all accomplish the same
 result.
 
 This tells Catalyst to start using one additional plugin,
-L<Catalyst::Plugin::StackTrace>, to add a stack trace to the standard
-Catalyst "debug screen" (the screen Catalyst sends to your browser when
-an error occurs). Be aware that
+L<Catalyst::Plugin::StackTrace>, to add a stack trace near the top of
+the standard Catalyst "debug screen" (the screen Catalyst sends to your
+browser when an error occurs). Be aware that
 L<StackTrace|Catalyst::Plugin::StackTrace> output appears in your
 browser, not in the console window from which you're running your
 application, which is where logging output usually goes.
@@ -257,7 +258,7 @@ B<Notes:>
 =item *
 
 C<__PACKAGE__> is just a shorthand way of referencing the name of the
-package where it is used.  Therefore, in C<MyApp.pm>, C<__PACKAGE__> is
+package where it is used.  Therefore, in F<MyApp.pm>, C<__PACKAGE__> is
 equivalent to C<MyApp>.
 
 =item *
@@ -275,13 +276,13 @@ lines as shown here or place them all on one line.
 =item *
 
 If you want to see what the StackTrace error screen looks like, edit
-C<lib/MyApp/Controller/Root.pm> and put a C<die "Oops";> command in the
+F<lib/MyApp/Controller/Root.pm> and put a C<die "Oops";> command in the
 C<sub index :Path :Args(0)> method.  Then start the development server
 and open C<http://localhost:3000/> in your browser.  You should get a
 screen that starts with "Caught exception in
 MyApp::Controller::Root->index" with sections showing a stacktrace,
 information about the Request and Response objects, the stash (something
-we will learn about soon), the applications configuration configuration.
+we will learn about soon), and the applications configuration.
 B<Just don't forget to remove the die before you continue the tutorial!>
 :-)
 
@@ -298,35 +299,35 @@ Use the Catalyst C<create> script to add a controller for book-related
 actions:
 
     $ script/myapp_create.pl controller Books
-     exists "/root/MyApp/script/../lib/MyApp/Controller"
-     exists "/root/MyApp/script/../t"
-    created "/root/MyApp/script/../lib/MyApp/Controller/Books.pm"
-    created "/root/MyApp/script/../t/controller_Books.t"
+     exists "/home/catalyst/MyApp/script/../lib/MyApp/Controller"
+     exists "/home/catalyst/MyApp/script/../t"
+    created "/home/catalyst/MyApp/script/../lib/MyApp/Controller/Books.pm"
+    created "/home/catalyst/MyApp/script/../t/controller_Books.t"
 
-Then edit C<lib/MyApp/Controller/Books.pm> (as discussed in
+Then edit F<lib/MyApp/Controller/Books.pm> (as discussed in
 L<Chapter 2|Catalyst::Manual::Tutorial::02_CatalystBasics> of
-the Tutorial, Catalyst has a separate directory under C<lib/MyApp> for
-each of the three parts of MVC: C<Model>, C<View>, and C<Controller>)
+the Tutorial, Catalyst has a separate directory under F<lib/MyApp> for
+each of the three parts of MVC: C<Model>, C<View> and C<Controller>)
 and add the following method to the controller:
 
     =head2 list
-    
+
     Fetch all book objects and pass to books/list.tt2 in stash to be displayed
-    
+
     =cut
-    
+
     sub list :Local {
         # Retrieve the usual Perl OO '$self' for this object. $c is the Catalyst
         # 'Context' that's used to 'glue together' the various components
         # that make up the application
         my ($self, $c) = @_;
-    
+
         # Retrieve all of the book records as book model objects and store in the
         # stash where they can be accessed by the TT template
         # $c->stash(books => [$c->model('DB::Book')->all]);
         # But, for now, use this code until we create the model later
         $c->stash(books => '');
-    
+
         # Set the TT template to use.  You will almost always want to do this
         # in your action methods (action methods respond to user input in
         # your controllers).
@@ -395,11 +396,11 @@ controller down through the most specific class>.
 
 B<:Path> -- C<:Path> actions let you map a method to an explicit URI
 path.  For example, "C<:Path('list')>" in
-C<lib/MyApp/Controller/Books.pm> would match on the URL
+F<lib/MyApp/Controller/Books.pm> would match on the URL
 C<http://localhost:3000/books/list>, but "C<:Path('/list')>" would match
 on C<http://localhost:3000/list> (because of the leading slash).  You
 can use C<:Args()> to specify how many arguments an action should
-accept.  See L<Catalyst::Manual::Intro/Action_types> for more
+accept.  See L<Catalyst::Manual::Intro/Action-types> for more
 information and examples.
 
 =item *
@@ -438,7 +439,7 @@ not discussed here (C<Regex> and C<LocalRegex>).
 As mentioned in L<Chapter 2|Catalyst::Manual::Tutorial::02_CatalystBasics>
 of the tutorial, views are where you render output, typically for
 display in the user's web browser (but can generate other types of
-output such as PDF or JSON).  The code in C<lib/MyApp/View> selects the
+output such as PDF or JSON).  The code in F<lib/MyApp/View> selects the
 I<type> of view to use, with the actual rendering template found in the
 C<root> directory.  As with virtually every aspect of Catalyst, options
 abound when it comes to the specific view technology you adopt inside
@@ -460,10 +461,10 @@ For our book application, enter the following command to enable the
 C<TT> style of view rendering:
 
     $ script/myapp_create.pl view HTML TT
-     exists "/root/MyApp/script/../lib/MyApp/View"
-     exists "/root/MyApp/script/../t"
-     created "/root/MyApp/script/../lib/MyApp/View/HTML.pm"
-     created "/root/MyApp/script/../t/view_HTML.t"
+     exists "/home/catalyst/MyApp/script/../lib/MyApp/View"
+     exists "/home/catalyst/MyApp/script/../t"
+     created "/home/catalyst/MyApp/script/../lib/MyApp/View/HTML.pm"
+     created "/home/catalyst/MyApp/script/../t/view_HTML.t"
 
 This creates a view called C<HTML> (the first argument) in a file called
 C<HTML.pm> that uses L<Catalyst::View::TT> (the second argument) as the
@@ -476,7 +477,7 @@ typical "wrapper page" type of configuration (where the "wrapper"
 controls the overall "look and feel" of your site from a single file or
 set of files).
 
-Edit C<lib/MyApp/View/HTML.pm> and you should see something similar to
+Edit F<lib/MyApp/View/HTML.pm> and you should see something similar to
 the following:
 
     __PACKAGE__->config(
@@ -496,8 +497,8 @@ This changes the default extension for Template Toolkit from '.tt' to
 '.tt2'.
 
 You can also configure components in your application class. For
-example, Edit C<lib/MyApp.pm> and you should see the default
-configuration above the call to C<_PACKAGE__-E<gt>setup> (your defaults
+example, Edit F<lib/MyApp.pm> and you should see the default
+configuration above the call to C<< _PACKAGE__->setup >> (your defaults
 could be different depending on the version of Catalyst you are using):
 
     __PACKAGE__->config(
@@ -508,7 +509,7 @@ could be different depending on the version of Catalyst you are using):
 
 
 Change this to match the following (insert a new
-C<__PACKAGE__-E<gt>config> below the existing statement):
+C<< __PACKAGE__->config >> below the existing statement):
 
     __PACKAGE__->config(
         name => 'MyApp',
@@ -526,17 +527,17 @@ C<__PACKAGE__-E<gt>config> below the existing statement):
     );
 
 This changes the base directory for your template files from C<root> to
-C<root/src>.
+F<root/src>.
 
 Please stick with the settings above for the duration of the tutorial,
 but feel free to use whatever options you desire in your applications
-(as with most things Perl, there's more than one way to do it...).
+(as with most things in Perl, there's more than one way to do it...).
 
-B<Note:> We will use C<root/src> as the base directory for our template
+B<Note:> We will use F<root/src> as the base directory for our template
 files, with a full naming convention of
-C<root/src/_controller_name_/_action_name_.tt2>.  Another popular option
-is to use C<root/> as the base (with a full filename pattern of
-C<root/_controller_name_/_action_name_.tt2>).
+F<root/src/_controller_name_/_action_name_.tt2>.  Another popular option
+is to use F<root/> as the base (with a full filename pattern of
+F<root/_controller_name_/_action_name_.tt2>).
 
 
 =head2 Create a TT Template Page
@@ -545,17 +546,17 @@ First create a directory for book-related TT templates:
 
     $ mkdir -p root/src/books
 
-Then create C<root/src/books/list.tt2> in your editor and enter:
+Then create F<root/src/books/list.tt2> in your editor and enter:
 
     [% # This is a TT comment. -%]
-    
+
     [%- # Provide a title -%]
     [% META title = 'Book List' -%]
-    
+
     [% # Note That the '-' at the beginning or end of TT code  -%]
     [% # "chomps" the whitespace/newline at that end of the    -%]
     [% # output (use View Source in browser to see the effect) -%]
-    
+
     [% # Some basic HTML with a loop to display books -%]
     <table>
     <tr><th>Title</th><th>Rating</th><th>Author(s)</th></tr>
@@ -581,7 +582,7 @@ looping, conditional logic, etc.  In general, TT simplifies the usual
 range of Perl operators down to the single dot (".") operator.  This
 applies to operations as diverse as method calls, hash lookups, and list
 index values (see L<Template::Manual::Variables> for details and
-examples).  In addition to the usual L<Template> module Pod
+examples).  In addition to the usual L<Template::Toolkit> module Pod
 documentation, you can access the TT manual at
 L<https://metacpan.org/module/Template::Manual>.
 
@@ -622,7 +623,7 @@ tutorial.
 In this step, we make a text file with the required SQL commands to
 create a database table and load some sample data.  We will use SQLite
 (L<http://www.sqlite.org>), a popular database that is lightweight and
-easy to use. Be sure to get at least version 3. Open C<myapp01.sql> in
+easy to use. Be sure to get at least version 3. Open F<myapp01.sql> in
 your editor and enter:
 
     --
@@ -670,15 +671,15 @@ your editor and enter:
     INSERT INTO book_author VALUES (4, 7);
     INSERT INTO book_author VALUES (5, 8);
 
-Then use the following command to build a C<myapp.db> SQLite database:
+Then use the following command to build a F<myapp.db> SQLite database:
 
     $ sqlite3 myapp.db < myapp01.sql
 
 If you need to create the database more than once, you probably want to
 issue the C<rm myapp.db> command to delete the database before you use
-the C<sqlite3 myapp.db E<lt> myapp01.sql> command.
+the C<< sqlite3 myapp.db < myapp01.sql >> command.
 
-Once the C<myapp.db> database file has been created and initialized, you
+Once the F<myapp.db> database file has been created and initialized, you
 can use the SQLite command line environment to do a quick dump of the
 database contents:
 
@@ -755,7 +756,7 @@ currently installed version numbers with the following commands.
     $ perl -MCatalyst::Model::DBIC::Schema\ 999
     $ perl -MDBD::SQLite\ 999
 
-Before you continue, make sure your C<myapp.db> database file is in the
+Before you continue, make sure your F<myapp.db> database file is in the
 application's topmost directory. Now use the model helper with the
 C<create=static> option to read the database with
 L<DBIx::Class::Schema::Loader> and
@@ -764,25 +765,25 @@ automatically build the required files for us:
     $ script/myapp_create.pl model DB DBIC::Schema MyApp::Schema \
         create=static dbi:SQLite:myapp.db \
         on_connect_do="PRAGMA foreign_keys = ON"
-     exists "/root/MyApp/script/../lib/MyApp/Model"
-     exists "/root/MyApp/script/../t"
-    Dumping manual schema for MyApp::Schema to directory /root/MyApp/script/../lib ...
+     exists "/home/catalyst/MyApp/script/../lib/MyApp/Model"
+     exists "/home/catalyst/MyApp/script/../t"
+    Dumping manual schema for MyApp::Schema to directory /home/catalyst/MyApp/script/../lib ...
     Schema dump completed.
-    created "/root/MyApp/script/../lib/MyApp/Model/DB.pm"
-    created "/root/MyApp/script/../t/model_DB.t"
+    created "/home/catalyst/MyApp/script/../lib/MyApp/Model/DB.pm"
+    created "/home/catalyst/MyApp/script/../t/model_DB.t"
 
 Please note the '\' above.  Depending on your environment, you might be
 able to cut and paste the text as shown or need to remove the '\'
 character to that the command is all on a single line.
 
-The C<script/myapp_create.pl> command breaks down like this:
+The F<script/myapp_create.pl> command breaks down like this:
 
 =over 4
 
 =item *
 
 C<DB> is the name of the model class to be created by the helper in
-the C<lib/MyApp/Model> directory.
+the F<lib/MyApp/Model> directory.
 
 =item *
 
@@ -793,13 +794,13 @@ model inside of Catalyst.
 =item *
 
 C<MyApp::Schema> is the name of the DBIC schema file written to
-C<lib/MyApp/Schema.pm>.
+F<lib/MyApp/Schema.pm>.
 
 =item *
 
 C<create=static> causes L<DBIx::Class::Schema::Loader> to load the
 schema as it runs and then write that information out into
-C<lib/MyApp/Schema.pm> and files under the C<lib/MyApp/Schema>
+F<lib/MyApp/Schema.pm> and files under the F<lib/MyApp/Schema>
 directory.
 
 =item *
@@ -813,19 +814,19 @@ And finally, the C<on_connect_do> string requests that
 L<DBIx::Class::Schema::Loader> create
 foreign key relationships for us (this is not needed for databases such
 as PostgreSQL and MySQL, but is required for SQLite). If you take a look
-at C<lib/MyApp/Model/DB.pm>, you will see that the SQLite pragma is
+at F<lib/MyApp/Model/DB.pm>, you will see that the SQLite pragma is
 propagated to the Model, so that SQLite's recent (and optional) foreign
 key enforcement is enabled at the start of every database connection.
 
 =back
 
 
-If you look in the C<lib/MyApp/Schema.pm> file, you will find that it
+If you look in the F<lib/MyApp/Schema.pm> file, you will find that it
 only contains a call to the C<load_namespaces> method.  You will also
-find that C<lib/MyApp> contains a C<Schema> subdirectory, which then has
+find that F<lib/MyApp> contains a C<Schema> subdirectory, which then has
 a subdirectory called "Result".  This "Result" subdirectory then has
 files named according to each of the tables in our simple database
-(C<Author.pm>, C<BookAuthor.pm>, and C<Book.pm>).  These three files are
+(F<Author.pm>, F<BookAuthor.pm>, and F<Book.pm>).  These three files are
 called "Result Classes" (or
 "L<ResultSource Classes|DBIx::Class::ResultSource>") in DBIx::Class
 nomenclature. Although the Result Class files are named after tables in
@@ -834,7 +835,7 @@ returned by DBIC (more on this later, especially in
 L<Catalyst::Manual::Tutorial::04_BasicCRUD/EXPLORING THE POWER OF DBIC>).
 
 The idea with the Result Source files created under
-C<lib/MyApp/Schema/Result> by the C<create=static> option is to only
+F<lib/MyApp/Schema/Result> by the C<create=static> option is to only
 edit the files below the C<# DO NOT MODIFY THIS OR ANYTHING ABOVE!>
 warning. If you place all of your changes below that point in the file,
 you can regenerate the automatically created information at the top of
@@ -842,20 +843,20 @@ each file should your database structure get updated.
 
 Also note the "flow" of the model information across the various files
 and directories.  Catalyst will initially load the model from
-C<lib/MyApp/Model/DB.pm>.  This file contains a reference to
-C<lib/MyApp/Schema.pm>, so that file is loaded next.  Finally, the call
+F<lib/MyApp/Model/DB.pm>.  This file contains a reference to
+F<lib/MyApp/Schema.pm>, so that file is loaded next.  Finally, the call
 to C<load_namespaces> in C<Schema.pm> will load each of the "Result
-Class" files from the C<lib/MyApp/Schema/Result> subdirectory.  The
+Class" files from the F<lib/MyApp/Schema/Result> subdirectory.  The
 final outcome is that Catalyst will dynamically create three
 table-specific Catalyst models every time the application starts (you
 can see these three model files listed in the debug output generated
 when you launch the application).
 
-Additionally, the C<lib/MyApp/Schema.pm> model can easily be loaded
+Additionally, the F<lib/MyApp/Schema.pm> model can easily be loaded
 outside of Catalyst, for example, in command-line utilities and/or cron
-jobs. C<lib/MyApp/Model/DB.pm> provides a very thin "bridge" between
-Catalyst this external database model.  Once you see how we can add some
-powerful features to our DBIC model in
+jobs. F<lib/MyApp/Model/DB.pm> provides a very thin "bridge" between
+Catalyst and this external database model.  Once you see how we can
+add some powerful features to our DBIC model in
 L<Chapter 4|Catalyst::Manual::Tutorial::04_BasicCRUD>, the elegance
 of this approach will start to become more obvious.
 
@@ -879,41 +880,41 @@ L<DBIx::Class::Schema::Loader> version C<0.05000> or later.
 
 =head1 ENABLE THE MODEL IN THE CONTROLLER
 
-Open C<lib/MyApp/Controller/Books.pm> and un-comment the model code we
-left disabled earlier so that your version matches the following (un-
-comment the line containing C<[$c-E<gt>model('DB::Book')-E<gt>all]> and
-delete the next 2 lines):
+Open F<lib/MyApp/Controller/Books.pm> and un-comment the model code we
+left disabled earlier so that your version matches the following
+(un-comment the line containing C<< [$c->model('DB::Book')->all] >>
+and delete the next 2 lines):
 
     =head2 list
-    
+
     Fetch all book objects and pass to books/list.tt2 in stash to be displayed
-    
+
     =cut
-    
+
     sub list :Local {
         # Retrieve the usual Perl OO '$self' for this object. $c is the Catalyst
         # 'Context' that's used to 'glue together' the various components
         # that make up the application
         my ($self, $c) = @_;
-    
+
         # Retrieve all of the book records as book model objects and store
         # in the stash where they can be accessed by the TT template
         $c->stash(books => [$c->model('DB::Book')->all]);
-    
+
         # Set the TT template to use.  You will almost always want to do this
         # in your action methods (action methods respond to user input in
         # your controllers).
         $c->stash(template => 'books/list.tt2');
     }
 
-B<TIP>: You may see the C<$c-E<gt>model('DB::Book')> un-commented above
-written as C<$c-E<gt>model('DB')-E<gt>resultset('Book')>.  The two are
-equivalent.  Either way, C<$c-E<gt>model> returns a
+B<TIP>: You may see the C<< $c->model('DB::Book') >> un-commented above
+written as C<< $c->model('DB')->resultset('Book') >>.  The two are
+equivalent.  Either way, C<< $c->model >> returns a
 L<DBIx::Class::ResultSet> which handles queries
 against the database and iterating over the set of results that is
 returned.
 
-We are using the C<-E<gt>all> to fetch all of the books.  DBIC supports
+We are using the C<< ->all >> to fetch all of the books.  DBIC supports
 a wide variety of more advanced operations to easily do things like
 filtering and sorting the results.  For example, the following could be
 used to sort the results by descending title:
@@ -942,7 +943,7 @@ you are using a different shell (for example, under tcsh, use
 C<setenv DBIC_TRACE 1>).
 
 B<NOTE:> You can also set this in your code using
-C<$class-E<gt>storage-E<gt>debug(1);>.  See
+C<< $class->storage->debug(1); >>.  See
 L<DBIx::Class::Manual::Troubleshooting> for details (including options
 to log to a file instead of displaying to the Catalyst development
 server log).
@@ -958,11 +959,11 @@ display something like:
     | Catalyst::Plugin::ConfigLoader  0.30                                       |
     | Catalyst::Plugin::StackTrace  0.11                                         |
     '----------------------------------------------------------------------------'
-    
+
     [debug] Loaded dispatcher "Catalyst::Dispatcher"
     [debug] Loaded engine "Catalyst::Engine"
-    [debug] Found home "/root/MyApp"
-    [debug] Loaded Config "/root/MyApp/myapp.conf"
+    [debug] Found home "/home/catalyst/MyApp"
+    [debug] Loaded Config "/home/catalyst/MyApp/myapp.conf"
     [debug] Loaded components:
     .-----------------------------------------------------------------+----------.
     | Class                                                           | Type     |
@@ -975,7 +976,7 @@ display something like:
     | MyApp::Model::DB::BookAuthor                                    | class    |
     | MyApp::View::HTML                                               | instance |
     '-----------------------------------------------------------------+----------'
-    
+
     [debug] Loaded Private actions:
     .----------------------+--------------------------------------+--------------.
     | Private              | Class                                | Method       |
@@ -986,7 +987,7 @@ display something like:
     | /books/index         | MyApp::Controller::Books             | index        |
     | /books/list          | MyApp::Controller::Books             | list         |
     '----------------------+--------------------------------------+--------------'
-    
+
     [debug] Loaded Path actions:
     .-------------------------------------+--------------------------------------.
     | Path                                | Private                              |
@@ -996,13 +997,13 @@ display something like:
     | /books                              | /books/index                         |
     | /books/list                         | /books/list                          |
     '-------------------------------------+--------------------------------------'
-    
+
     [info] MyApp powered by Catalyst 5.80020
     HTTP::Server::PSGI: Accepting connections at http://0:3000
 
-B<NOTE:> Be sure you run the C<script/myapp_server.pl> command from the
-'base' directory of your application, not inside the C<script> directory
-itself or it will not be able to locate the C<myapp.db> database file.
+B<NOTE:> Be sure you run the F<script/myapp_server.pl> command from the
+'base' directory of your application, not inside the F<script> directory
+itself or it will not be able to locate the F<myapp.db> database file.
 You can use a fully qualified or a relative path to locate the database
 file, but we did not specify that when we ran the model helper earlier.
 
@@ -1029,11 +1030,11 @@ the Catalyst welcome page.
 
 Next, to view the book list, change the URL in your browser to
 L<http://localhost:3000/books/list>. You should get a list of the five
-books loaded by the C<myapp01.sql> script above without any formatting.
+books loaded by the F<myapp01.sql> script above without any formatting.
 The rating for each book should appear on each row, but the "Author(s)"
 column will still be blank (we will fill that in later).
 
-Also notice in the output of the C<script/myapp_server.pl> that
+Also notice in the output of the F<script/myapp_server.pl> that
 L<DBIx::Class> used the following SQL to retrieve the data:
 
     SELECT me.id, me.title, me.rating FROM book me
@@ -1059,7 +1060,7 @@ files.
 In order to create a wrapper, you must first edit your TT view and tell
 it where to find your wrapper file.
 
-Edit your TT view in C<lib/MyApp/View/HTML.pm> and change it to match
+Edit your TT view in F<lib/MyApp/View/HTML.pm> and change it to match
 the following:
 
     __PACKAGE__->config(
@@ -1080,7 +1081,7 @@ the following:
 
 Next you need to set up your wrapper template.  Basically, you'll want
 to take the overall layout of your site and put it into this file.  For
-the tutorial, open C<root/src/wrapper.tt2> and input the following:
+the tutorial, open F<root/src/wrapper.tt2> and input the following:
 
     <?xml version="1.0" encoding="UTF-8"?>
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" [%#
@@ -1090,7 +1091,7 @@ the tutorial, open C<root/src/wrapper.tt2> and input the following:
     <title>[% template.title or "My Catalyst App!" %]</title>
     <link rel="stylesheet" href="[% c.uri_for('/static/css/main.css') %]" />
     </head>
-    
+
     <body>
     <div id="outer">
     <div id="header">
@@ -1099,7 +1100,7 @@ the tutorial, open C<root/src/wrapper.tt2> and input the following:
         [%# Insert the page title -%]
         <h1>[% template.title or site.title %]</h1>
     </div>
-    
+
     <div id="bodyblock">
     <div id="menu">
         Navigation:
@@ -1109,7 +1110,7 @@ the tutorial, open C<root/src/wrapper.tt2> and input the following:
                 %]" title="Catalyst Welcome Page">Welcome</a></li>
         </ul>
     </div><!-- end menu -->
-    
+
     <div id="content">
         [%# Status and error messages %]
         <span class="message">[% status_msg %]</span>
@@ -1118,10 +1119,10 @@ the tutorial, open C<root/src/wrapper.tt2> and input the following:
         [% content %]
     </div><!-- end content -->
     </div><!-- end bodyblock -->
-    
+
     <div id="footer">Copyright (c) your name goes here</div>
     </div><!-- end outer -->
-    
+
     </body>
     </html>
 
@@ -1131,10 +1132,10 @@ Notice the status and error message sections in the code above:
     <span class="error">[% error_msg %]</span>
 
 If we set either message in the Catalyst stash (e.g.,
-C<$c-E<gt>stash-E<gt>{status_msg} = 'Request was successful!'>) it will
+C<< $c->stash->{status_msg} = 'Request was successful!' >>) it will
 be displayed whenever any view used by that request is rendered.  The
 C<message> and C<error> CSS styles can be customized to suit your needs
-in the C<root/static/css/main.css> file we create below.
+in the F<root/static/css/main.css> file we create below.
 
 B<Notes:>
 
@@ -1163,7 +1164,7 @@ directory:
 
     $ mkdir root/static/css
 
-Then open the file C<root/static/css/main.css> (the file referenced in
+Then open the file F<root/static/css/main.css> (the file referenced in
 the stylesheet href link of our wrapper above) and add the following
 content:
 
@@ -1214,7 +1215,7 @@ of high-quality CSS functionality.
 Hit "Reload" in your web browser and you should now see a formatted
 version of our basic book list. (Again, the development server should
 have automatically restarted when you made changes to
-C<lib/MyApp/View/HTML.pm>. If you are not using the "-r" option, you
+F<lib/MyApp/View/HTML.pm>. If you are not using the "-r" option, you
 will need to hit C<Ctrl-C> and manually restart it. Also note that the
 development server does I<NOT> need to restart for changes to the TT and
 static files we created and edited in the C<root> directory -- those
@@ -1232,19 +1233,19 @@ template -- the wrapper will provide the overall feel of the page.
 If you take a look at the Schema files automatically generated by
 L<DBIx::Class::Schema::Loader>, you will see that it has already defined
 C<has_many> and C<belongs_to> relationships on each side of our foreign
-keys. For example, take a look at C<lib/MyApp/Schema/Result/Book.pm> and
+keys. For example, take a look at F<lib/MyApp/Schema/Result/Book.pm> and
 notice the following code:
 
     =head1 RELATIONS
-    
+
     =head2 book_authors
-    
+
     Type: has_many
-    
+
     Related object: L<MyApp::Schema::Result::BookAuthor>
-    
+
     =cut
-    
+
     __PACKAGE__->has_many(
       "book_authors",
       "MyApp::Schema::Result::BookAuthor",
@@ -1300,20 +1301,20 @@ tools, you will need to manually define your C<has_many> and
 C<belongs_to> relationships. We recommend upgrading to the versions
 specified above. :-)
 
-Have a look at C<lib/MyApp/Schema/Result/BookAuthor.pm> and notice that
+Have a look at F<lib/MyApp/Schema/Result/BookAuthor.pm> and notice that
 there is a C<belongs_to> relationship defined that acts as the "mirror
 image" to the C<has_many> relationship we just looked at above:
 
     =head1 RELATIONS
-    
+
     =head2 book
-    
+
     Type: belongs_to
-    
+
     Related object: L<MyApp::Schema::Result::Book>
-    
+
     =cut
-    
+
     __PACKAGE__->belongs_to(
       "book",
       "MyApp::Schema::Result::Book",
@@ -1328,7 +1329,7 @@ Although recent versions of SQLite and L<DBIx::Class::Schema::Loader>
 automatically handle the C<has_many> and C<belongs_to> relationships,
 C<many_to_many> relationship bridges (not technically a relationship)
 currently need to be manually inserted.  To add a C<many_to_many>
-relationship bridge, first edit C<lib/MyApp/Schema/Result/Book.pm> and
+relationship bridge, first edit F<lib/MyApp/Schema/Result/Book.pm> and
 add the following text below the C<# You can replace this text...>
 comment:
 
@@ -1348,16 +1349,16 @@ C<1;> on a line by itself.
 The C<many_to_many> relationship bridge is optional, but it makes it
 easier to map a book to its collection of authors.  Without it, we would
 have to "walk" through the C<book_author> table as in
-C<$book-E<gt>book_author-E<gt>first-E<gt>author-E<gt>last_name> (we will
+C<< $book->book_author->first->author->last_name >> (we will
 see examples on how to use DBIx::Class objects in your code soon, but
-note that because C<$book-E<gt>book_author> can return multiple authors,
+note that because C<< $book->book_author >> can return multiple authors,
 we have to use C<first> to display a single author).  C<many_to_many>
 allows us to use the shorter
-C<$book-E<gt>author-E<gt>first-E<gt>last_name>. Note that you cannot
+C<< $book->author->first->last_name >>. Note that you cannot
 define a C<many_to_many> relationship bridge without also having the
 C<has_many> relationship in place.
 
-Then edit C<lib/MyApp/Schema/Result/Author.pm> and add the reverse
+Then edit F<lib/MyApp/Schema/Result/Author.pm> and add the reverse
 C<many_to_many> relationship bridge for C<Author> as follows (again, be
 careful to put in above the C<1;> but below the C<# DO NOT MODIFY THIS
 OR ANYTHING ABOVE!> comment):
@@ -1380,7 +1381,7 @@ alternate way to specify the trace option just in case):
     $ DBIC_TRACE=1 script/myapp_server.pl -r
 
 Make sure that the application loads correctly and that you see the
-three dynamically created model class (one for each of the Result
+three dynamically created model classes (one for each of the Result
 Classes we created).
 
 Then hit the URL L<http://localhost:3000/books/list> with your browser
@@ -1395,7 +1396,7 @@ update the template to do that.
 
 Let's add a new column to our book list page that takes advantage of the
 relationship information we manually added to our schema files in the
-previous section.  Edit C<root/src/books/list.tt2> and replace the
+previous section.  Edit F<root/src/books/list.tt2> and replace the
 "empty" table cell "<td></td>" with the following:
 
     ...
@@ -1441,30 +1442,30 @@ debug output (one for each book as the authors are being retrieved by
 DBIx::Class):
 
     SELECT me.id, me.title, me.rating FROM book me:
-    SELECT author.id, author.first_name, author.last_name FROM book_author me  
+    SELECT author.id, author.first_name, author.last_name FROM book_author me
     JOIN author author ON author.id = me.author_id WHERE ( me.book_id = ? ): '1'
-    SELECT author.id, author.first_name, author.last_name FROM book_author me  
+    SELECT author.id, author.first_name, author.last_name FROM book_author me
     JOIN author author ON author.id = me.author_id WHERE ( me.book_id = ? ): '2'
-    SELECT author.id, author.first_name, author.last_name FROM book_author me  
+    SELECT author.id, author.first_name, author.last_name FROM book_author me
     JOIN author author ON author.id = me.author_id WHERE ( me.book_id = ? ): '3'
-    SELECT author.id, author.first_name, author.last_name FROM book_author me  
+    SELECT author.id, author.first_name, author.last_name FROM book_author me
     JOIN author author ON author.id = me.author_id WHERE ( me.book_id = ? ): '4'
-    SELECT author.id, author.first_name, author.last_name FROM book_author me  
+    SELECT author.id, author.first_name, author.last_name FROM book_author me
     JOIN author author ON author.id = me.author_id WHERE ( me.book_id = ? ): '5'
 
-Also note in C<root/src/books/list.tt2> that we are using "| html", a
-type of TT filter, to escape characters such as E<lt> and E<gt> to &lt;
+Also note in F<root/src/books/list.tt2> that we are using "| html", a
+type of TT filter, to escape characters such as < and > to &lt;
 and &gt; and avoid various types of dangerous hacks against your
 application.  In a real application, you would probably want to put "|
 html" at the end of every field where a user has control over the
 information that can appear in that field (and can therefore inject
 markup or code if you don't "neutralize" those fields).  In addition to
 "| html", Template Toolkit has a variety of other useful filters that
-can found in the documentation for L<Template::Filters>.  (While we are
-on the topic of security and escaping of dangerous values, one of the
-advantages of using tools like DBIC for database access or
+can be found in the documentation for L<Template::Filters>.  (While we
+are on the topic of security and escaping of dangerous values, one of
+the advantages of using tools like DBIC for database access or
 L<HTML::FormFu> for form management [see
-L<Chapter 9|Catalyst::Manual::Tutorial::09_AdvancedCRUD::09_FormFu>
+L<Chapter 9|Catalyst::Manual::Tutorial::09_AdvancedCRUD::09_FormFu>]
 is that they automatically handle most escaping for you and therefore
 dramatically increase the security of your app.)
 
@@ -1473,7 +1474,7 @@ dramatically increase the security of your app.)
 
 In some situations, it can be useful to run your application and display
 a page without using a browser.  Catalyst lets you do this using the
-C<scripts/myapp_test.pl> script.  Just supply the URL you wish to
+F<script/myapp_test.pl> script.  Just supply the URL you wish to
 display and it will run that request through the normal controller
 dispatch logic and use the appropriate view to render the output
 (obviously, complex pages may dump a lot of text to your terminal
@@ -1509,7 +1510,7 @@ forwards processing to your view in order to generate the appropriate
 response output.  Catalyst uses
 L<Catalyst::Action::RenderView> by default
 to automatically perform this operation.  If you look in
-C<lib/MyApp/Controller/Root.pm>, you should see the empty definition for
+F<lib/MyApp/Controller/Root.pm>, you should see the empty definition for
 the C<sub end> method:
 
     sub end : ActionClass('RenderView') {}
@@ -1521,7 +1522,7 @@ C<RenderView> process:
 
 =item *
 
-C<Root.pm> is designed to hold application-wide logic.
+F<Root.pm> is designed to hold application-wide logic.
 
 =item *
 
@@ -1529,7 +1530,7 @@ At the end of a given user request, Catalyst will call the most specific
 C<end> method that's appropriate.  For example, if the controller for a
 request has an C<end> method defined, it will be called.  However, if
 the controller does not define a controller-specific C<end> method, the
-"global" C<end> method in C<Root.pm> will be called.
+"global" C<end> method in F<Root.pm> will be called.
 
 =item *
 
@@ -1544,7 +1545,7 @@ Because C<sub end> is empty, this effectively just runs the default
 logic in C<RenderView>.  However, you can easily extend the
 C<RenderView> logic by adding your own code inside the empty method body
 (C<{}>) created by the Catalyst Helpers when we first ran the
-C<catalyst.pl> to initialize our application.  See
+F<catalyst.pl> to initialize our application.  See
 L<Catalyst::Action::RenderView> for more
 detailed information on how to extend C<RenderView> in C<sub end>.
 
@@ -1563,7 +1564,7 @@ this URL:
 
 You should get a page with the following message at the top:
 
-    Caught exception in MyApp::Controller::Root->end "Forced debug - 
+    Caught exception in MyApp::Controller::Root->end "Forced debug -
     Scrubbed output at /usr/share/perl5/Catalyst/Action/RenderView.pm line 46."
 
 Along with a summary of your application's state at the end of the
@@ -1586,28 +1587,28 @@ By default, C<Catalyst::View::TT> will look for a template that uses the
 same name as your controller action, allowing you to save the step of
 manually specifying the template name in each action.  For example, this
 would allow us to remove the
-C<$c-E<gt>stash-E<gt>{template} = 'books/list.tt2';>
+C<< $c->stash->{template} = 'books/list.tt2'; >>
 line of our C<list> action in the Books controller.
 Open C<lib/MyApp/Controller/Books.pm> in your editor and comment out
 this line to match the following (only the
-C<$c-E<gt>stash-E<gt>{template}> line has changed):
+C<< $c->stash->{template} >> line has changed):
 
     =head2 list
-    
+
     Fetch all book objects and pass to books/list.tt2 in stash to be displayed
-    
+
     =cut
-    
+
     sub list :Local {
         # Retrieve the usual Perl OO '$self' for this object. $c is the Catalyst
         # 'Context' that's used to 'glue together' the various components
         # that make up the application
         my ($self, $c) = @_;
-    
+
         # Retrieve all of the book records as book model objects and store in the
         # stash where they can be accessed by the TT template
         $c->stash(books => [$c->model('DB::Book')->all]);
-    
+
         # Set the TT template to use.  You will almost always want to do this
         # in your action methods (actions methods respond to user input in
         # your controllers).
@@ -1618,40 +1619,41 @@ C<$c-E<gt>stash-E<gt>{template}> line has changed):
 You should now be able to access the L<http://localhost:3000/books/list>
 URL as before.
 
-B<NOTE:> Please note that if you use the default template technique, you
-will B<not> be able to use either the C<$c-E<gt>forward> or the
-C<$c-E<gt>detach> mechanisms (these are discussed in Chapter 2 and
+B<NOTE:> If you use the default template technique, you
+will B<not> be able to use either the C<< $c->forward >> or the
+C<< $c->detach >> mechanisms (these are discussed in Chapter 2 and
 Chapter 9 of the Tutorial).
 
-B<IMPORTANT:> Make sure that you do NOT skip the following section
+B<IMPORTANT:> Make sure that you do B<not> skip the following section
 before continuing to the next chapter 4 Basic CRUD.
 
 
 =head2 Return To A Manually Specified Template
 
-In order to be able to use C<$c-E<gt>forward> and C<$c-E<gt>detach>
+In order to be able to use C<< $c->forward >> and C<< $c->detach >>
 later in the tutorial, you should remove the comment from the statement
-in C<sub list> in C<lib/MyApp/Controller/Books.pm>:
+in C<sub list> in F<lib/MyApp/Controller/Books.pm>:
 
     $c->stash(template => 'books/list.tt2');
 
-Then delete the C<TEMPLATE_EXTENSION> line in C<lib/MyApp/View/HTML.pm>.
+Then delete the C<TEMPLATE_EXTENSION> line in F<lib/MyApp/View/HTML.pm>.
 
 Check the L<http://localhost:3000/books/list> URL in your browser.  It
 should look the same manner as with earlier sections.
 
 
+You can jump to the next chapter of the tutorial here:
+L<Basic CRUD|Catalyst::Manual::Tutorial::04_BasicCRUD>
+
+
 =head1 AUTHOR
 
 Kennedy Clark, C<hkclark@gmail.com>
 
 Feel free to contact the author for any errors or suggestions, but the
 best way to report issues is via the CPAN RT Bug system at
-<https://rt.cpan.org/Public/Dist/Display.html?Name=Catalyst-Manual>.
-
-The most recent version of the Catalyst Tutorial can be found at
-L<http://dev.catalyst.perl.org/repos/Catalyst/Catalyst-Manual/5.80/trunk/lib/Catalyst/Manual/Tutorial/>.
+L<https://rt.cpan.org/Public/Dist/Display.html?Name=Catalyst-Manual>.
 
-Copyright 2006-2010, Kennedy Clark, under the
+Copyright 2006-2011, Kennedy Clark, under the
 Creative Commons Attribution Share-Alike License Version 3.0
 (L<http://creativecommons.org/licenses/by-sa/3.0/us/>).