File Coverage

blib/lib/Plack/Middleware/Assets.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

#
# This file is part of Plack-Middleware-Assets
#
# This software is Copyright (c) 2013 by Moritz Onken.
#
# This is free software, licensed under:
#
#   The (three-clause) BSD License
#
package Plack::Middleware::Assets;
{
  $Plack::Middleware::Assets::VERSION = '1.0.0';
}

# ABSTRACT: Concatenate and minify JavaScript and CSS files
use strict;
use warnings;

use base 'Plack::Middleware';
use Plack::Util::Accessor
    qw( separator filter content minify files key mtime type type_class expires extension );

use Digest::MD5 qw(md5_hex);
use HTTP::Date  ();
use Class::Load ();

sub new {
    my $class = shift;
    my $self  = $class->SUPER::new(@_);

    # set defaults
    $self->separator(1) unless ( defined $self->separator );
    $self->minify(1)    unless ( defined $self->minify );
    $self->filter(1)    unless ( defined $self->filter );
    $self->_build_content;
    return $self;
}

sub _build_content {
    my $self = shift;
    local $/;

    my $type = $self->type
        || (
          ( grep {/\.css$/} @{ $self->files } ) ? 'css'
        : ( grep {/\.js$/} @{ $self->files } )  ? 'js'
        : 'plain'
        );
    $self->type($type);
    my $class = __PACKAGE__ . "::Type::$type";
    eval { Class::Load::load_class($class) }
        or die "$class could not be loaded: $@";
    $self->type_class($class);

    my $separator = $self->separator;

    # use default comment format unless format was specified
    $separator = $class->separator
        if $separator && $separator !~ /%s/;

    $self->content(
        join(
            "\n",
            map {
                open my $fh, '<', $_ or die "$_: $!";
                ( $separator ? sprintf( $separator, $_ ) : '' ) . <$fh>
                } @{ $self->files }
        )
    );

    $self->content( $self->_transform('filter') ) if $self->filter;
    $self->content( $self->_transform('minify') ) if $self->minify;

    $self->key( md5_hex( $self->content ) );
    my @mtime = map { ( stat($_) )[9] } @{ $self->files };
    $self->mtime( ( reverse( sort(@mtime) ) )[0] );
}

sub _transform {
    my ( $self, $transform ) = @_;
    return $self->content
        if ( $transform ne 'minify'
        && $ENV{PLACK_ENV}
        && $ENV{PLACK_ENV} eq 'development' );
    no strict 'refs';
    my $run = $self->$transform;
    my $method;
    if ( ref $run eq 'CODE' ) {
        $method = $run;
    }
    elsif ( $run && $self->type_class->can($transform) ) {
        $method = $self->type_class . "::$transform";
    }
    return $self->content unless ($method);

    local $_ = $self->content;
    return $method->($_);
}

sub serve {
    my $self = shift;
    my $type = $self->type;

    return [
        200,
        [   'Content-Type'   => $self->type_class->content_type,
            'Content-Length' => length( $self->content ),
            'Last-Modified'  => HTTP::Date::time2str( $self->mtime ),
            'Expires' =>
                HTTP::Date::time2str( time + ( $self->expires || 2592000 ) ),
        ],
        [ $self->content ]
    ];
}

sub call {
    my $self = shift;
    my $env  = shift;

    if ( $ENV{PLACK_ENV} && $ENV{PLACK_ENV} eq 'development' ) {
        my @mtime = map { ( stat($_) )[9] } @{ $self->files };
        $self->_build_content
            if ( $self->mtime < ( reverse( sort(@mtime) ) )[0] );
    }

    $env->{'psgix.assets'} ||= [];
    my $extension = $self->extension || $self->type_class->extension;
    my $url = '/_asset/' . $self->key . '.' . $extension;
    push( @{ $env->{'psgix.assets'} }, $url );
    return $self->serve if $env->{PATH_INFO} eq $url;
    return $self->app->($env);
}

package Plack::Middleware::Assets::Type::plain;
{
  $Plack::Middleware::Assets::Type::plain::VERSION = '1.0.0';
}
use strict;
use warnings;

sub content_type {'text/plain'}
sub separator    { }
sub extension    {'txt'}

package Plack::Middleware::Assets::Type::css;
{
  $Plack::Middleware::Assets::Type::css::VERSION = '1.0.0';
}
use strict;
use warnings;
use base 'Plack::Middleware::Assets::Type::plain';
use CSS::Minifier::XS qw(minify);

sub content_type {'text/css'}
sub separator    {"/* %s */\n"}
sub extension    {'css'}

package Plack::Middleware::Assets::Type::js;
{
  $Plack::Middleware::Assets::Type::js::VERSION = '1.0.0';
}
use strict;
use warnings;
use base 'Plack::Middleware::Assets::Type::plain';
use JavaScript::Minifier::XS qw(minify);

sub content_type {'application/javascript'}
sub separator    {"/* %s */\n"}
sub extension    {'js'}

1;

__END__