File Coverage

blib/lib/Routes/Tiny.pm

Criterion	Covered	Total	%
statement	64	67	95.5
branch	15	18	83.3
condition	2	3	66.6
subroutine	10	10	100.0
pod	5	5	100.0
total	96	103	93.2

package Routes::Tiny;

use strict;
use warnings;

require Carp;
require Scalar::Util;
use Routes::Tiny::Pattern;

our $VERSION = 0.21;

sub new {
    my $class = shift;
    my (%params) = @_;

    my $self = {};
    bless $self, $class;

    $self->{strict_trailing_slash} = $params{strict_trailing_slash};
    $self->{strict_case} = $params{strict_case};
    $self->{default_method} = $params{default_method};

    $self->{parent_pattern}        = undef;
    $self->{patterns}              = [];
    $self->{names}                 = {};
    $self->{strict_trailing_slash} = 1
      unless defined $self->{strict_trailing_slash};
    $self->{strict_case} = 1
      unless defined $self->{strict_case};

    return $self;
}

sub add_route {
    my $self = shift;

    my $pattern = $self->_build_pattern(@_);

    push @{$self->{patterns}}, $pattern;

    $self->_register_pattern_name($pattern) if $pattern->{name};

    return $pattern;
}

sub mount {
    my $self = shift;
    my ($pattern, $routes, @args) = @_;

    $pattern = $self->add_route($pattern, subroutes => $routes, @args);
    $routes->{parent_pattern} = $pattern;
    $self->_register_pattern_name($_) for values %{ $routes->{names} };
    Scalar::Util::weaken($routes->{parent_pattern});
    return $pattern;
}

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

    foreach my $pattern (@{$self->{patterns}}) {
        if (my $m = $pattern->match($path, @args)) {
            return $m;
        }
    }

    return;
}

sub build_path {
    my $self = shift;
    my ($name, @args) = @_;

    my $pattern = $self->{names}->{$name};

    return $pattern->build_path(@args) if $pattern;

    Carp::croak("Unknown name '$name' used to build a path");
}

sub _register_pattern_name {
    my $self = shift;
    my ($pattern) = @_;

    my $name = $pattern->name;
    if (exists $self->{names}->{ $name }) {
        Carp::carp("pattern name '$name' already used");
    }
    else {
        $self->{names}->{ $name } = $pattern;
        my $parent_routes = $self->{parent_pattern} && $self->{parent_pattern}->{routes};
        if ($parent_routes) {
            $parent_routes->_register_pattern_name(@_);
        }
    }
}

sub _build_pattern {
    my $self = shift;

    if (@_ % 2) {
        unshift(@_, 'pattern');
    } else {
        my $method  = shift;
        my $pattern = shift;

        if ($method =~ /^(GET|HEAD|POST|PUT|DELETE|TRACE|OPTIONS|CONNECT|PATCH)$/i) {
            unshift(@_, pattern => $pattern);
            unshift(@_, method  => $method);
        } else {
            Carp::croak("Unknown pattern http method '$_[0]'");
        }
    }

    return Routes::Tiny::Pattern->new(
        strict_trailing_slash => $self->{strict_trailing_slash},
        strict_case           => $self->{strict_case},
        default_method        => $self->{default_method},
        routes                => $self,
        @_
    )
}

1;
__END__