File Coverage

blib/lib/Mojolicious/Plugin/Tables.pm

Criterion	Covered	Total	%
statement	86	98	87.7
branch	11	18	61.1
condition	12	22	54.5
subroutine	9	11	81.8
pod	1	1	100.0
total	119	150	79.3

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.05';

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/];

    for ($r->under('tables')                   ->to('auth#ok'   )) {
        for ($_->under()                       ->to('tables#ok' )) {
            $_->get                            ->to('#page'     );
            for ($_->under(':table')           ->to('#table_ok' )) {
                $_->any                        ->to('#table'    );
                $_->get('add')                 ->to('#add'      );
                $_->post('save')               ->to('#save'     );
                for ($_->under(':id')          ->to('#id_ok'    )) {
                    $_->get(':action'=>[action=>$crud_gets]     );
                    $_->post(':action'=>[action=>$crud_posts]   );
                    $_->get('add_child/:child')->to('#view'     );
                    $_->any(':children')       ->to('#children' );
                }
            }
        }
    }

    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__