File Coverage

blib/lib/Raisin/Routes.pm

Criterion	Covered	Total	%
statement	56	63	88.8
branch	13	18	72.2
condition	5	11	45.4
subroutine	10	10	100.0
pod	2	3	66.6
total	86	105	81.9

#!perl
#PODNAME: Raisin::Routes
#ABSTRACT: A routing class for Raisin.

use strict;
use warnings;

package Raisin::Routes;
$Raisin::Routes::VERSION = '0.94';
use Carp;
use Plack::Util::Accessor qw(
    cache
    list
    routes
);

use Raisin::Param;
use Raisin::Routes::Endpoint;
use Raisin::Util;

sub new {
    my $class = shift;
    my $self = bless { id => rand() }, $class;

    $self->cache({});
    $self->list({});
    $self->routes([]);

    $self;
}

sub add {
    my ($self, %params) = @_;

    my $method = uc $params{method};
    my $path = $params{path};

    if (!$method || !$path) {
        carp "Method and path are required";
        return;
    }

    my $code = $params{code};
    # Supports only CODE as route destination
    if (!$code || !(ref($code) eq 'CODE')) {
        carp "Invalid route params for $method $path";
        return;
    }

    my @pp;
    for my $key (qw(params named)) {
        my $next_param = Raisin::Util::iterate_params($params{$key} || []);
        while (my ($type, $spec) = $next_param->()) {
            last unless $type;

            push @pp, Raisin::Param->new(
                named => $key eq 'named',
                type => $type, # -> requires/optional
                spec => $spec, # -> { name => ..., type => ... }
            );
        }
    }

    if (ref($path) && ref($path) ne 'Regexp') {
        print STDERR "Route `$path` should be SCALAR or Regexp\n";
        return;
    }

    # Cut off the last slash from a path
    $path =~ s#(.+)/$#$1# if !ref($path);

    my $ep = Raisin::Routes::Endpoint->new(
        code => $code,
        method => $method,
        params => \@pp,
        path => $path,

        desc => $params{desc},
        entity => $params{entity},
        summary => $params{summary},
        tags => $params{tags},
        produces => $params{produces},
    );
    push @{ $self->{routes} }, $ep;

    if ($self->list->{$path}{$method}) {
        Raisin::log(warn => "route has been redefined: $method $path");
    }

    $self->list->{$path}{$method} = scalar @{ $self->{routes} };
}

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

    my $cache_key = lc "$method:$path";
    my $routes
        = exists $self->cache->{$cache_key}
        ? $self->cache->{$cache_key}
        : $self->routes;

    my @found = grep { $_->match($method, $path) } @$routes or return;

    if (scalar @found > 1) {
        Raisin::log(warn => "more then one route has been found: $method $path");
    }

    $self->cache->{$cache_key} = \@found;
    $found[0];
}

1;

__END__