File Coverage

blib/lib/Plack/Request/WithEncoding.pm

Criterion	Covered	Total	%
statement	73	74	98.6
branch	14	16	87.5
condition	8	12	66.6
subroutine	19	19	100.0
pod	8	8	100.0
total	122	129	94.5

package Plack::Request::WithEncoding;
use 5.008_001;
use strict;
use warnings;
use parent qw/Plack::Request/;
use Encode ();
use Carp ();
use Hash::MultiValue;

our $VERSION = "0.14";

use constant KEY_BASE_NAME    => 'plack.request.withencoding';
use constant DEFAULT_ENCODING => 'utf-8';

sub encoding {
    my $env = $_[0]->env;
    my $k = KEY_BASE_NAME . '.encoding';

    # In order to be able to specify the `undef` into $req->env->{plack.request.withencoding.encoding}
    exists $env->{$k} ? $env->{$k} : ($env->{$k} = DEFAULT_ENCODING);
}

sub body_parameters {
    my $self = shift;
    $self->env->{KEY_BASE_NAME . '.body'} ||= $self->_decode_parameters($self->SUPER::body_parameters);
}

sub query_parameters {
    my $self = shift;
    $self->env->{KEY_BASE_NAME . '.query'} ||= $self->_decode_parameters($self->SUPER::query_parameters);
}

sub parameters {
    my $self = shift;
    $self->env->{KEY_BASE_NAME . '.merged'} ||= do {
        my $query = $self->query_parameters;
        my $body  = $self->body_parameters;
        Hash::MultiValue->new($query->flatten, $body->flatten);
    }
}

sub raw_body_parameters {
    shift->SUPER::body_parameters;
}

sub raw_query_parameters {
    shift->SUPER::query_parameters;
}

sub raw_parameters {
    my $self = shift;

    $self->env->{'plack.request.merged'} ||= do {
        my $query = $self->SUPER::query_parameters();
        my $body  = $self->SUPER::body_parameters();
        Hash::MultiValue->new( $query->flatten, $body->flatten );
    };
}

sub raw_param {
    my $self = shift;

    my $raw_parameters = $self->raw_parameters;
    return keys %{ $raw_parameters } if @_ == 0;

    my $key = shift;
    return $raw_parameters->{$key} unless wantarray;
    return $raw_parameters->get_all($key);
}

sub _decode_parameters {
    my ($self, $stuff) = @_;
    return $stuff unless $self->encoding; # return raw value if encoding method is `undef`

    my $encoding = Encode::find_encoding($self->encoding);
    unless ($encoding) {
        my $invalid_encoding = $self->encoding;
        Carp::croak("Unknown encoding '$invalid_encoding'.");
    }

    my @flatten = $stuff->flatten;
    my @decoded;
    while ( my ($k, $v) = splice @flatten, 0, 2 ) {
        push @decoded, $self->_decode($encoding, $k), $self->_decode($encoding, $v);
    }
    return Hash::MultiValue->new(@decoded);
}

sub _decode {
    my ($self, $encoding, $data) = @_;

    if (ref $data eq "ARRAY") {
        my @result;
        for my $d (@$data) {
            push @result, $self->_decode($encoding, $d);
        }
        return \@result;
    }
    elsif (ref $data eq "HASH") {
        my %result;
        while (my ($k, $v) = each %$data) {
            $result{$self->_decode($encoding, $k)} = $self->_decode($encoding, $v);
        }
        return \%result;
    }

    return defined $data ? $encoding->decode($data) : undef;
}

1;
__END__