use List::MoreUtils qw( any all uniq first_index );
use Scalar::Util 'weaken', 'blessed';
-our $VERSION = '0.89_01';
+our $VERSION = '0.99';
$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
my $cache_ok = delete $options{cache};
- # something like Super::Class|Super::Class::2=Role|Role::1
- my $cache_key = join '=' => (
- join('|', @{$options{superclasses} || []}),
- join('|', sort @{$options{roles} || []}),
- );
+ my $cache_key
+ = _anon_cache_key( $options{superclasses}, $options{roles} );
if ($cache_ok && defined $ANON_CLASSES{$cache_key}) {
return $ANON_CLASSES{$cache_key};
return $new_class;
}
-sub add_role {
- my ($self, $role) = @_;
- (blessed($role) && $role->isa('Moose::Meta::Role'))
- || $self->throw_error("Roles must be instances of Moose::Meta::Role", data => $role);
- push @{$self->roles} => $role;
+sub _anon_cache_key {
+ # Makes something like Super::Class|Super::Class::2=Role|Role::1
+ return join '=' => (
+ join( '|', @{ $_[0] || [] } ),
+ join( '|', sort @{ $_[1] || [] } ),
+ );
}
-sub make_immutable {
+sub reinitialize {
my $self = shift;
+ my $pkg = shift;
+
+ my $meta = blessed $pkg ? $pkg : Class::MOP::class_of($pkg);
+
+ my $cache_key;
+
+ my %existing_classes;
+ if ($meta) {
+ %existing_classes = map { $_ => $meta->$_() } qw(
+ attribute_metaclass
+ method_metaclass
+ wrapped_method_metaclass
+ instance_metaclass
+ constructor_class
+ destructor_class
+ error_class
+ );
- # we do this for metaclasses way too often to do this check for them
- if (!$self->name->isa('Class::MOP::Object')) {
- my @superclasses = grep { $_ ne 'Moose::Object' && $_ ne $self->name }
- $self->linearized_isa;
- for my $superclass (@superclasses) {
- my $meta = Class::MOP::class_of($superclass);
- next unless $meta && $meta->isa('Moose::Meta::Class');
- next unless $meta->is_mutable;
- Carp::cluck("Calling make_immutable on "
- . $self->name
- . ", which has a mutable ancestor ($superclass)");
- last;
- }
+ $cache_key = _anon_cache_key(
+ [ $meta->superclasses ],
+ [ map { $_->name } @{ $meta->roles } ],
+ ) if $meta->is_anon_class;
}
- $self->SUPER::make_immutable(@_);
+
+ my $new_meta = $self->SUPER::reinitialize(
+ $pkg,
+ %existing_classes,
+ @_,
+ );
+
+ return $new_meta unless defined $cache_key;
+
+ my $new_cache_key = _anon_cache_key(
+ [ $meta->superclasses ],
+ [ map { $_->name } @{ $meta->roles } ],
+ );
+
+ delete $ANON_CLASSES{$cache_key};
+ $ANON_CLASSES{$new_cache_key} = $new_meta;
+
+ return $new_meta;
+}
+
+sub add_role {
+ my ($self, $role) = @_;
+ (blessed($role) && $role->isa('Moose::Meta::Role'))
+ || $self->throw_error("Roles must be instances of Moose::Meta::Role", data => $role);
+ push @{$self->roles} => $role;
}
sub role_applications {
sub _fix_metaclass_incompatibility {
my ($self, @superclasses) = @_;
- foreach my $super (@superclasses) {
- my $meta = Class::MOP::Class->initialize($super);
-
- my @all_supers = $meta->linearized_isa;
- shift @all_supers;
-
- my @super_metas_to_fix = ($meta);
-
- # We need to check & fix the immediate superclass. If its @ISA
- # contains a class without a metaclass instance, followed by a
- # class _with_ a metaclass instance, init a metaclass instance
- # for classes without one and fix compat up to and including
- # the class which was already initialized.
- my $idx = first_index { Class::MOP::class_of($_) } @all_supers;
-
- push @super_metas_to_fix,
- map { Class::MOP::Class->initialize($_) } @all_supers[ 0 .. $idx ]
- if $idx >= 0;
-
- foreach my $super_meta (@super_metas_to_fix) {
- $self->_fix_one_incompatible_metaclass($super_meta);
- }
- }
+ $self->_fix_one_incompatible_metaclass($_)
+ for map { Moose::Meta::Class->initialize($_) } @superclasses;
}
sub _fix_one_incompatible_metaclass {
my $super_meta_name
= $super_meta->is_immutable
- ? $super_meta->get_mutable_metaclass_name
+ ? $super_meta->_get_mutable_metaclass_name
: ref($super_meta);
return 1
my $super_meta_name
= $super_meta->is_immutable
- ? $super_meta->get_mutable_metaclass_name
+ ? $super_meta->_get_mutable_metaclass_name
: ref($super_meta);
my $self_metaclass = ref $self;
=item B<< Moose::Meta::Class->create($package_name, %options) >>
This overrides the parent's method in order to accept a C<roles>
-option. This should be an array reference containing one more roles
-that the class does, each optionally followed by a hashref of options.
+option. This should be an array reference containing roles
+that the class does, each optionally followed by a hashref of options
+(C<-excludes> and C<-alias>).
my $metaclass = Moose::Meta::Class->create( 'New::Class', roles => [...] );
actually apply any role to the class; it is only for tracking role
applications.
-=item B<< $metaclass->does_role($role_name) >>
+=item B<< $metaclass->does_role($role) >>
-This returns a boolean indicating whether or not the class does the
-specified role. This tests both the class and its parents.
+This returns a boolean indicating whether or not the class does the specified
+role. The role provided can be either a role name or a L<Moose::Meta::Role>
+object. This tests both the class and its parents.
=item B<< $metaclass->excludes_role($role_name) >>
=head1 BUGS
-All complex software has bugs lurking in it, and this module is no
-exception. If you find a bug please either email me, or add the bug
-to cpan-RT.
+See L<Moose/BUGS> for details on reporting bugs.
=head1 AUTHOR
=head1 COPYRIGHT AND LICENSE
-Copyright 2006-2009 by Infinity Interactive, Inc.
+Copyright 2006-2010 by Infinity Interactive, Inc.
L<http://www.iinteractive.com>
projects / gitmo/Moose.git / blobdiff