File Coverage

blib/lib/Path/Dispatcher/Rule/Under.pm

Criterion	Covered	Total	%
statement	22	35	62.8
branch	3	8	37.5
condition	3	3	100.0
subroutine	5	6	83.3
pod	1	2	50.0
total	34	54	62.9

package Path::Dispatcher::Rule::Under;
# ABSTRACT: rules under a predicate

our $VERSION = '1.07';

use Moo;
use Type::Tiny;
use Type::Utils qw(class_type);

extends 'Path::Dispatcher::Rule';
with 'Path::Dispatcher::Role::Rules';

my $PREFIX_RULE_TYPE = "Type::Tiny"->new(
    name       => "PrefixRule",
    parent     => class_type("Path::Dispatcher::Rule"),
    constraint => sub { return ( shift()->prefix ) ? 1 : 0 },
    message    => sub { "This rule ($_) does not match just prefixes!" },
);

has predicate => (
    is  => 'ro',
    isa => $PREFIX_RULE_TYPE
);

sub match {
    my $self = shift;
    my $path = shift;

    my $prefix_match = $self->predicate->match($path)
        or return;

    my $leftover = $prefix_match->leftover;
    $leftover = '' if !defined($leftover);

    my $new_path = $path->clone_path($leftover);

    # Pop off @matches until we have a last rule that is not ::Chain
    #
    # A better technique than isa might be to use the concept of 'endpoint', 'midpoint', or 'anypoint' rules and
    # add a method to ::Rule that lets evaluate whether any rule is of the right kind (i.e. ->is_endpoint)
    #
    # Because the checking for ::Chain endpointedness is here, this means that outside of an ::Under, ::Chain behaves like
    # an ::Always (one that will always trigger next_rule if it's block is ran)
    #
    my @matches = map {
        $_->match(
            $new_path,
            extra_constructor_args => {
                parent => $prefix_match,
            },
        )
    } $self->rules;
    pop @matches while @matches && $matches[-1]->rule->isa('Path::Dispatcher::Rule::Chain');
    return @matches;
}

sub complete {
    my $self = shift;
    my $path = shift;

    my $predicate = $self->predicate;

    my $prefix_match = $predicate->match($path)
        or return $predicate->complete($path);

    my $new_path = $path->clone_path($prefix_match->leftover);

    my $prefix = substr($path->path, 0, length($path->path) - length($new_path->path));

    my @completions = map { $_->complete($new_path) } $self->rules;

    if ($predicate->can('untokenize')) {
        return map { $predicate->untokenize($prefix, $_) } @completions;
    }
    else {
        return map { "$prefix$_" } @completions;
    }
}

__PACKAGE__->meta->make_immutable;
no Moo;

1;

__END__