File Coverage

lib/Mojolicious/Plugin/Route.pm

Criterion	Covered	Total	%
statement	93	94	98.9
branch	32	42	76.1
condition	10	15	66.6
subroutine	16	16	100.0
pod	1	1	100.0
total	152	168	90.4

package Mojolicious::Plugin::Route;

use Mojo::Base 'Mojolicious::Plugin';
use Mojo::Util 'camelize';
use Mojo::Loader 'load_class';
use Carp;

use constant BASE => {
    files      => [],
    references => {}
};

our $VERSION = '0.09';

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

    my ($moniker, $moniker_path) = $self->_get_moniker($app, $conf);
    my $namespace                = $conf->{namespace} // 'Route';
    my $inverse                  = $conf->{inverse} // undef;
    my $path_routes              = $app->home . '/lib/' . $moniker_path;

    croak "Routes path ($path_routes) does not exist!" unless -d $path_routes;

    $path_routes =~ s/\/$//;
    $path_routes .= '/' . $namespace;

    croak "Namespace ($namespace) does not exist!" unless -d $path_routes;

    $self->_find_files($path_routes);

    $self->_load_routes($app, $moniker, $namespace, $inverse);

    $self->_clean_base;
}

sub _find_files {
    my ($self, $path, $find) = @_;

    my $more;
    $find ||= '';

    # find files and folders
    for my $file ( glob($path . '/*' . $find) ) {
        if (-d $file) {
            $more = '/*';

            next;
        }

        push(@{BASE->{files}}, $1) if $file =~ /\/lib\/([\w\/]+)\.pm$/;
    }

    if ($more) {
        $find .= $more;
        $self->_find_files($path, $find);
    }
}

sub _load_routes {
    my ($self, $app, $moniker, $namespace, $inverse) = @_;

    my $base = $moniker . '::' . $namespace;

    my $routes = $app->routes;

    for my $file (@{BASE->{files}}) {
        $file =~ s/\//::/g;

        my $class = $self->_load_class($file);

        if ($class && $class->isa('MojoX::Route')) {
            my $ref = $class->new(app => $app);

            $self->_any($routes, $ref, $file, $base, $inverse)   if $class->can('any');
            $self->_under($routes, $ref, $file, $base, $inverse) if $class->can('under');
            $self->_route($routes, $ref, $file, $base, $inverse) if $class->can('route');
        }
    }
}

sub _clean_base {
    @{BASE->{files}} = ();
    %{BASE->{references}} = ();
}

sub _any {
    my ($self, $routes, $ref, $file, $base, $inverse) = @_;

    my ($name, $ref_name) = $self->_ref_name($file, $base);

    my @params;
    push(@params, BASE->{references}->{$ref_name}) if $self->_valid_reference($ref_name);
    push(@params, $routes);

    my $any = $ref->any($inverse ? reverse(@params) : @params);

    BASE->{references}->{$name} = $any if $any;
}

sub _under {
    my ($self, $routes, $ref, $file, $base, $inverse) = @_;

    my ($name, $ref_name) = $self->_ref_name($file, $base);

    my @params;
    push(@params, BASE->{references}->{$ref_name}) if $self->_valid_reference($ref_name);
    push(@params, $routes);

    my $under = $ref->under($inverse ? reverse(@params) : @params);

    BASE->{references}->{$name} = $under if $under;
}

sub _route {
    my ($self, $routes, $ref, $file, $base, $inverse) = @_;

    my ($name, $ref_name) = $self->_ref_name($file, $base);

    my @params;
    push(@params, BASE->{references}->{$name})     if $self->_valid_reference($name);
    push(@params, BASE->{references}->{$ref_name}) if $self->_valid_reference($ref_name);
    push(@params, $routes);

    $ref->route($inverse ? reverse(@params) : @params);
}

sub _ref_name {
    my ($self, $name, $base) = @_;

    $name =~ s/${base}:://;
    my ($ref_name) = $name =~ /^([\w:]+)::\w+$/;

    return ($name, $ref_name);
}

sub _load_class {
    my ($self, $class) = @_;

    # load class
    my $e = load_class $class;

    return $class unless $e;

    return;
}

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

    # set path lib
    my $path = $app->home . '/lib/';

    # check if moniker is defined
    return ($conf->{moniker}, $conf->{moniker}) if $conf->{moniker} && -d $path . $conf->{moniker};

    # check if need camelize moniker
    my $moniker = camelize($app->moniker);

    # generate moniker path
    my $moniker_path = $moniker;
    $moniker_path    =~ s/::/\//g;

    return ($app->moniker, $app->moniker) unless -d $path . $moniker_path;

    return ($moniker, $moniker_path);
}

sub _valid_reference {
    my ($self, $name) = @_;

    return $name && defined BASE->{references}->{$name};
}

1;

__END__