use Carp 'confess';
use Scalar::Util 'blessed', 'weaken';
-our $VERSION = '0.71';
+our $VERSION = '0.89';
$VERSION = eval $VERSION;
our $AUTHORITY = 'cpan:STEVAN';
|| confess
'You must supply a delegate_to_method which is a method name or a CODE reference';
+ exists $options{curried_arguments}
+ || ( $options{curried_arguments} = [] );
+
+ ( $options{curried_arguments} &&
+ ( 'ARRAY' eq ref $options{curried_arguments} ) )
+ || confess 'You must supply a curried_arguments which is an ARRAY reference';
+
my $self = $class->_new( \%options );
weaken( $self->{'attribute'} );
return bless $options, $class;
}
+sub curried_arguments { (shift)->{'curried_arguments'} }
+
sub associated_attribute { (shift)->{'attribute'} }
sub delegate_to_method { (shift)->{'delegate_to_method'} }
# NOTE: we used to do a goto here, but the goto didn't handle
# failure correctly (it just returned nothing), so I took that
# out. However, the more I thought about it, the less I liked it
- # doing the goto, and I prefered the act of delegation being
+ # doing the goto, and I preferred the act of delegation being
# actually represented in the stack trace. - SL
# not inlining this, since it won't really speed things up at
# all... the only thing that would end up different would be
$self->{body} = sub {
my $instance = shift;
my $proxy = $instance->$accessor();
- ( defined $proxy )
- || $self->throw_error(
- "Cannot delegate $handle_name to $method_to_call because "
- . "the value of "
- . $self->associated_attribute->name
- . " is not defined",
- method_name => $method_to_call,
- object => $instance
+
+ my $error
+ = !defined $proxy ? ' is not defined'
+ : ref($proxy) && !blessed($proxy) ? qq{ is not an object (got '$proxy')}
+ : undef;
+
+ if ($error) {
+ $self->throw_error(
+ "Cannot delegate $handle_name to $method_to_call because "
+ . "the value of "
+ . $self->associated_attribute->name
+ . $error,
+ method_name => $method_to_call,
+ object => $instance
);
- $proxy->$method_to_call(@_);
+ }
+ my @args = (@{ $self->curried_arguments }, @_);
+ $proxy->$method_to_call(@args);
};
}
=over 4
-=item B<new (%options)>
+=item B<< Moose::Meta::Method::Delegation->new(%options) >>
-This creates the method based on the criteria in C<%options>,
-these options are:
+This creates the delegation methods based on the provided C<%options>.
=over 4
=item I<attribute>
This must be an instance of C<Moose::Meta::Attribute> which this
-accessor is being generated for. This parameter is B<required>.
+accessor is being generated for. This options is B<required>.
=item I<delegate_to_method>
The method in the associated attribute's value to which we
delegate. This can be either a method name or a code reference.
+=item I<curried_arguments>
+
+An array reference of arguments that will be prepended to the argument list for
+any call to the delegating method.
+
=back
-=item B<associated_attribute>
+=item B<< $metamethod->associated_attribute >>
Returns the attribute associated with this method.
-=item B<delegate_to_method>
+=item B<< $metamethod->curried_arguments >>
+
+Return any curried arguments that will be passed to the delegated method.
+
+=item B<< $metamethod->delegate_to_method >>
-Returns the method to which this method delegates.
+Returns the method to which this method delegates, as passed to the
+constructor.
=back
=head1 BUGS
-All complex software has bugs lurking in it, and this module is no
+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.