=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
result.
This tells Catalyst to start using one additional plugin,
-L<Catalyst::Plugin::StackTrace|Catalyst::Plugin::StackTrace>, to add a
+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<StackTrace|Catalyst::Plugin::StackTrace> output appears in your
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
"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 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;
+
+This changes the base directory for your template files from
+C<root> to C<root/src>.
-B<NOTE:> Make sure to add a comma after '.tt2' outside the single
-quote.
+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...
-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
+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:
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<http://search.cpan.org/perldoc?Template::Manual::Variables> for
+L<https://metacpan.org/module/Template::Manual::Variables> for
details and examples). In addition to the usual L<Template> module Pod
documentation, you can access the TT manual at
-L<http://search.cpan.org/perldoc?Template::Manual>.
+L<https://metacpan.org/module/Template::Manual>.
B<TIP:> While you can build all sorts of complex logic into your TT
templates, you should in general keep the "code" part of your
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
=head2 Make Sure You Have a Recent Version of the DBIx::Class Model
First, let's be sure we have a recent version of the DBIC helper,
-L<Catalyst::Model::DBIC::Schema|Catalyst::Model::DBIC::Schema>, so
+L<Catalyst::Model::DBIC::Schema>, so
that we can take advantage of some recent enhancements in how
foreign keys are handled with SQLite. To check your version,
run this command:
less than v0.39, you will need to run this command to install it
directly from CPAN:
- $ sudo cpan Catalyst::Model::DBIC::Schema
+ $ cpan -i Catalyst::Model::DBIC::Schema
And re-run the version print command to verify that you are now at
0.39 or higher.
Upgrade if you are not at version C<1.27> or higher.
+Also, remember to put a line requiring the version of the module
+you just installed into your Makefile.PL
=head2 Create Static DBIx::Class Schema Files
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/HTML.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(
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().
Kennedy Clark, C<hkclark@gmail.com>
-Please report any errors, issues or suggestions to the author. The
-most recent version of the Catalyst Tutorial can be found at
+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/>.
-Copyright 2006-2010, 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