=item *
The C<CATALYST_DEBUG=1> environment variable (or set it to
-zero to templorarily disable debug output).
+zero to temporarily disable debug output).
=back
the method without any attribute -- you can call it in your code, but
the Catalyst dispatcher will ignore it.)
-There are five types of "special" build-in C<:Private> actions:
+There are five types of "special" built-in C<:Private> actions:
C<begin>, C<end>, C<default>, C<index>, and C<auto>.
=over 4
Enter the following command to enable the C<TT> style of view
rendering for this tutorial:
- $ script/myapp_create.pl view TT TT
+ $ script/myapp_create.pl view HTML TT
exists "/home/me/MyApp/script/../lib/MyApp/View"
exists "/home/me/MyApp/script/../t"
- created "/home/me/MyApp/script/../lib/MyApp/View/TT.pm"
- created "/home/me/MyApp/script/../t/view_TT.t"
+ created "/home/me/MyApp/script/../lib/MyApp/View/HTML.pm"
+ created "/home/me/MyApp/script/../t/view_HTML.t"
-This simply creates a view called C<TT> (the second 'TT' argument) in
-a file called C<TT.pm> (the first 'TT' argument). It is now up to you
-to decide how you want to structure your view layout. For the
-tutorial, we will start with a very simple TT template to initially
-demonstrate the concepts, but quickly migrate to a more 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).
+This simply creates a view called C<HTML> in a file called C<HTML.pm> (the first
+argument). It is now up to you to decide how you want to structure your view
+layout. For the tutorial, we will start with a very simple TT template to
+initially demonstrate the concepts, but quickly migrate to a more 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/TT.pm> and you should see that the default
-contents contains something similar to the following:
+Edit C<lib/MyApp/View/HTML.pm> and you should see
+something similar to the following:
- __PACKAGE__->config(TEMPLATE_EXTENSION => '.tt');
+ __PACKAGE__->config(
+ TEMPLATE_EXTENSION => '.tt',
+ render_die => 1,
+ );
And update it to match:
__PACKAGE__->config(
# Change default TT extension
TEMPLATE_EXTENSION => '.tt2',
- # Set the location for TT files
- INCLUDE_PATH => [
- MyApp->path_to( 'root', 'src' ),
+ render_die => 1,
+ );
+
+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 that the default:
+
+ __PACKAGE__->setup;
+
+Above this, add config:
+
+ __PACKAGE__->config(
+ 'View::HTML' => {
+ #Set the location for TT files
+ INCLUDE_PATH => [
+ __PACKAGE__->path_to( 'root', 'src' ),
],
+ },
);
+ # This line was here already
+ __PACKAGE__->setup;
-B<NOTE:> Make sure to add a comma after '.tt2' outside the single
-quote.
+This changes the base directory for your template files from
+C<root> to C<root/src>.
-This changes the default extension for Template Toolkit from '.tt' to
-'.tt2' and changes the base directory for your template files from
-C<root> to C<root/src>. Stick with these conventions for 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
+The reason to do this outside the C<lib/MyApp/View/HTML.pm> file
+is that the template path is found with the C<path_to> method,
+to get a path relative to the application root (no matter where it
+is installed), but this requires the application to be loaded...
+
+Trying to set this setting in the view means that you have a chicken
+and egg problem, in that the view requires the application to be loaded,
+but loading the application loads the view.
+
+Putting the configuration which depends on the application class into
+that class is the neatest way to avoid this issue.
+
+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...).
B<Note:> We will use C<root/src> as the base directory for our
use C<root/> as the base (with a full filename pattern of
C<root/_controller_name_/_action_name_.tt2>).
-
=head2 Create a TT Template Page
First create a directory for book-related TT templates:
Although DBIx::Class has included support for a C<create=dynamic> mode
to automatically read the database structure every time the
-application starts, it's use is no longer recommended. While it can
+application starts, its use is no longer recommended. While it can
make for "flashy" demos, the use of the C<create=static> mode we use
below can be implemented just as quickly and provides many advantages
(such as the ability to add your own methods to the overall DBIC
B<NOTE:> Older versions of
L<Catalyst::Model::DBIC::Schema|Catalyst::Model::DBIC::Schema> use the
deprecated DBIx::Class C<load_classes> technique instead of the newer
-C<load_namspaces>. For new applications, please try to use
+C<load_namespaces>. For new applications, please try to use
C<load_namespaces> since it more easily supports a very useful DBIC
technique called "ResultSet Classes." If you need to convert an
existing application from "load_classes" to "load_namespaces," you can
| MyApp::Model::DB::Author | class |
| MyApp::Model::DB::Book | class |
| MyApp::Model::DB::BookAuthor | class |
- | MyApp::View::TT | instance |
+ | MyApp::View::HTML | instance |
'-----------------------------------------------------------------+----------'
[debug] Loaded Private actions:
edit many individual files.
-=head2 Configure TT.pm For The Wrapper
+=head2 Configure HTML.pm For The Wrapper
In order to create a wrapper, you must first edit your TT view and
tell it where to find your wrapper file.
-Edit you TT view in C<lib/MyApp/View/TT.pm> and change it to match the
+Edit your TT view in C<lib/MyApp/View/HTML.pm> and change it to match the
following:
__PACKAGE__->config(
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/TT.pm>. If you are not using the "-r" option, you will
+C<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
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> relationships currently need to be manually inserted.
-To add a C<many_to_many> relationship, first edit
+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 add the following text below
the C<# You can replace this text...> comment:
# many_to_many():
# args:
- # 1) Name of relationship, DBIC will create accessor with this name
+ # 1) Name of relationship bridge, DBIC will create accessor with this name
# 2) Name of has_many() relationship this many_to_many() is shortcut for
# 3) Name of belongs_to() relationship in model class of has_many() above
# You must already have the has_many() defined to use a many_to_many().
a statement that evaluates to C<true>. This is customarily done with
C<1;> on a line by itself.
-The C<many_to_many> relationship is optional, but it makes it
+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" though the C<book_author> table as in
+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 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, 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
-define a C<many_to_many> relationship without also having the
+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
-C<many_to_many> relationship for C<Author> as follows (again, be careful
+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):
# many_to_many():
# args:
- # 1) Name of relationship, DBIC will create accessor with this name
+ # 1) Name of relationship bridge, DBIC will create accessor with this name
# 2) Name of has_many() relationship this many_to_many() is shortcut for
# 3) Name of belongs_to() relationship in model class of has_many() above
# You must already have the has_many() defined to use a many_to_many().
$c->stash(template => 'books/list.tt2');
Then delete the C<TEMPLATE_EXTENSION> line in
-C<lib/MyApp/View/TT.pm>.
+C<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.
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/>.
-Copyright 2006-2008, Kennedy Clark, under Creative Commons License
+Copyright 2006-2010, Kennedy Clark, under the
+Creative Commons Attribution Share-Alike License Version 3.0
(L<http://creativecommons.org/licenses/by-sa/3.0/us/>).
projects / catagits/Catalyst-Manual.git / blobdiff