File Coverage

blib/lib/Plack/Middleware/EasyHooks.pm

Criterion	Covered	Total	%
statement	74	78	94.8
branch	32	40	80.0
condition	4	6	66.6
subroutine	15	16	93.7
pod	6	8	75.0
total	131	148	88.5

package Plack::Middleware::EasyHooks;

use 5.006;
use strict;
use warnings;

use parent qw(Plack::Middleware);

our $VERSION = '0.02';

sub before {
    my ($self, $env) = @_;

    $self->{before}->($env) if defined $self->{before};
}

sub after {
    my ($self, $env, $res) = @_;

    $self->{after}->($env, $res) if defined $self->{after};
}

sub filter {
    my ($self, $env, $chunk) = @_;

    $chunk = $self->{filter}->($env, $chunk) if defined $self->{filter};

    return $chunk;
}

sub tail {
    my ($self, $env) = @_;

    $self->{tail}->($env) if defined $self->{tail};
}

sub finalize {
    my ($self, $env) = @_;

    $self->{finalize}->($env) if defined $self->{finalize};
}

sub call {
    my ($self, $env) = @_;

    $self->before($env);
    my $res = $self->app->($env);

    if ( $env->{"psgix.cleanup"} ) {
        push @{ $env->{"psgix.cleanup.handlers"} }, sub { $self->finalize($_[0]) };
    }

    if ( ref $res eq "ARRAY" ) {
        return $self->handle_full_response($env, $res);
    }

    if ( ref $res eq "CODE" ) {
        return $self->handle_delayed_response($env, $res);
    }

    # Unknown response type...
    return $res;
}

sub handle_full_response {
    my ($self, $env, $res) = @_;

    my $override = $self->after($env, $res);
    if (defined($override) && ref $override eq "ARRAY") {
        $res->[0] = $override->[0];
        $res->[1] = $override->[1];
        $res->[2] = $override->[2];
    }

    my ($status, $header, $body) = @$res;

    if (ref $body eq "ARRAY") {
        my $tail;
        $body  = [
            (map { $self->filter($env, $_) } @$body),
            (defined($tail = $self->tail($env)) ? $tail : ())
        ];

        $self->finalize($env) unless $env->{'psgix.cleanup'};
        return [ $status, $header, $body ];
    }

    my $done;
    my $wrapped = Plack::Util::inline_object(
        getline => sub {
            return if $done;

            my $chunk = $body->getline();

            if (defined $chunk) {
                return $self->filter($env, $chunk);
            }

            $done = 1;
            return $self->tail($env);
        },
        close => sub {
            $body->close;

            $self->finalize($env) unless $env->{"psgix.cleanup"};
        },
    );

    return [ $status, $header, $wrapped ];
}

sub handle_delayed_response {
    my ($self, $env, $res) = @_;

    return sub {
        my $responder = shift;

        $res->(
            sub {
                my ($res) = @_;

                if (exists( $res->[2] )) {
                    return $responder->( $self->handle_full_response($env, $res) );
                }

                my $override = $self->after($env, $res);
                if (defined($override) && ref $override eq "ARRAY") {
                    $res->[0] = $override->[0];
                    $res->[1] = $override->[1];
                    $res->[2] = $override->[2] if exists $override->[2];
                }

                my $writer = $responder->( $res );

                return Plack::Util::inline_object(
                    write => sub {
                        $writer->write( $self->filter($env, @_) );
                    },
                    close => sub {
                        my $tail = $self->tail();
                        $writer->write($tail) if defined($tail);

                        $self->finalize($env) unless $env->{'psgix.cleanup'};
                        $writer->close;
                    },
                );
            }
        );
    };
}


1;

__END__