use strict;
use warnings;
-use Scalar::Util;
use Devel::GlobalDestruction qw(in_global_destruction);
+use MRO::Compat;
+use Scalar::Util;
+use Try::Tiny;
use if ( not our $__mx_is_compiled ), 'Moose::Meta::Class';
use if ( not our $__mx_is_compiled ), metaclass => 'Moose::Meta::Class';
-our $VERSION = '0.77';
+our $VERSION = '0.90';
$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
sub new {
my $class = shift;
+ Carp::cluck 'Calling new() on an instance is deprecated,'
+ . ' please use (blessed $obj)->new' if blessed $class;
+
my $params = $class->BUILDARGS(@_);
- # We want to support passing $self->new, but initialize
- # takes only an unblessed class name
my $real_class = Scalar::Util::blessed($class) || $class;
my $self = Class::MOP::Class->initialize($real_class)->new_object($params);
# extra meta level calls
return unless $self->can('DEMOLISH');
- # This is a hack, because Moose::Meta::Class may not be the right
- # metaclass, but class_of may return undef during global
- # destruction, if the metaclass object has already been cleaned
- # up.
- my $meta = Class::MOP::class_of($self)
- || Moose::Meta::Class->initialize( ref $self );
-
- foreach my $method ( $meta->find_all_methods_by_name('DEMOLISH') ) {
- $meta->throw_error(
- "Couldn't call DEMOLISH on package $method->{class} because"
- . " global destruction destroyed it first. Make sure all of"
- . " your instances of $method->{class} are destroyed before"
- . " global destruction to fix this."
- ) if !$method->{code} && $in_global_destruction;
- $method->{code}->execute($self, $in_global_destruction);
+ my @isa;
+ if ( my $meta = Class::MOP::class_of($self ) ) {
+ @isa = $meta->linearized_isa;
+ } else {
+ # We cannot count on being able to retrieve a previously made
+ # metaclass, _or_ being able to make a new one during global
+ # destruction. However, we should still be able to use mro at
+ # that time (at least tests suggest so ;)
+ my $class_name = ref $self;
+ @isa = @{ mro::get_linear_isa($class_name) }
+ }
+
+ foreach my $class (@isa) {
+ no strict 'refs';
+ my $demolish = *{"${class}::DEMOLISH"}{CODE};
+ $self->$demolish($in_global_destruction)
+ if defined $demolish;
}
}
sub DESTROY {
- # if we have an exception here ...
- if ($@) {
- # localize the $@ ...
- local $@;
- # run DEMOLISHALL ourselves, ...
- $_[0]->DEMOLISHALL(in_global_destruction);
- # and return ...
- return;
+ my $self = shift;
+
+ local $?;
+
+ try {
+ $self->DEMOLISHALL(in_global_destruction);
}
- # otherwise it is normal destruction
- $_[0]->DEMOLISHALL(in_global_destruction);
+ catch {
+ # Without this, Perl will warn "\t(in cleanup)$@" because of some
+ # bizarre fucked-up logic deep in the internals.
+ no warnings 'misc';
+ die $_;
+ };
+
+ return;
}
# support for UNIVERSAL::DOES ...