File Coverage

blib/lib/Minima/App.pm

Criterion	Covered	Total	%
statement	31	31	100.0
branch	4	4	100.0
condition			n/a
subroutine	10	10	100.0
pod			n/a
total	45	45	100.0

use v5.40;
use experimental 'class';

class Minima::App;

use Carp;
use Minima::Router;
use Path::Tiny ();
use Plack::Response;
use Plack::Util;
use FindBin;

use constant DEFAULT_VERSION => 'prototype';

field $env      :param(environment)   :reader = undef;
field $config   :param(configuration) :reader = {};

field $router = Minima::Router->new;

ADJUST {
    $self->_read_config;
}

method set_env      ($e) { $env = $e }
method set_config   ($c) { $config = $c; $self->_read_config }

method development
{
    return 1 if not defined $ENV{PLACK_ENV};

    $ENV{PLACK_ENV} eq 'development'
}

method path ($p)
{
    Path::Tiny::path($p)->absolute($config->{base_dir})->stringify;
}

method run
{
    croak "Can't run without an environment.\n" unless defined $env;

    my $match = $router->match($env);
    my $response;
    my $controller;
    my $action;

    return $self->_not_found unless $match;
    return $self->_redirect($match) if $match->{redirect};

    try {
        ($controller, $action) = $self->_setup_controller($match);

        # before_action
        if ($controller->can('before_action')) {
            my $res = $controller->before_action($action);
            return $res if $res; # halt
        }
        # actual action
        $response = $controller->$action;
        # after action
        if ($controller->can('after_action')) {
            $controller->after_action($response);
        }
    } catch ($e) {
        my $err = $router->error_route;
        # Something failed. If we're in production
        # and there is a server_error route, try it.
        if (!$self->development && $err) {
            ($controller, $action) = $self->_setup_controller($err);
            $response = $controller->$action($e);
        } else {
            # Nothing can be done, re-throw
            die $e;
        }
    }

    # Delete body on HEAD requests
    my $auto_head = $config->{automatic_head} // 1;
    if (   $auto_head
        && length $env->{REQUEST_METHOD}
        && $env->{REQUEST_METHOD} eq 'HEAD'
    ) {
        return Plack::Util::response_cb($response, sub {
            my $res = shift;
            if ($res->[2]) {
                $res->[2] = [];
            } else {
                return sub { defined $_[0] ? '' : undef };
            }
        });
    }

    return $response;
}

method _setup_controller ($match)
{
    my $class  = $match->{controller};
    my $method = $match->{action};

    die "Route dispatch failed: "
        . "no controller defined for `$env->{PATH_INFO}`.\n"
        unless defined $class;

    die "Route dispatch failed: no action configured for `$class`.\n"
        unless defined $method && length $method;

    $self->_load_class($class);

    my $controller = $class->new(
        app   => $self,
        route => $match,
    );

    die "Route dispatch failed: `$class` does not implement action `$method`.\n"
        unless $controller->can($method);

    ( $controller, $method );
}

method _not_found
{
    [
        404,
        [ 'Content-Type' => 'text/plain' ],
        [ "not found\n" ]
    ]
}

method _load_class ($class)
{
    try {
        my $file = $class;
        $file =~ s|::|/|g;
        require "$file.pm";
    } catch ($e) {
        croak "Could not load `$class`: $e\n";
    }
}

method _load_routes
{
    $router->clear_routes;

    my $file = $config->{routes};
    unless (defined $file) {
        # No file passed. Attempt the default route.
        $file = $self->path('etc/routes.map');
        # If it does not exist, setup a basic route
        # for the default controller only.
        unless (-e $file) {
            $router->_connect(
                '/',
                {
                    controller => 'Minima::Controller',
                    action => 'hello',
                },
            );
            return;
        }
    }

    # Controller prefix
    my $prefix = $config->{controller_prefix};
    $router->set_prefix($prefix) if defined $prefix;

    # Read routes
    $file = $self->path($file);
    $router->read_file($file);
}

method _redirect ($m)
{
    my $res = Plack::Response->new;

    $res->redirect($m->{redirect}, $m->{redirect_status});
    $res->finalize;
}

method _read_config
{
    # Ensure base_dir is set and absolute
    my $base = $config->{base_dir} // '.';
    $config->{base_dir} = Path::Tiny::path($base)->absolute;

    $self->_load_routes;
    $self->_set_version;
}

method _set_version
{
    return if defined $config->{VERSION};

    if (defined $config->{version_from}) {
        my $class = $config->{version_from};
        try {
            $self->_load_class($class);
        } catch ($e) {
            croak "Failed to load version from class.\n$e\n";
        }
        $config->{VERSION} = $class->VERSION // DEFAULT_VERSION;
    } else {
        $config->{VERSION} = DEFAULT_VERSION;
    }
}

__END__