File Coverage

blib/lib/Mojolicious/Plugin/AppCacheManifest.pm

Criterion	Covered	Total	%
statement	71	74	95.9
branch	25	36	69.4
condition	14	22	63.6
subroutine	7	7	100.0
pod	1	1	100.0
total	118	140	84.2

package Mojolicious::Plugin::AppCacheManifest;

use Mojo::Base qw( Mojolicious::Plugin );

our $VERSION = "0.05";
our %HEADERS = map +( $_, undef ), qw( CACHE FALLBACK NETWORK SETTINGS );
our %CACHE;

has "timeout";

sub register
{
	my ( $self, $app, $conf ) = @_;
	my $extension = $conf->{extension} // "appcache";
	my $re = join( "|", map quotemeta,
	    ref( $extension )
	     ?  @$extension
	     : ( $extension )
	);
	my $redir = qr!\A (.*?) /+ [^/]+ \. (?: $re ) \z!x;
	my $static = $app->static();

	$self->timeout( $conf->{timeout} // 0 );

	$app->hook( before_dispatch => sub {
		my $c = shift;
		my $stash = $c->stash();
		my $tx = $c->tx();
		my $req = $tx->req();
		my $res = $tx->res();
		my $url = $req->url();
		my $path  = $stash->{path}
			  ? Mojo::Path->new( $stash->{path} )
			  : $url->path->clone();
		my $parts = $path->canonicalize->parts();

		# catch nonsense
		return if @$parts == 0 || $parts->[0] eq "..";

		# check for extensions
		unless ( $path =~ $redir ) {
			# otherwise do what the static dispatch code does
			return unless $static->serve( $c, join( "/", @$parts ) );

			$stash->{"mojo.static"}++;
			return !!$c->rendered();
		}

		# setup and prepare
		my $code = 200;
		my $asset = $static->file( join( "/", @$parts ) );
		my ( $output, $last_modified ) = $self->_process(
			$asset->slurp(),
			$asset->path(),
			$static->paths(),
		);

		# save bandwith if possible
		if ( my $date = $req->headers->if_modified_since() ) {
			$code = 304
				if $last_modified eq Mojo::Date->new( $date );
		}

		# send response with conditional body
		$res->code( $code );
		$res->headers->content_type( "text/cache-manifest" );
		$res->headers->last_modified( $last_modified );
		$res->body( $output )
			if $code == 200;

		$stash->{"mojo.static"}++;
		return !!$c->rendered();
	} );

	return $self;
}

sub _process
{
	my ( $self, $body, $path, $dirs ) = @_;
	my $timeout = $self->timeout();
	my $mtime = ( stat( $path ) )[9];
	my $time = time();

	# use cache when file modification and timeout are fine
	return @{ $CACHE{ $path } }[2,3] if
	  exists( $CACHE{ $path } ) &&
		  $CACHE{ $path }[0] >= $mtime &&
		  $CACHE{ $path }[1] + $timeout > $time;

	# extract structure, find highest last modification and generate new output
	my $manifest = $self->_parse( $body );
	my $date = $self->_find_last_modified( $manifest, $mtime, $dirs );
	my $output = $self->_generate( $manifest, $date );

	# put into cache when a timeout is given
	$CACHE{ $path } = [ $date->epoch(), $time, $output, $date ]
		if $timeout > 0;

	return ( $output, $date );
}

sub _parse
{
	my ( $self, $body ) = @_;

	return unless # found and removed the header
	    $body =~ s!\A CACHE [ ] MANIFEST [ \t\r\n] \s* !!sx;

	# split sections by header; prepend header for initial section
	my @body = ( "CACHE", split( m/
	    ^ \s* (\S+) \s* : \s* \r?\n \s*
	/mx, $body ) );

	my %seen;
	my %manifest;

	while ( @body and my $header = uc( shift( @body ) ) ) {
		my $part = shift( @body );

		# skip unknown
		next unless exists( $HEADERS{ $header } );

		# separate lines without comments
		my @lines = grep( +(
		    ! m!\A [#] !x
		), split( m! \s* \r?\n \s* !x, $part ) );

		# unique elements in order; fallback section has pairs
		push( @{ $manifest{ $header } }, map +( $header eq "FALLBACK"
		    ? m!\A (\S+) \s+ (\S+) !x && ! $seen{ $header, $1, $2 }++
		        ? [ $1, $2 ] : ( )
		    : ! $seen{ $header, $_ }++
		        ? ( $_ ) : ( )
		), @lines );
	}

	return \%manifest;
}

sub _find_last_modified
{
	my ( $self, $manifest, $maxmtime, $dirs ) = @_;
	my @parts = map Mojo::URL->new( $_ )->path->canonicalize->parts(),
		    @{ $manifest->{CACHE} };

	# check all paths but prevent path traversal attempts
	for my $path ( map join( "/", @$_ ), grep $_->[0] ne "..", @parts ) {
		my $mtime = 0;

		# try the path in each directory
		stat( "$_/$path" ) and
		    # keep the modification time
		    $mtime = ( stat( _ ) )[9],
		    # stop on the first hit
		    last
			for @$dirs;

		$maxmtime = $mtime if $mtime > $maxmtime;
	}

	return Mojo::Date->new( $maxmtime );
}

sub _generate
{
	my ( $self, $manifest, $date ) = @_;
	my @output = (
		"CACHE MANIFEST",
		"# $date",
	);

	# put cache section explicitely first
	push( @output, @{ $manifest->{CACHE} } )
		if $manifest->{CACHE};

	# followed by fallback in pairs
	push( @output, "FALLBACK:", map "@$_", @{ $manifest->{FALLBACK} } )
		if $manifest->{FALLBACK};

	# finally settings and network in that order
	push( @output, "$_:", @{ $manifest->{ $_ } } )
		for grep $manifest->{ $_ }, qw( SETTINGS NETWORK );

	return join( "\n", @output, "" ); # trailing newline
}

1;

__END__