use Carp 'confess';
use Scalar::Util 'blessed';
-our $VERSION = '0.04';
+our $VERSION = '1.12';
+$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
use base 'Class::MOP::Method';
);
if (@$before && @$after) {
$modifier_table->{cache} = sub {
- $_->(@_) for @{$before};
+ for my $c (@$before) { $c->(@_) };
my @rval;
((defined wantarray) ?
((wantarray) ?
($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}->(@_);
}
}
($rval[0] = $around->{cache}->(@_)))
:
$around->{cache}->(@_));
- $_->(@_) for @{$after};
+ for my $c (@$after) { $c->(@_) };
return unless defined wantarray;
return wantarray ? @rval : $rval[0];
}
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,
},
};
$_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 {
my $code = shift;
- $code->{'%!modifier_table'}->{orig};
+ $code->{'modifier_table'}->{orig};
}
sub add_before_modifier {
my $code = shift;
my $modifier = shift;
- unshift @{$code->{'%!modifier_table'}->{before}} => $modifier;
- $_build_wrapped_method->($code->{'%!modifier_table'});
+ unshift @{$code->{'modifier_table'}->{before}} => $modifier;
+ $_build_wrapped_method->($code->{'modifier_table'});
+}
+
+sub before_modifiers {
+ my $code = shift;
+ return @{$code->{'modifier_table'}->{before}};
}
sub add_after_modifier {
my $code = shift;
my $modifier = shift;
- push @{$code->{'%!modifier_table'}->{after}} => $modifier;
- $_build_wrapped_method->($code->{'%!modifier_table'});
+ push @{$code->{'modifier_table'}->{after}} => $modifier;
+ $_build_wrapped_method->($code->{'modifier_table'});
+}
+
+sub after_modifiers {
+ my $code = shift;
+ return @{$code->{'modifier_table'}->{after}};
}
{
sub add_around_modifier {
my $code = shift;
my $modifier = shift;
- unshift @{$code->{'%!modifier_table'}->{around}->{methods}} => $modifier;
- $code->{'%!modifier_table'}->{around}->{cache} = $compile_around_method->(
- @{$code->{'%!modifier_table'}->{around}->{methods}},
- $code->{'%!modifier_table'}->{orig}->body
+ unshift @{$code->{'modifier_table'}->{around}->{methods}} => $modifier;
+ $code->{'modifier_table'}->{around}->{cache} = $compile_around_method->(
+ @{$code->{'modifier_table'}->{around}->{methods}},
+ $code->{'modifier_table'}->{orig}->body
);
- $_build_wrapped_method->($code->{'%!modifier_table'});
+ $_build_wrapped_method->($code->{'modifier_table'});
}
}
+sub around_modifiers {
+ my $code = shift;
+ 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__
=head1 NAME
-Class::MOP::Method::Wrapped - Method Meta Object to handle before/around/after modifiers
+Class::MOP::Method::Wrapped - Method Meta Object for methods with before/after/around modifiers
=head1 DESCRIPTION
-This is a L<Class::MOP::Method> subclass which provides the funtionality
-to wrap a given CODE reference with before, after and around method modifiers.
+This is a L<Class::MOP::Method> subclass which implements before,
+after, and around method modifiers.
=head1 METHODS
=over 4
-=item B<wrap ($code)>
+=item B<< Class::MOP::Method::Wrapped->wrap($metamethod, %options) >>
-This is the constructor, it will return a B<Class::MOP::Method::Wrapped>
-instance that can be used to add before, after and around modifiers to.
+This is the constructor. It accepts a L<Class::MOP::Method> object and
+a hash of options.
-=item B<get_original_method>
+The options are:
-This returns the original CODE reference that was provided to the
-constructor.
+=over 8
+
+=item * name
+
+The method name (without a package name). This will be taken from the
+provided L<Class::MOP::Method> object if it is not provided.
+
+=item * package_name
+
+The package name for the method. This will be taken from the provided
+L<Class::MOP::Method> object if it is not provided.
+
+=item * associated_metaclass
+
+An optional L<Class::MOP::Class> object. This is the metaclass for the
+method's class.
=back
-=head2 Modifiers
+=item B<< $metamethod->get_original_method >>
-These three methods will add the method modifiers to the wrapped
-CODE reference. For more information on how method modifiers work,
-see the section in L<Class::MOP::Class>.
+This returns the L<Class::MOP::Method> object that was passed to the
+constructor.
-=over 4
+=item B<< $metamethod->add_before_modifier($code) >>
+
+=item B<< $metamethod->add_after_modifier($code) >>
+
+=item B<< $metamethod->add_around_modifier($code) >>
+
+These methods all take a subroutine reference and apply it as a
+modifier to the original method.
+
+=item B<< $metamethod->before_modifiers >>
-=item B<add_before_modifier ($code)>
+=item B<< $metamethod->after_modifiers >>
-=item B<add_after_modifier ($code)>
+=item B<< $metamethod->around_modifiers >>
-=item B<add_around_modifier ($code)>
+These methods all return a list of subroutine references which are
+acting as the specified type of modifier.
=back
=head1 COPYRIGHT AND LICENSE
-Copyright 2006-2008 by Infinity Interactive, Inc.
+Copyright 2006-2010 by Infinity Interactive, Inc.
L<http://www.iinteractive.com>
projects / gitmo/Class-MOP.git / blobdiff