use strict;
use warnings;
+our $VERSION = '0.75_01';
+$VERSION = eval $VERSION;
+our $AUTHORITY = 'cpan:STEVAN';
+
use List::MoreUtils qw( all );
+my @Classes = qw( constructor_class destructor_class error_class );
+
sub apply_metaclass_roles {
my %options = @_;
my $for = $options{for_class};
- my $meta = _make_new_metaclass( $for, \%options );
+ my %old_classes = map { $_ => Class::MOP::class_of($for)->$_ }
+ grep { Class::MOP::class_of($for)->can($_) }
+ @Classes;
- for my $tor_class ( grep { $options{ $_ . '_roles' } }
- qw( constructor_class destructor_class ) ) {
+ my $meta = _make_new_metaclass( $for, \%options );
- my $class = _make_new_class(
- $meta->$tor_class(),
- $options{ $tor_class . '_roles' }
- );
+ for my $c ( grep { $meta->can($_) } @Classes ) {
+ if ( $options{ $c . '_roles' } ) {
+ my $class = _make_new_class(
+ $meta->$c(),
+ $options{ $c . '_roles' }
+ );
- $meta->$tor_class($class);
+ $meta->$c($class);
+ }
+ else {
+ $meta->$c( $old_classes{$c} );
+ }
}
return $meta;
my $for = shift;
my $options = shift;
- return $for->meta()
+ return Class::MOP::class_of($for)
unless grep { exists $options->{ $_ . '_roles' } }
qw(
metaclass
attribute_metaclass
method_metaclass
+ wrapped_method_metaclass
instance_metaclass
);
+ my $old_meta = Class::MOP::class_of($for);
my $new_metaclass
- = _make_new_class( ref $for->meta(), $options->{metaclass_roles} );
-
- my $old_meta = $for->meta();
+ = _make_new_class( ref $old_meta, $options->{metaclass_roles} );
# This could get called for a Moose::Meta::Role as well as a Moose::Meta::Class
my %classes = map {
qw(
attribute_metaclass
method_metaclass
+ wrapped_method_metaclass
instance_metaclass
);
my $for = $options{for_class};
- my $meta = $for->meta();
+ my $meta = Class::MOP::class_of($for);
my $new_base = _make_new_class(
$for,
return $existing_class unless $roles;
- my $meta = $existing_class->meta();
+ my $meta = Class::MOP::Class->initialize($existing_class);
return $existing_class
if $meta->can('does_role') && all { $meta->does_role($_) } @{$roles};
use Moose ();
use Moose::Exporter;
- use Moose::Util::Meta::Role;
+ use Moose::Util::MetaRole;
use MyApp::Role::Meta::Class;
use MyApp::Role::Meta::Method::Constructor;
This utility module is designed to help authors of Moose extensions
write extensions that are able to cooperate with other Moose
extensions. To do this, you must write your extensions as roles, which
-can then be dynamically applyied to the caller's metaclasses.
+can then be dynamically applied to the caller's metaclasses.
This module makes sure to preserve any existing superclasses and roles
already set for the meta objects, which means that any number of
=item * method_metaclass_roles => \@roles
+=item * wrapped_method_metaclass_roles => \@roles
+
=item * instance_metaclass_roles => \@roles
=item * constructor_class_roles => \@roles
=head1 COPYRIGHT AND LICENSE
-Copyright 2008 by Infinity Interactive, Inc.
+Copyright 2009 by Infinity Interactive, Inc.
L<http://www.iinteractive.com>