File Coverage

blib/lib/Router/Boom/Method.pm

Criterion	Covered	Total	%
statement	55	58	94.8
branch	12	12	100.0
condition	5	9	55.5
subroutine	11	12	91.6
pod	5	5	100.0
total	88	96	91.6

package Router::Boom::Method;
use strict;
use warnings;
use utf8;
use 5.008_005;

use Router::Boom;

our $VERSION = "1.01";

sub new {
    my $class = shift;
    my $self = bless {}, $class;
    return $self;
}

sub add {
    my ($self, $method, $path, $opaque) = @_;

    delete $self->{router}; # clear cache

    if (defined($method) && !ref($method)) {
        $method = [$method];
    }

    unless ($self->{path_seen}->{$path}++) {
        push @{$self->{path}}, $path;
    }
    push @{$self->{data}->{$path}}, [$method, $opaque];
}

sub routes {
    my $self = shift;

    my @routes;
    for my $path (@{$self->{path}}) {
        for my $route (@{$self->{data}->{$path}}) {
            my ($method, $opaque) = @$route;
            push @routes, [ $method, $path, $opaque ];
        }
    }
    return @routes;
}

sub _method_match {
    my ($request_method, $matcher) = @_;
    return 1 if not defined($matcher);

    for my $m (@$matcher) {
        return 1 if $m eq $request_method;
    }
    return 0;
}

sub match {
    my ($self, $request_method, $path) = @_;

    $self->{router} ||= $self->_build_router();

    if (my ($patterns, $captured) = $self->{router}->match($path)) {
        for my $pattern (@$patterns) {
            if (_method_match($request_method, $pattern->[0])) {
                return ($pattern->[1], $captured, 0);
            }
        }
        return (undef, undef, 1);
    } else {
        return;
    }
}

sub regexp {
    my $self = shift;
    $self->{router} ||= $self->_build_router();
    $self->{router}->regexp;
}

sub _build_router {
    my ($self) = @_;
    my $router = Router::Boom->new();
    for my $path (@{$self->{path}}) {
        $router->add($path, $self->{data}->{$path});
    }
    $router;
}

1;
__END__