L<Catalyst::Plugin::ConfigLoader|Catalyst::Plugin::ConfigLoader> and
L<Config::Any|Config::Any>). If you are using a versions of
Catalyst::Devel prior to 1.06, you can convert to the newer format by
-simply creating the C<myapp.yml> file manually and deleting
+simply creating the C<myapp.conf> file manually and deleting
C<myapp.yml>. The default contents of C<myapp.conf> should only
consist of one line: C<name MyApp>.
is used to pass information between components and provide access to
Catalyst and plugin functionality.
-B<Note:> Catalyst actions are regular Perl methods, but they make use
-of Nicholas Clark's C<attributes> module (that's the "C<: Local>" next
-to the C<sub list> in the code above) to provide additional
-information to the Catalyst dispatcher logic. Many newer Catalyst
-applications are switching to the use of "Literal" C<:Path> actions
-and C<Args> attribute in lieu of C<: Local> and C<: Private>. For
-example, C<sub any_method :Path :Args(0)> can be used instead of C<sub
-index :Private> (because no path was supplied to C<Path> it matches
-the "empty" URL in the namespace of that module... the same thing
-C<sub index> would do) or C<sub list :Path('list') :Args(0)> could be
-used instead of the C<sub list : Local> above (the C<list> argument to
-C<Path> would make it match on the URL C<list> under C<books>, the
-namespace of the current module). See "Action Types" in
-L<Catalyst::Manual::Intro|Catalyst::Manual::Intro> as well as Part 5
-of this tutorial (Authentication) for additional information. Another
-popular but more advanced feature is C<Chained> actions that allow a
-single URL to "chain together" multiple action method calls, each with
-an appropriate number of arguments (see
-L<Catalyst::DispatchType::Chained|Catalyst::DispatchType::Chained> for
-details).
+Catalyst actions are regular Perl methods, but they make use of
+attributes (the "C<: Local>" next to the "C<sub list>" in the code
+above) to provide additional information to the Catalyst dispatcher
+logic (note that the space between the colon and the attribute name is
+optional... you will see attributes written both ways). Most Catalyst
+Controllers use one of five action types:
+
+=over 4
+
+=item *
+
+B<:Private> -- Use C<:Private> for methods that you want to make into
+an action, but you do not want Catalyst to directly expose the action
+to your users. Catalyst will not map C<:Private> methods to a URI.
+Use them for various sorts of "special" methods (the C<begin>,
+C<auto>, etc. discussed below) or for methods you want to be able to
+C<forward> or C<detach> to. (If the method is a plain old "helper
+method" that you don't want to be an action at all, then just define
+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:
+C<begin>, C<end>, C<default>, C<index>, and C<auto>.
+
+=item *
+
+With C<begin>, C<end>, C<default>, C<index> private actions, only the
+most specific action of each type will be called. For example, if you
+define a C<begin> action in your controller it will I<override> a
+C<begin> action in your application/root controller -- I<only> the
+action in your controller will be called.
+
+=item *
+
+Unlike the other actions where only a single method is called for each
+request, I<every> auto action along the chain of namespaces will be
+called. Each C<auto> action will be called I<from the application/root
+controller down through the most specific class>.
+
+=back
+
+=item *
+
+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
+C<http://localhost:3000/books/list> but "C<:Path('/list')>" would match
+on C<http://localhost:3000/list>. You can use C<:Args()> to specify
+how many arguments an action should except. See
+L<Catalyst::Manual::Intro/Action_types> for more information and a few
+examples.
+
+=item *
+
+B<:Local> -- C<:Local> is merely a shorthand for
+"C<:Path('_name_of_method_')>". For example, these are equivalent:
+"C<sub create_book :Local {...}>" and
+"C<sub create_book :Path('create_book') {...}>".
+
+=item *
+
+B<:Global> -- C<:Global> is merely a shorthand for
+"C<:Path('/_name_of_method_')>". For example, these are equivalent:
+"C<sub create_book :Global {...}>" and
+"C<sub create_book :Path('/create_book') {...}>".
+
+=item *
+
+B<:Chained> -- Newer Catalyst applications tend to use the Chained
+dispatch form of action types because of its power and flexibility.
+It allows a series of controller methods to automatically be dispatched
+to service a single user request. See
+L<Catalyst::Manual::Tutorial::BasicCRUD|Catalyst::Manual::Tutorial::BasicCRUD>
+and L<Catalyst::DispatchType::Chained|Catalyst::DispatchType::Chained>
+for more information on chained actions.
+
+=back
+
+You should refer to L<Catalyst::Manual::Intro/Action_types> for
+additional information and for coverage of some lesser-used action
+types not discussed here (C<Regex> and C<LocalRegex>).
=head1 CATALYST VIEWS
=back
-Both are similar, but C<TT> merely creates the C<lib/MyApp/View/TT.pm>
+Both helpers are similar. C<TT> creates the C<lib/MyApp/View/TT.pm>
file and leaves the creation of any hierarchical template organization
entirely up to you. (It also creates a C<t/view_TT.t> file for testing;
-test cases will be discussed in Part 8.) On the other hand, the
-C<TTSite> helper creates a modular and hierarchical view layout with
+test cases will be discussed in Part 8.) C<TTSite>, on the other hand,
+creates a modular and hierarchical view layout with
separate Template Toolkit (TT) files for common header and footer
information, configuration values, a CSS stylesheet, and more.
-While TTSite is useful to bootstrap a project, most in the Catalyst
-community recommend that it's easier to learn both Catalyst and
-Template Toolkit if you use the more basic TT approach. Consequently,
-this tutorial will use "plain old TT."
+While C<TTSite> was useful to bootstrap a project, its use is now
+deprecated and to be considered historical. For most Catalyst
+applications it adds redundant functionality and structure; many in the
+Catalyst community recommend that it's easier to learn both Catalyst and
+Template Toolkit if you use the more basic C<TT> approach.
+Consequently, this tutorial will use "plain old TT."
Enter the following command to enable the C<TT> style of view
rendering for this tutorial:
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>.
+C<root> to C<root/src>. These changes from the default are done mostly
+to facilitate the application we're developing in this tutorial; as with
+most things Perl, there's more than one way to do it...
=head2 Create a TT Template Page
".q" to exit from SQLite from the SQLite interactive mode and return to
your OS command prompt.
+For using other databases, such as PostgreSQL or MySQL, see
+L<Appendix 2|Catalyst::Manual::Tutorial::Appendices>.
=head1 DATABASE ACCESS WITH C<DBIx::Class>
projects / catagits/Catalyst-Manual.git / blobdiff