File Coverage

blib/lib/Minima/Controller.pm

Criterion	Covered	Total	%
statement	35	35	100.0
branch			n/a
condition			n/a
subroutine	12	12	100.0
pod			n/a
total	47	47	100.0

use v5.40;
use experimental 'class';

class Minima::Controller;

use Carp;
use Data::Dumper;
use Encode qw(decode);
use Hash::MultiValue;
use JSON;
use Minima::View::PlainText;
use Plack::Request;
use Plack::Response;
use Scalar::Util qw(reftype);

use constant k_FLASH => 'minima.flash';

field $env             :reader;
field $app      :param :reader;
field $route    :param :reader = {};

field $request  :reader;
field $response :reader;
field $params   :reader;

field $req_encoding;

ADJUST {
    $env = $app->env // {};

    $request  = Plack::Request->new($env);
    $response = Plack::Response->new(200);

    $params = $self->_get_request_parameters;
}

method before_action    ($m) { }
method after_action     ($r) { }

method trimmed_params ($options = {})
{
    my $exclude = $options->{exclude} // [];
    my @f_params = $params->flatten;
    my @params;

    for my ($k, $v) (@f_params) {
        if (defined $v) {
            my $skip = 0;
            for my $pat (@$exclude) {
                if (ref $pat && reftype $pat eq 'REGEXP') {
                    if ($k =~ $pat) { $skip = 1; last }
                } else {
                    if ($k eq $pat) { $skip = 1; last }
                }
            }
            if (!$skip) {
                if (!ref $v) {
                    $v = trim $v;
                } elsif (ref $v eq ref []) {
                    $v = [ map { defined $_ ? trim($_) : $_ } @$v ];
                }
            }
        }
        push @params, $k, $v;
    }
    return Hash::MultiValue->new(@params);
}

method json_body
{
    my $c_type = $request->content_type // '';
    return undef unless $c_type =~ m|\Aapplication/json\b|i;

    my $body = $request->content;
    return undef unless length $body;

    my $data;

    try {
        $data = decode_json($body);
    } catch ($e) {
        return undef;
    }

    return $data;
}

method flash ($type = undef, $message = undef)
{
    my $session = $request->session;
    my $options = $request->session_options;

    croak <<~M unless $session;
        flash requires session middleware.
        Please enable Plack::Middleware::Session.
        M

    # pop
    unless (defined $type) {
        return undef unless exists $session->{+k_FLASH};
        delete $options->{no_store} if $options;
        return delete $session->{+k_FLASH};
    }

    # push
    delete $options->{no_store} if $options;
    push $session->{+k_FLASH}->{$type}->@*, $message;
}

method hello
{
    $self->render(Minima::View::PlainText->new, "hello, world\n");
}

method not_found
{
    $response->code(404);
    $self->render(Minima::View::PlainText->new, "not found\n");
}

method redirect ($url, $code = 302)
{
    $response->redirect($url, $code);
    $response->finalize;
}

method render ($view, $data = {})
{
    $response->body($view->render($data));
    $view->prepare_response($response);

    $response->finalize;
}

method print_env
{
    return $self->redirect('/') unless $app->development;

    my $max = 0;
    for (map { length } keys %$env) {
        $max = $_ if $_ > $max;
    }

    $self->render(
        Minima::View::PlainText->new,
        join '', map {
            sprintf "%*s => %s\n", -$max, $_, $env->{$_}
        } sort keys %$env
    );
}

method dd ($ref)
{
    my $dumper = Data::Dumper->new([ $ref ]);
    $dumper->Terse(1);

    $self->render(
        Minima::View::PlainText->new,
        $dumper->Dump,
    );
}

method _get_request_parameters
{
    $req_encoding = $app->config->{request_encoding} // 'UTF-8';

    my @parameters = map {
        $self->_decode($_)
    } $request->parameters->flatten;

    $params = Hash::MultiValue->new(@parameters);
}

method _decode ($data)
{
    if (ref $data eq ref {}) {
        my %encoded;
        for my ($k, $v) (%$data) {
            $encoded{ $self->_decode($k) } = $self->_decode($v);
        }
        return \%encoded;
    }

    if (ref $data eq ref []) {
        my @encoded;
        for my $v (@$data) {
            push @encoded, $self->_decode($v);
        }
        return \@encoded;
    }

    if (defined $data) {
        return decode($req_encoding, $data);
    }

    undef;
}

__END__