this feature of Catalyst during the authentication and authorization
sections (Part 5 and Part 6).
-B<IMPORTANT NOTE:> If you are using a version of
-L<Catalyst::Devel|Catalyst::Devel> prior to version 1.06, you need to
-be aware that Catalyst changed from a default format of YAML to the
-more straightforward C<Config::General> format. This tutorial use the
-newer C<myapp.conf> configuration file for C<Config::General> instead
-of C<myapp.yml> for YAML. However, Catalyst has long supported both
-formats and Catalyst will automatically use either C<myapp.conf> or
-C<myapp.yml> (or any other format supported by
-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.conf> file manually and deleting
-C<myapp.yml>. The default contents of C<myapp.conf> should only
-consist of one line: C<name MyApp>.
+B<IMPORTANT NOTE:> If you are using a version of
+L<Catalyst::Devel|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
+L<Catalyst::Plugin::ConfigLoader|Catalyst::Plugin::ConfigLoader> and
+L<Config::Any|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
+should only consist of one line:
+
+ name MyApp
B<TIP>: This script can be useful for converting between configuration
formats:
perl -Ilib -e 'use MyApp; use Config::General;
Config::General->new->save_file("myapp.conf", MyApp->config);'
-B<NOTE:> The default C<myapp.conf> should look like:
-
- name MyApp
-
=item *
L<Catalyst::Plugin::Static::Simple|Catalyst::Plugin::Static::Simple>
is used to pass information between components and provide access to
Catalyst and plugin functionality.
-Catalyst actions are regular Perl methods, but they make use
-of attributes (the "C<: Local>" next to the "C<sub list>" in the code
+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 them written both ways). Over time, the
-recommended style for most Catalyst applications has changed:
-
-=over 4
-
-=item * From "C<:Local>" and "C<:Private>"
-
-=item * To "C<:Path>" and "C<:Args>"
-
-=item * To "C<:Chained>"
-
-=back
-
-Although all three styles work just fine, the newer forms offer more
-advanced capbilities and allow you to be more expressive with the URIs
-that your application uses.
-
-Here is a quick summary of the most commonly used action types:
-C<Local>, C<Private>, C<Path> and C<Chained>:
+optional... you will see attributes written both ways). Most Catalyst
+Controllers use one of five action types:
=over 4
=item *
-B<Local and Private> -- In the past, the majority of applications have
-traditionally used C<Local> actions for items that respond to user
-requests and C<Private> actions for those that do not directly respond
-to user input.
+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.)
-=over 4
+There are five types of "special" build-in C<:Private> actions:
+C<begin>, C<end>, C<default>, C<index>, and C<auto>.
-There are five types of build-in C<Private> actions: C<begin>,
-C<end>, C<default>, C<index>, and C<auto>.
+=over 4
=item *
=item *
-B<Path> -- C<Path> actions were the next style of action types to
-become popular and essentially provide a limited subset of what can be
-found done with Chained actions. You can match on different portions
-of the URI (for example C<Path('list')> in
+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>) and it let's you be very specific with
-what arguments each controller method will accept. See
-L<Catalyst::Manual::Intro/Action_types> for more information and a few
+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<Chained> -- Newer Catalyst applications tend to use the Chained
+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
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>, C<LocalRegex> and C<Global>).
+types not discussed here (C<Regex> and C<LocalRegex>).
=head1 CATALYST VIEWS
created "/home/me/MyApp/script/../t/model_DB.t"
+The C<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
-C<lib/MyApp/Model>. C<DBIC::Schema> is the type of the model to
-create. C<MyApp::Schema> is the name of the DBIC schema file written
-to C<lib/MyApp/Schema.pm>. Because we specified C<create=dynamic> to
-the helper, it use
+C<lib/MyApp/Model>.
+
+=item *
+
+C<DBIC::Schema> is the type of the model to create.
+
+=item *
+
+C<MyApp::Schema> is the name of the DBIC schema file written to
+C<lib/MyApp/Schema.pm>.
+
+=item *
+
+Because we specified C<create=dynamic> to the helper, it use
L<DBIx::Class::Schema::Loader|DBIx::Class::Schema::Loader> to
dynamically load the schema information from the database every time
-the application starts. DBIC uses the schema to load other classes
-that represent the tables in your database (DBIC refers to these
-"table objects" as "result sources," see
-L<DBIx::Class::ResultSource|DBIx::Class::ResultSource>). And finally,
-C<dbi:SQLite:myapp.db> is the standard DBI connect string for use with
-SQLite.
+the application starts.
+
+=item *
+
+And finally, C<dbi:SQLite:myapp.db> is the standard DBI connect string
+for use with SQLite.
+
+=back
B<NOTE:> Although the C<create=dynamic> option to the DBIC helper
makes for a nifty demonstration, is only really suitable for very
$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
+B<TIP>: You may see the C<$c-E<gt>model('DB::Books')> un-commented
+above written as C<$c-E<gt>model('DB')-E<gt>resultset('Books')>. The
two are equivalent. Either way, C<$c-E<gt>model> returns a
L<DBIx::Class::ResultSet|DBIx::Class::ResultSet> which handles queries
against the database and iterating over the set of results that are
=head2 Test Run The Application
-First, let's enable an environment variable option that causes
-DBIx::Class to dump the SQL statements it's using to access the database
-(this option can provide extremely helpful troubleshooting information):
+First, let's enable an environment variable that causes DBIx::Class to
+dump the SQL statements usedß to access the database. This is a
+helpful trick when you are trying to debug your database-oriented
+code:
$ export DBIC_TRACE=1
automatically created information at the top of 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 to C<load_classes> in C<Schema.pm> will load each of the
-table-specific "results source" files from the C<lib/MyApp/Schema>
-subdirectory. These three table-specific DBIC schema files will then be
-used to 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).
+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 to C<load_classes> in C<Schema.pm> will load each of the "result
+class" files from the C<lib/MyApp/Schema> subdirectory. The end
+result 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).
+
+B<NOTE:> The version of
+L<Catalyst::Model::DBIC::Schema|Catalyst::Model::DBIC::Schema> in
+Ubuntu 8.10 uses the older DBIC C<load_classes> vs. the newer
+C<load_namspaces> technique. For new applications, please try to use
+C<load_namespaces> since it more easily supports a very useful DBIC
+technique called "ResultSet Classes." This tutorial expects to migrate to
+C<load_namespaces> when the next release of Ubuntu comes out.
+
+If you wish to try C<load_namespaces> now, you can manually do the
+equivalent of the C<create=static> operation outside of the Catalyst
+helper:
+
+ perl -MDBIx::Class::Schema::Loader=make_schema_at,dump_to_dir:./lib -e \
+ 'make_schema_at("MyApp::Schema", { debug => 1, use_namespaces => 1, \
+ components => ["InflateColumn::DateTime"] },["dbi:SQLite:myapp.db", "", "" ])'
+
+And then use the helper to only create the Catalyst model class:
+
+ script/myapp_create.pl model DB DBIC::Schema MyApp::Schema dbi:SQLite:myapp.db
+
+B<However>, it is important to note that C<load_namespaces> will look
+for your C<Books.pm>, <Authors.pm>, etc. files in
+C<lib/MyApp/Schema/Result> (it adds the subdirection "Result" so that
+there can also be a "ResultSet" directory next to it in the
+hierarchy). Therefore, if you switch to C<load_namespaces>, you will
+need to modify the path to these "result class" files throughout the
+rest of the tutorial. Our recommendation for now would be to complete
+the tutorial using C<load_classes> and the try converting to
+C<load_namespaces> after you are done.
=head2 Updating the Generated DBIC Schema Files
# args:
# 1) Name of relationship, DBIC will create accessor with this name
# 2) Name of the model class referenced by this relationship
- # 3) Column name in *foreign* table
+ # 3) Column name in *foreign* table (aka, foreign key in peer table)
__PACKAGE__->has_many(book_authors => 'MyApp::Schema::BookAuthors', 'book_id');
# many_to_many():
# args:
# 1) Name of relationship, DBIC will create accessor with this name
# 2) Name of the model class referenced by this relationship
- # 3) Column name in *foreign* table
+ # 3) Column name in *foreign* table (aka, foreign key in peer table)
__PACKAGE__->has_many(book_author => 'MyApp::Schema::BookAuthors', 'author_id');
# many_to_many():
projects / catagits/Catalyst-Manual.git / blobdiff