Merge branch 'stable'

[gitmo/Class-MOP.git] / lib / Class / MOP / Method / Wrapped.pm

diff --git a/lib/Class/MOP/Method/Wrapped.pm b/lib/Class/MOP/Method/Wrapped.pm
index b7b1691..71a2a13 100644 (file)
--- a/lib/Class/MOP/Method/Wrapped.pm
+++ b/lib/Class/MOP/Method/Wrapped.pm
@@ -7,7 +7,7 @@ use warnings;
 use Carp         'confess';
 use Scalar::Util 'blessed';
 
-our $VERSION   = '0.86';
+our $VERSION   = '1.12';
 $VERSION = eval $VERSION;
 our $AUTHORITY = 'cpan:STEVAN';
 
@@ -28,7 +28,7 @@ my $_build_wrapped_method = sub {
     );
     if (@$before && @$after) {
         $modifier_table->{cache} = sub {
-            $_->(@_) for @{$before};
+            for my $c (@$before) { $c->(@_) };
             my @rval;
             ((defined wantarray) ?
                 ((wantarray) ?
@@ -37,14 +37,14 @@ my $_build_wrapped_method = sub {
                     ($rval[0] = $around->{cache}->(@_)))
                 :
                 $around->{cache}->(@_));
-            $_->(@_) for @{$after};
+            for my $c (@$after) { $c->(@_) };
             return unless defined wantarray;
             return wantarray ? @rval : $rval[0];
         }
     }
     elsif (@$before && !@$after) {
         $modifier_table->{cache} = sub {
-            $_->(@_) for @{$before};
+            for my $c (@$before) { $c->(@_) };
             return $around->{cache}->(@_);
         }
     }
@@ -58,7 +58,7 @@ my $_build_wrapped_method = sub {
                     ($rval[0] = $around->{cache}->(@_)))
                 :
                 $around->{cache}->(@_));
-            $_->(@_) for @{$after};
+            for my $c (@$after) { $c->(@_) };
             return unless defined wantarray;
             return wantarray ? @rval : $rval[0];
         }
@@ -70,10 +70,10 @@ my $_build_wrapped_method = sub {
 
 sub wrap {
     my ( $class, $code, %params ) = @_;
-    
+
     (blessed($code) && $code->isa('Class::MOP::Method'))
         || confess "Can only wrap blessed CODE";
-        
+
     my $modifier_table = {
         cache  => undef,
         orig   => $code,
@@ -85,15 +85,35 @@ sub wrap {
         },
     };
     $_build_wrapped_method->($modifier_table);
-    my $method = $class->SUPER::wrap(
+    return $class->SUPER::wrap(
         sub { $modifier_table->{cache}->(@_) },
-        # get these from the original 
+        # get these from the original
         # unless explicitly overriden
-        package_name => $params{package_name} || $code->package_name,
-        name         => $params{name}         || $code->name,
+        package_name   => $params{package_name} || $code->package_name,
+        name           => $params{name}         || $code->name,
+
+        modifier_table => $modifier_table,
     );
-    $method->{'modifier_table'} = $modifier_table;
-    $method;
+}
+
+sub _new {
+    my $class = shift;
+    return Class::MOP::Class->initialize($class)->new_object(@_)
+        if $class ne __PACKAGE__;
+
+    my $params = @_ == 1 ? $_[0] : {@_};
+
+    return bless {
+        # inherited from Class::MOP::Method
+        'body'                 => $params->{body},
+        'associated_metaclass' => $params->{associated_metaclass},
+        'package_name'         => $params->{package_name},
+        'name'                 => $params->{name},
+        'original_method'      => $params->{original_method},
+
+        # defined in this class
+        'modifier_table'       => $params->{modifier_table}
+    } => $class;
 }
 
 sub get_original_method {
@@ -157,6 +177,25 @@ sub around_modifiers {
     return @{$code->{'modifier_table'}->{around}->{methods}};
 }
 
+sub _make_compatible_with {
+    my $self = shift;
+    my ($other) = @_;
+
+    # XXX: this is pretty gross. the issue here is that CMOP::Method::Wrapped
+    # objects are subclasses of CMOP::Method, but when we get to moose, they'll
+    # need to be compatible with Moose::Meta::Method, which isn't possible. the
+    # right solution here is to make ::Wrapped into a role that gets applied to
+    # whatever the method_metaclass happens to be and get rid of
+    # wrapped_method_metaclass entirely, but that's not going to happen until
+    # we ditch cmop and get roles into the bootstrapping, so. i'm not
+    # maintaining the previous behavior of turning them into instances of the
+    # new method_metaclass because that's equally broken, and at least this way
+    # any issues will at least be detectable and potentially fixable. -doy
+    return $self unless $other->_is_compatible_with($self->_real_ref_name);
+
+    return $self->SUPER::_make_compatible_with(@_);
+}
+
 1;
 
 __END__
@@ -235,7 +274,7 @@ Stevan Little E<lt>stevan@iinteractive.comE<gt>
 
 =head1 COPYRIGHT AND LICENSE
 
-Copyright 2006-2009 by Infinity Interactive, Inc.
+Copyright 2006-2010 by Infinity Interactive, Inc.
 
 L<http://www.iinteractive.com>