File Coverage

blib/lib/Class/Adapter/Clear.pm

Criterion	Covered	Total	%
statement	13	13	100.0
branch			n/a
condition			n/a
subroutine	5	5	100.0
pod			n/a
total	18	18	100.0

package Class::Adapter::Clear;

=pod

=head1 NAME

Class::Adapter::Clear - A handy base Adapter class that makes no changes

=head1 SYNOPSIS

B

  # Load and create the CGI
  use CGI;
  $q = new CGI;

  # Create the page
  print $q->header,                    # HTTP Header
        $q->start_html('hello world'), # Start the page
        $q->h1('hello world'),         # Hello World!
        $q->end_html;                  # End the page

B

  # Load and create the CGI
  use CGI;
  $q = new CGI;

  # Convert to an Adapter
  use Class::Adapter::Clear;
  $q = new Class::Adapter::Clear( $q );

  # Create the page
  print $q->header,                    # HTTP Header
        $q->start_html('hello world'), # Start the page
        $q->h1('hello world'),         # Hello World!
        $q->end_html;                  # End the page

B

  package My::CGI;

  use base 'Class::Adapter::Clear';

  # Optional - Create the thing we are decorating auto-magically
  sub new {
      my $class = shift;

      # Create the object we are decorating
      my $query = CGI->new(@_);

      # Wrap it in the Adapter
      $class->SUPER::new($query);
  }

  # Decorate the h1 method to change what is created
  sub h1 {
  	my $self = shift;
  	my $str  = shift;

    # Do something before the real method call
    if ( defined $str and $str eq 'hello world' ) {
    	$str = 'Hello World!';
    }

    $self->_OBJECT_->($str, @_);
  }

=head1 DESCRIPTION

C provides the base class for creating one common
type of L classes. For more power, move up to
L.

On it's own C passes all methods through to the same
method in the parent object with the same parameters, responds to
C<-Eisa> like the parent object, and responds to C<-Ecan> like
the parent object.

It looks like a C, and it quacks like a C.

On this base, you simple implement whatever method you want to do
something special to.

  # Different method, same parameters
  sub method1 {
      my $self = shift;
      $self->_OBJECT_->method2(@_); # Call a different method
  }

  # Same method, different parameters
  sub method1 {
      my $self = shift;
      $self->_OBJECT_->method1( lc($_[0]) ); # Lowercase the param
  }

  # Same method, same parameters, tweak the result
  sub method1 {
      my $self = shift;
      my $rv = $self->_OBJECT_->method1(@_);
      $rv =~ s/\n/\n/g; # Add line-break HTML tags at each newline
      return $rv;
  }

As you can see, the advantage of this full-scale I approach,
compared to inheritance, or function wrapping (see L), is
that you have complete and utter freedom to do anything you might need
to do, without stressing the Perl inheritance model or doing anything
unusual or tricky with C references.

You may never need this much power. But when you need it, you B
need it.

As an aside, Class::Adapter::Clear is implemented with the following
L formula.

  use Class::Adapter::Builder
      ISA      => '_OBJECT_',
      AUTOLOAD => 1;

=head1 METHODS

=head2 new $object

As does the base L class, the default C constructor
takes a single object as argument and creates a new object which holds the
passed object.

Returns a new C object, or C if you do not pass
in an object.

=cut

use 5.005;
use strict;
use Class::Adapter::Builder
	ISA      => '_OBJECT_',
	AUTOLOAD => 1;

use vars qw{$VERSION};
BEGIN {
	$VERSION = '1.07';
}

1;

=pod

=head1 SUPPORT

Bugs should be reported via the CPAN bug tracker at

L

For other issues, contact the author.

=head1 AUTHOR

Adam Kennedy [e-mail]

=head1 SEE ALSO

L, L

=head1 COPYRIGHT

Copyright 2005 - 2011 Adam Kennedy.

This program is free software; you can redistribute
it and/or modify it under the same terms as Perl itself.

The full text of the license can be found in the
LICENSE file included with this module.

=cut