File Coverage

blib/lib/Mojolicious/Plugin/CHI/Route.pm

Criterion	Covered	Total	%
statement	66	68	97.0
branch	22	26	84.6
condition	10	17	58.8
subroutine	8	8	100.0
pod	1	1	100.0
total	107	120	89.1

package Mojolicious::Plugin::CHI::Route;
use Mojo::Base 'Mojolicious::Plugin';
use Mojo::Util qw'md5_sum';
use Mojo::Date;

our $VERSION = '0.05';

# Register plugin
sub register {
  my ($plugin, $app, $param) = @_;

  # Plugin parameter
  $param ||= {};

  # Load parameter from Config file
  if (my $config_param = $app->config('CHI-Route')) {
    $param = { %$param, %$config_param };
  };

  # Load CHI plugin if not already loaded
  unless (exists $app->renderer->helpers->{chi}) {
    $app->plugin('CHI');
  };

  # set namespace
  my $namespace = $param->{namespace} // 'default';

  unless ($app->chi($namespace)) {
    $app->log->error("No cache defined for '$namespace'");

    # Add condition to check for cache
    $app->routes->add_condition(
      chi => sub { 1 }
    );

    return;
  };

  my $expires_in = $param->{expires_in} // '6 hours';

  # Set default key
  my $default_key = $param->{key} // sub {
    return shift->req->url->to_abs->to_string;
  };

  # Cache if required
  $app->hook(
    after_render => sub {
      my ($c, $output, $format) = @_;

      # No cache instruction found
      return unless $c->stash('chi.r.cache');

      # Only cache successfull renderings
      if ($c->res->is_error || ($c->stash('status') && $c->stash('status') != 200)) {
        return;
      };

      # Get key from stash
      my $key = $c->stash('chi.r.cache');

      # Set ETag and last_modified headers
      my $last_modified = Mojo::Date->new;
      my $headers;
      foreach ($c->res->headers) {
        $_->last_modified($last_modified);
        $_->etag('W/"' . md5_sum($last_modified->to_string). '"');
        $headers = $_->to_hash;

        # Delete Mojolicious server header
        delete $headers->{Server};
      };

      # Cache
      $c->chi($namespace)->set(
        $key => {
          'body'    => $$output,
          'format'  => $format,
          'headers' => $headers
        } => {
          expires_in => $c->stash('chi.r.expires') // $expires_in
        }
      );
    }
  );

  # Add condition to check for cache
  $app->routes->add_condition(
    chi => sub {
      my ($r, $c, $captures, $arg) = @_;

      # Only cache GET requests
      return 1 if $c->req->method ne 'GET';

      my $chi = $c->chi($namespace);

      # No cache associated
      return 1 unless $chi;

      # Get the key for the cache
      my $key;

      # Set by argument
      if ($arg->{key}) {
        $key = ref $arg->{key} ? $arg->{key}->($c) : $arg->{key} . '';
      }

      # Set
      else {
        $key = $default_key->($c);
      };

      return 1 unless $key;

      # Get cache based on key
      my $found = $chi->get($key);

      # Found cache! Render
      if ($found) {

        $c->stash->{'mojo.routed'} = 1;

        my $headers = $found->{headers};
        my $etag = delete $headers->{'ETag'};
        my $last_modified = delete $headers->{'Last-Modified'};

        # Check if client side cache is still fresh
        if ($c->is_fresh(
          etag => $etag,
          last_modified => $last_modified
        )) {
          $c->log->debug('Client side cache is still valid');
          $c->rendered(304);
        }

        # Client has no valid copy of the cache
        else {

          $c->log->debug('Routing to a cache');

          for ($c->res) {
            $_->headers->from_hash($headers);
            $_->headers->header('X-Cache-CHI' => 1);
            $_->code(200);
          };

          # Render from cache
          $c->render(
            'format' => $found->{format},
            'data'   => $found->{body}
          );
        };

        # Skip to final
        $c->match->position(1000);
      }

      # Render normally and then cache the route
      else {

        if (exists $arg->{expires_in}) {
          $c->stash('chi.r.expires' => $arg->{expires_in});
        };

        $c->stash('chi.r.cache' => $key);
      };

      return 1;
    }
  );
};


1;


__END__