++ed by:

141 PAUSE users
96 non-PAUSE users.

Dave Rolsky
and 1 contributors

Changes for version 0.58

  • !! This release has an incompatible change regarding !! !! how roles add methods to a class !!
  • Roles and role application ! Roles now add methods by calling add_method, not alias_method. They make sure to always provide a method object, which will be cloned internally. This means that it is now possible to track the source of a method provided by a role, and even follow its history through intermediate roles.
    • This means that methods added by a role now show up when looking at a class's method list/map. (Dave Rolsky)
  • Makefile.PL
    • From this release on, we'll try to maintain a list of conflicting modules, and warn you if you have one installed. For example, this release conflicts with ...
      • MooseX::Singleton <= 0.11
      • MooseX::Params::Validate <= 0.05
      • Fey::ORM <= 0.10
      • In general, we try to not break backwards compatibility for most Moose users, but MooseX modules and other code which extends Moose's metaclasses is often affected by very small changes in the Moose internals.
  • Moose::Meta::Method::Delegation
  • Moose::Meta::Attribute
    • Delegation methods now have their own method class. (Dave Rolsky)
  • Moose::Meta::TypeConstraint::Parameterizable
    • Added a new method 'parameterize' which is basically a factory for the containing constraint. This makes it easier to create new types of parameterized constraints. (jnapiorkowski)
  • Moose::Meta::TypeConstraint::Union
    • Changed the way Union types canonicalize their names to follow the normalized TC naming rules, which means we strip all whitespace. (jnapiorkowski)
  • Moose::Util::TypeConstraints
    • Parameter and Union args are now sorted, this makes Int|Str the same constraint as Str|Int. (jnapiorkowski)
    • Changes to the way Union types are parsed to more correctly stringify their names. (jnapiorkowski)
    • When creating a parameterized type, we now use the new parameterize method. (jnapiorkowski)
    • Incoming type constraint strings are now normalized to remove all whitespace differences. (jnapiorkowski)
    • Changed the way we parse type constraint strings so that we now match TC[Int,Int,...] and TC[name=>Str] as parameterized type constraints. This lays the foundation for more flexible type constraint implementations.
  • Tests and docs for all the above. (jnapiorkowski)
  • Moose::Exporter
  • Moose
    • Moose::Exporter will no longer remove a subroutine that the exporting package re-exports. Moose re-exports the Carp::confess function, among others. The reasoning is that we cannot know whether you have also explicitly imported those functions for your own use, so we err on the safe side and always keep them. (Dave Rolsky)
      • added tests for this (rafl)
  • Moose::Meta::Class
    • Changes to how we fix metaclass compatibility that are much too complicated to go into. The summary is that Moose is much less likely to complain about metaclass incompatibility now. In particular, if two metaclasses differ because Moose::Util::MetaRole was used on the two corresponding classes, then the difference in roles is reconciled for the subclass's metaclass. (Dave Rolsky)
    • Squashed an warning in _process_attribute (thepler)
  • Moose::Meta::Role
    • throw exceptions (sooner) for invalid attribute names (thepler)
      • added tests for this (thepler)
  • Moose::Util::MetaRole
    • If you explicitly set a constructor or destructor class for a metaclass object, and then applied roles to the metaclass, that explicitly set class would be lost and replaced with the default.
  • Moose::Meta::Class
  • Moose::Meta::Attribute
  • Moose::Meta::Method
  • Moose
  • Moose::Object
  • Moose::Error::Default
  • Moose::Error::Croak
  • Moose::Error::Confess
    • All instances of confess() changed to use overridable C<throw_error> method. This method ultimately calls a class constructor, and you can change the class being called. In addition, errors now pass more information than just a string. The default C<error_class> behaves like C<Carp::confess>, so the behavior is not visibly different for end users.