File Coverage

blib/lib/Mojolicious/Plugin/Tables.pm

Criterion	Covered	Total	%
statement	88	100	88.0
branch	11	18	61.1
condition	12	22	54.5
subroutine	9	11	81.8
pod	1	1	100.0
total	121	152	79.6

package Mojolicious::Plugin::Tables;
use Mojo::Base 'Mojolicious::Plugin';

use File::Basename 'dirname';
use File::Spec::Functions 'catdir';

use Mojolicious::Plugin::Tables::Model;

our $VERSION = '1.06';

sub register {
    my ($self, $app, $conf) = @_;

    my $log = $app->log;

    $app->helper(add_stash => sub {
        my ($c, $slot, $val) = @_;
        push @{$c->stash->{$slot} ||= []}, $val;
    });

    $app->helper(add_flash => sub {
        my ($c, $slot, $val) = @_;
        push @{$c->session->{new_flash}{$slot} ||= []}, $val;
    });

    $app->helper(shipped => sub {
        # special stash slot for sending json-able structs to js;
        # get/set logic here cloned from Mojo::Util::_stash.
        my $c = shift;
        my $shipped = $c->stash->{shipped} ||= {};
        return $shipped unless @_;
        return $shipped->{$_[0]} unless @_>1 || ref $_[0];
        my $values = ref $_[0]? $_[0] : {@_};
        @$shipped{keys %$values} = values %$values;
    });

    $app->config(default_theme=>'redmond');
    $app->defaults(layout => $conf->{layout} || 'tables');

    my $model_class = $conf->{model_class} ||= 'Mojolicious::Plugin::Tables::Model';
    eval "require $model_class" or die;

    $model_class->log($log);
    my $schema = $model_class->setup($conf);
    my $model = $schema->model;
    $app->config(model=>$model);

    $app->hook(before_dispatch => sub {
        my $c = shift;
        # Move first part and slash from path to base path when deployed under a path
        if ($c->req->headers->to_string =~ /X-Forwarded/) {
            my $part0 = shift @{$c->req->url->path->leading_slash(0)};
            push @{$c->req->url->base->path->trailing_slash(0)}, $part0;
            $c->shipped(urlbase => $c->req->url->base);
        } else {
            $c->shipped(urlbase => '');
        }
        # capture https into base
        if ($c->req->headers->header('X-Forwarded-HTTPS')
        || ($c->req->headers->header('X-Forwarded-Proto')||'') eq 'https') {
            $c->req->url->base->scheme('https')
        }
    });

    my $plugin_resources = catdir dirname(__FILE__), 'Tables', 'resources';
    push @{$app->routes->namespaces}, 'Mojolicious::Plugin::Tables::Controller';
    push @{$app->renderer->paths}, catdir($plugin_resources, 'templates');
    push @{$app->static->paths},   catdir($plugin_resources, 'public');

    # Arrange for custom table-specific template overrides, when present.
    # We do this by wrapping the standard ep-handler with a
    # pre-processor to test for existence of the custom template.
    # Any internal caching by EP renderer is preserved even for overrides.

    my $handlers = $app->renderer->handlers;
    my $base_ep  = $handlers->{ep};
    $handlers->{ep} = sub {
        my ($renderer, $c, $output, $options) = @_;
        {
            my $table           = $c->stash('table') || last;
            my $custom_template = "$table/$options->{template}";
            my $custom_path     = $renderer->template_path ({%$options,
                                             template=>$custom_template}) || last;
            $options->{template} = $custom_template;
            $log->debug("custom 'tables' template at $custom_path") if $ENV{TABLES_DEBUG};
        }
        $base_ep->(@_)
    };

    my $r = $app->routes;
    $r->get('/' => sub{shift->redirect_to('tables')}) unless $conf->{nohome};

    my @crud_gets  = (qw/view edit del nuke navigate/);
    my @crud_posts = (qw/save/);
    my $fmts       = [format=>[qw/html json/]];

    for ($r->under('tables')                          ->to('auth#ok'   )) {
        for ($_->under()                              ->to('tables#ok' )) {
            $_->get                                   ->to('#page'     );
            for ($_->under(':table')                  ->to('#table_ok' )) {
                $_->any('/'=>$fmts)                   ->to('#table', format=>'html' );
                $_->get('add')                        ->to('#add'      );
                $_->post('save')                      ->to('#save'     );
                for ($_->under(':id')                 ->to('#id_ok'    )) {
                    my $r = $_;
                    $r->get( $_=>$fmts)               ->to("#$_", format=>'html') for @crud_gets;
                    $r->post($_=>$fmts)               ->to("#$_", format=>'html') for @crud_posts;
                    $r->get('add_child/:child'=>$fmts)->to('#view', format=>'html'     );
                    $r->any(':children'=>$fmts)       ->to('#children', format=>'html' );
                }
            }
        }
    }

    my @tablist = @{$model->{tablist}};
    $log->info ("'Tables' Framework enabled.");
    $log->debug("Route namespaces are..");
    $log->debug("--> $_") for @{$app->routes->namespaces};
    $log->debug("Renderer paths are..");
    $log->debug("--> $_") for @{$app->renderer->paths};
    $log->debug("Static paths are..");
    $log->debug("--> $_") for @{$app->static->paths};
    $log->info ("/tables routes are in place. ".scalar(@tablist)." tables available");
    $log->debug("--> $_") for @tablist;

    $log->debug($app->dumper($model)) if $ENV{TABLES_DEBUG};

}

1;
__END__