File Coverage

blib/lib/Router/Pygmy.pm

Criterion	Covered	Total	%
statement	60	62	96.7
branch	18	22	81.8
condition	5	8	62.5
subroutine	10	10	100.0
pod	5	6	83.3
total	98	108	90.7

package Router::Pygmy;
$Router::Pygmy::VERSION = '0.04';
use strict;
use warnings;

# ABSTRACT: ultrasimple path router matching paths to names and args


use Carp;
use Router::Pygmy::Route;

my ( $PATH_PART_IDX, $ARG_IDX, $ROUTE_IDX ) = 0 .. 2;

sub new {
    my $class  = shift;
    my $router = bless(
        {
            lookup    => [],
            route_for => {},
        },
        $class
    );
    if (@_) {

        # so far only
        # routes => \%routes
        # or
        # { routes => \%routes }
        # is allowed
        my %args = ref $_[0] && ref $_[0] eq 'HASH' ? %{ $_[0] } : @_;

        if ( my $routes = $args{routes} ) {
            for my $spec ( keys %$routes ) {
                $router->add_route( $spec, $routes->{$spec} );
            }
        }
    }

    return $router;
}

sub new_route {
    my $this = shift;
    return Router::Pygmy::Route->parse(@_);
}

sub add_route {
    my ( $this, $spec, $name ) = @_;

    if ( my $duplicit_route = $this->{route_for}{$name} ) {
        croak sprintf "Duplicit routes for '$name' ('%s', '%s')",
          $duplicit_route->spec, $spec;
    }

    my $route  = $this->new_route($spec);
    my $lookup = $this->{lookup};
    for my $part ( @{ $route->parts } ) {
        $lookup = (
            defined($part)
            ? $lookup->[$PATH_PART_IDX]{$part}
            : $lookup->[$ARG_IDX]
        ) ||= [];
    }

    if ( my $duplicit_name = $lookup->[$ROUTE_IDX] ) {
        my $duplicit_route = $this->{route_for}{$duplicit_name};
        croak sprintf "Identical routes '%s', '%s'",
          $duplicit_route->spec, $route->spec;
    }

    $lookup->[$ROUTE_IDX] = $name;
    $this->{route_for}{$name} = $route;
    return $route;
}

# uri for
sub path_for {
    my $this = shift;
    my $name = shift;

    my $route = $this->{route_for}{$name}
      or croak "No route '$name'";
    return $route->path_for(@_);
}

# return (name, \@args)
sub match {
    my ( $this, $path ) = @_;

    my @parts = grep { $_ } split m{/}, $path;
    my @args;

    my $lookup = $this->{lookup};

    while (@parts) {
        my $part = shift @parts;

        if ( my $by_path_part = $lookup->[$PATH_PART_IDX]{$part} ) {
            $lookup = $by_path_part;
        }
        elsif ( my $by_arg = $lookup->[$ARG_IDX] ) {
            push @args, $part;
            $lookup = $by_arg;
        }
        else {
            return;
        }
    }

    my $name = $lookup && $lookup->[$ROUTE_IDX];
    return $name ? ( $name, \@args ) : ();
}

sub match_named {
    my $this = shift;

    my ($name, $args) = $this->match(@_) or return;
    my $route = $this->{route_for}{$name};
    my $names = $route->arg_names;
    my $i = 0;
    return ( $name, [ map { ($names->[$i++] => $_) } @$args ]);
}

1;
# vim: expandtab:shiftwidth=4:tabstop=4:softtabstop=0:textwidth=78:

__END__