NAME

       Class::MakeMethods::Composite::Universal - Composite Method Tricks

SYNOPSIS

         Class::MakeMethods::Composite::Universal->make_patch(
           -TargetClass => 'SomeClass::OverYonder',
           name => 'foo',
           pre_rules => [
             sub {
               my $method = pop;
               warn "Arguments for foo:", @_
             }
           ]
           post_rules => [
             sub {
               warn "Result of foo:", Class::MakeMethods::Composite->CurrentResults
             }
           ]
         );

DESCRIPTION

       The Composite::Universal suclass of MakeMethods provides some generally-applicable types
       of methods based on Class::MakeMethods::Composite.

METHOD GENERATOR TYPES

   patch
       The patch ruleset generates composites whose core behavior is based on an existing
       subroutine.

       Here's a sample usage:

         sub foo {
           my $count = shift;
           return 'foo' x $count;
         }

         Class::MakeMethods::Composite::Universal->make(
           -ForceInstall => 1,
           patch => {
             name => 'foo',
             pre_rules => [
               sub {
                 my $method = pop @_;
                 if ( ! scalar @_ ) {
                   @{ $method->{args} } = ( 2 );
                 }
               },
               sub {
                 my $method = pop @_;
                 my $count = shift;
                 if ( $count > 99 ) {
                   Carp::confess "Won't foo '$count' -- that's too many!"
                 }
               },
             ],
             post_rules => [
               sub {
                 my $method = pop @_;
                 if ( ref $method->{result} eq 'SCALAR' ) {
                   ${ $method->{result} } =~ s/oof/oozle-f/g;
                 } elsif ( ref $method->{result} eq 'ARRAY' ) {
                   map { s/oof/oozle-f/g } @{ $method->{result} };
                 }
               }
             ],
           },
         );

   make_patch
       A convenient wrapper for "make()" and the "patch" method generator.

       Provides the '-ForceInstall' flag, which is required to ensure that the patched subroutine
       replaces the original.

       For example, one could add logging to an existing method as follows:

         Class::MakeMethods::Composite::Universal->make_patch(
           -TargetClass => 'SomeClass::OverYonder',
           name => 'foo',
           pre_rules => [
             sub {
               my $method = pop;
               warn "Arguments for foo:", @_
             }
           ]
           post_rules => [
             sub {
               warn "Result of foo:", Class::MakeMethods::Composite->CurrentResults
             }
           ]
         );

SEE ALSO

       See Class::MakeMethods for general information about this distribution.

       See Class::MakeMethods::Composite for more about this family of subclasses.