File Coverage

blib/lib/WWW/Mechanize/Plugin/Cache.pm

Criterion	Covered	Total	%
statement	19	21	90.4
branch			n/a
condition			n/a
subroutine	7	7	100.0
pod			n/a
total	26	28	92.8

package WWW::Mechanize::Plugin::Cache;

our $VERSION = '0.06';
use base qw(Class::Accessor::Fast);
__PACKAGE__->mk_accessors(qw(caching_initialized cache_args cache cached));

use warnings;
use strict;
use Carp;
use Data::Dump::Streamer;
use Cache::FileCache;
use WWW::Mechanize;

my $prehook_closure  = sub { prehook(@_) };
my $posthook_closure = sub { posthook(@_) };

sub import { }  # This plugin does not have any import options

sub init {
  my ($class, $pluggable, %args) = @_;

  # Set up the one-time pre-hook.
  $pluggable->pre_hook('get',  $prehook_closure);
  $pluggable->post_hook('get', $posthook_closure);

  {
    no strict 'refs';
    # Used to capture the cache arguments on the current statement.
    *{caller(). '::cache_args'} = \&cache_args;

    # Whether or not a given request came from the cache.
    *{caller(). '::cached'} = \&cached;

    # The cache object itself.
    *{caller(). '::cache'} = \&cache;

    # Whether or not the Mech object is sufficiently set up to
    # allow caching to work.
    *{caller(). '::caching_initialized'} = \&caching_initialized;
  }

  # Grab the arguments now, and process them later.
  $pluggable->cache_args($args{'cache'});

  # Note that the Mech object is not yet initialized enough to
  # support caching.
  $pluggable->caching_initialized(0);

  # And we've processed this.
  return qw(cache);
}

sub _make_cache_key {
  # We'll just use the URL as the key, since that's what we have.
  my ($pluggable, $mech, @args) = @_;
  return $args[0];
}

sub _create_cache {
  my($pluggable, $args) = @_;

  if ($args) {
    # We have a cache argument.
    if (ref $args) {
      # It points to something that might be a cache.
      if ( $args->isa('Cache::FileCache')) {
        # Yes, it is. Set up the cache.
        $pluggable->cache($args);
      }
      else {
        # Not a good cache object.
        die "The supplied object is not a valid cache\n";
      }
    }
    elsif ($args) {
      # A true value, which means "start caching, dude."
      # Buld a new cache.
      my $cache = Cache::FileCache->new(
                                        {default_expires_in => "1d",
                                         namespace => 'www-mechanize-cached'},
                                       );
      # Save it in the Mech::Pluggable object.
      $pluggable->cache($cache);
    }
  }
}

sub prehook {
  my ($pluggable, $mech, @args) = @_;

  # Are we supposed to have a cache?
  if (my $args = $pluggable->cache_args) {
    $pluggable->cache(_create_cache($pluggable, $args));

    # Don't create the cache again.
    $pluggable->cache_args(0);
  }

  # Is there a cache available?
  if (my $cache = $pluggable->cache) {
    my $cache_key = _make_cache_key(@_);
    my $cached = $cache->get($cache_key);

    # Did we find the current request in the cache?
    if ($cached) {
      if (!$pluggable->caching_initialized) {
        $pluggable->caching_initialized(1);
        # Commit enough surgery on the Mech object to
        # get all of it methods to work even without a
        # real get.
        #
        # Currently we're not doing anything...
      }
      # Yes. Return it and don't call the method.
      $mech->get('file://.');
      $mech->update_html($cached);
      $pluggable->cached(1);
      return -1;
    }
    else {
      # No. Go ahead and call the method.
      $pluggable->cached(0);
      return 0;
    }
  }
  # If there was no cache, just return as usual.
  else {
    return 0;
  }
}

sub posthook {
  my($pluggable, $mech, @args) = @_;
  # If we got to this point, we've actually
  # done either a get or a submit_form. We
  # should save the current page, unless it's
  # already in the cache.
  unless ($pluggable->cached) {
    # It's not in the cache. Save it --
    # if there actually *IS* a cache.
    my $cache = $pluggable->cache;
    if ($cache) {
      $cache->set($args[0],$mech->content);
      # Don't mark it, because we haven't
      # tried to fetch it from the cache.
      # We've only stored it.
    }
  }
}

1; # Magic true value required at end of module
__END__