=head1 Upgrading to Catalyst 5.80
-Work in progress
+Most applications and plugins should run unaltered on Catalyst 5.80.
+
+However as a lot of refactoring work has taken place, several changes have
+been made which could cause incompatibilities, if your application or plugin
+is using deprecated code, or relying on side-effects then there could be
+incompatibility.
+
+Most issues found with pre-existing components have been easy to solve, and a
+complete description of behavior changes which may cause compatibility issues,
+or warnings to be emitted is included below to help if you have problems.
+
+If you think you have found an upgrade related issue which is not covered in
+this document, then please email the Catalyst list to discuss the problem.
=head1 Known backwards compatibility breakages.
-=head2 Catalyst::Plugin::Authentication
+=head2 Components which inherit from Moose::Object before Catalyst::Component
-You need at least version FIXME of Catalyst::Plugin::Authentication.
+Moose components which say:
-=head2 Moose applications
+ package TestApp::Controller::Example;
+ use Moose;
+ extends qw/Moose::Object Catalyst::Component/;
-Applications made by early adopters, which say:
+to use the constructor provided by Moose, whilst working if you do some hacks
+with the C< BUILDARGS > method, will not work with Catalyst 5.80 as
+C<Catalyst::Component> inherits from C<Moose::Object>, and so C< @ISA > fails
+to linearise.
- extends qw/Moose::Object Catalyst::Component/
+The fix for this, is to not inherit directly from C<Moose::Object>
+yourself. Having components which do not inherit their constructor from
+C<Catalyst::Component> is B<unsupported>, and has never been recommended,
+therefore you're on your own if you're using this technique. You'll need
+to detect the version of Catalyst your application is running with and deal
+with it appropriately.
-need the C<Moose::Object> removing to run with Catalyst 5.80, otherwise
-your Class' @ISA will not linearise with C3.
+You will also see this issue if you do the following:
-rafl to fix this bit :)
+ package TestApp::Controller::Example;
+ use Moose;
+ use base 'Catalyst::Controller';
-=head2 Components without new methods
+as C< use base > appends to @ISA.
-FIXME
+The correct way to use Moose in a component in a both forward and backwards
+compatible way is:
-=head2 Components without COMPONENT methods
+ package TestApp::Controller::Root;
+ use Moose;
+ BEGIN { extends 'Catalyst::Component' }; # Or ::Controller, or whatever
-FIXME
+Note that the C< extends > decleration needs to occur in a begin block for
+L<attributes> to operate correctly.
-=head2 __PACKAGE__->mk_accessor('meta');
+=head3 use Moose in MyApp
-Won't work due to a limitation of L<MooseX::Emulate::Class::Accessor::Fast>
+Similar to the above, this will also fail:
-FIXME
+ package MyApp;
+ use Moose;
+ use Catalyst qw/
+ ConfigLoader
+ /;
+ __PACKAGE__->setup;
-=head2 Class::Data::Inheritable side effects
+If you need to use Moose in your application class (e.g. for method modifiers
+etc) then the correct technique is:
-FIXME
+ package MyApp;
+ use Moose;
+ extends 'Catalyst';
+ __PACKAGE__->setup(qw/
+ ConfigLoader
+ /);
-=head2 Extending Catalyst::Request or other classes in an ad-hoc manor using mk_accessor
+=head2 Anonymous closures installed directly into the symbol table
-FIXME
+If you have any code which installs anonymous subroutine references directly
+into the symbol table, you may encounter breakages. The simplest solution is
+to use L<Sub::Name> to name the subroutine. Example:
-=head2 require $class was successful but the package is not defined.
+ # Original code, likely to break:
+ my $full_method_name = join('::',$package_name, $method_name);
+ *$full_method_name = sub { ... };
-FIXME Warning
+ # Fixed Code
+ use Sub::Name 'subname';
+ my $full_method_name = join('::',$package_name, $method_name);
+ *$full_method_name = subname $full_method_name, sub { ... };
-=head2 $c->plugin method
+Additionally, you can take advantage of Catalysts use of L<Class::MOP> and
+install the closure using the appropriate metaclass. Example:
+
+ use Class::MOP;
+ my $metaclass = Moose::Meta::Class->initialize($package_name);
+ $metaclass->add_method($method_name => sub { ... });
+
+=head2 Hooking into application setup
+
+To execute code during application startup the following snippet in MyApp.pm
+used to work:
+
+ sub setup {
+ my ($class, @args) = @_;
+ $class->NEXT::setup(@args);
+ ... # things to do after the actual setup
+ }
+
+With Catalyst 5.80 this won't work anymore. Because instead of using NEXT.pm it
+relies on L<Class::C3::Adopt::NEXT>, which uses plain C3 method resolution.
+
+As L<NEXTs|NEXT> hacks to remember what methods have already been called, this
+causes infinite recursion between MyApp::setup and Catalyst::setup.
+
+Moose method modifiers like C<< before|after|around 'setup => sub { ... }; >>
+also will not operate correctly due to backward compatibility issues with the
+way plugin setup methods.
+
+The right way to do it is this:
-Deprecated
+ after setup_finalize => sub {
+ ... # things to do after the actual setup
+ };
-=head2 Components which inherit Catalyst::Component's COMPONENT method, who's new method does not return a true value.
+=head2 Components with a new method which returns false
-Previously if your new method returned a false value, then your class' configuration would be blessed into a hash on your behalf,
-and this would be returned from the COMPONENT method. This is no longer supported. You are not recommended to implement your own new method
-in components, instead, you should inherit the new method from Catalyst::Component, and use Moose's BUILD functionality
+Previously, if you had a component which inherited from Catalyst::COMPONENT,
+but overrode the new method to return false, then your class' configuration
+would be blessed into a hash on your behalf, and this would be returned from
+the COMPONENT method.
+
+This behaviour makes no sense, and so has been removed. Implementing your own
+new method in components is B<highly> discouraged, instead, you should inherit
+the new method from Catalyst::Component, and use Moose's BUILD functionality
to perform any construction work necessary for your sub-class.
+=head2 __PACKAGE__->mk_accessor('meta');
-=head Methods in Catalyst::Dispatcher
+Won't work due to a limitation of L<Moose>. This is currently being fixed
+inside Moose.
- Class $class is calling the deprecated method Catalyst::Dispatcher::$public_method_name,\n"
- . "this will be removed in Catalyst 5.9X"
+=head2 Class::Data::Inheritable side effects
+
+Previously, writing to a class data accessor would copy the accessor method
+down into your package.
+
+This behavior has been removed. Whilst the class data is still stored
+per-class, it is stored on the metaclass of the class defining the accessor.
+
+Therefore anything relying on the side-effect of the accessor being copied down
+will be broken.
+
+The following example demonstrates the problem:
+
+ {
+ package BaseClass;
+ use base qw/Class::Data::Inheritable/;
+ __PACKAGE__->mk_classdata('foo');
+ }
+
+ {
+ package Child;
+ use base qw/BaseClass/;
+ }
+
+ BaseClass->foo('base class');
+ Child->foo('sub class');
+
+ use Test::More;
+ isnt(BaseClass->can('foo'), Child->can('foo'));
+
+=head2 Extending Catalyst::Request or other classes in an ad-hoc manor using mk_accessors
-FIXME
+Previously, it was possible to add additional accessors to Catalyst::Request
+(or other classes) by calling the mk_accessors class method.
-=head2 Confused multiple inheritence with Catalyst::Component::COMPONENT
+This is no longer supported - users should make a sub-class of the class whos
+behavior they would like to change, rather than globally polluting the
+Catalyst objects.
+
+=head2 Confused multiple inheritance with Catalyst::Component::COMPONENT
Warning message:
- There is a COMPONENT method resolving after Catalyst::Component
+ There is a COMPONENT method resolving after Catalyst::Component
in ${next_package}.
-
-This means that one of the packages on the right hand side of
-Catalyst::Component in your Class' inheritance hierarchy defines
-a COMPONENT method.
-Previously, Catalyst's COMPONENT method would delegate to the
-method on the right hand side, which could then delegate back again
-with NEXT. This (as it is insane), is no longer supported, as it
-makes no sense with C3 method dispatch order.
+This means that one of the packages on the right hand side of
+Catalyst::Component in your Class' inheritance hierarchy defines a COMPONENT
+method.
+
+Previously, Catalyst's COMPONENT method would delegate to the method on the
+right hand side, which could then delegate back again with NEXT. This (as it
+is insane), is no longer supported, as it makes no sense with C3 method
+dispatch order.
+
+Therefore the correct fix is to re-arrange your class' inheritance hierarchy
+so that the COMPONENT method you would like to inherit is the first COMPONENT
+method in your @ISA.
+
+=head1 WARNINGS
+
+=head2 Methods in Catalyst::Dispatcher
+
+The following methods in Catalyst::Dispatcher are likely to change
+significantly in the 5.8X release series, and therefore their use is highly
+deprecated.
+
+=over
+
+=item tree
+
+=item dispatch_types
+
+=item registered_dispatch_types
+
+=item method_action_class
+
+=item action_hash
+
+=item container_hash
+
+=back
+
+The first time one of these methods is called, a warning will be emitted:
+
+ Class $class is calling the deprecated method Catalyst::Dispatcher::$public_method_name,\n"
+ . "this will be removed in Catalyst 5.9X"
+
+You should B<NEVER> be calling any of these methods from application code.
+
+Plugins authors and maintainers whos plugins need to call these methods should
+email the development list to discuss your use-case, and what a better API
+should look like.
+
+=head2 require $class was successful but the package is not defined.
+
+In this version of Catalyst, if a component is loaded from disk, but no
+symbols are defined in that component's namespace after it is loaded, this
+warning will be issued.
+
+This is to protect against confusing bugs caused by mis-typing package names.
+
+This will become a fatal error in a future version.
+
+=head2 $c->plugin method
-Therefore the correct fix is to re-arrange your class' inheritance
-hierarchy so that the COMPONENT method you would like to inherit is
-the first COMPONENT method in your @ISA.
+Calling the plugin method is deprecated, and calling it at runtime is B<highly
+deprecated>.
+Instead you are recommended to use L< Catalyst::Model::Adaptor > or similar to
+compose the functionality you need outside of the main application namespace.
=cut
projects / catagits/Catalyst-Runtime.git / blobdiff