File Coverage

blib/lib/Plack/Middleware/REST.pm

Criterion	Covered	Total	%
statement	64	64	100.0
branch	27	32	84.3
condition	10	22	45.4
subroutine	9	9	100.0
pod	2	2	100.0
total	112	129	86.8

package Plack::Middleware::REST;
use strict;
use warnings;

our $VERSION = '0.10';

use Carp qw(croak);
use Scalar::Util qw(reftype);

use parent 'Plack::Middleware';
use Plack::Util::Accessor
    qw(get create upsert delete list head pass_through routes options patch patch_types);

use Plack::Middleware::Head;

sub prepare_app {
    my ($self) = @_;

    $self->pass_through(0) unless defined $self->pass_through;
    $self->head(1) unless defined $self->head;
    $self->options(1) unless defined $self->options;

    $self->routes({
        resource   => {
            GET    => 'get',
            PUT    => 'upsert',
            DELETE => 'delete',
            PATCH  => 'patch',
        },
        collection => {
            GET    => 'list',
            POST   => 'create',
        },
    });

    if ($self->head) {
        $self->routes->{resource}->{HEAD} = 'get';
        $self->routes->{collection}->{HEAD} = 'list';
    }

    if ($self->options) {
        $self->routes->{resource}->{OPTIONS} = 'get';
        $self->routes->{collection}->{OPTIONS} = 'list';
    }

    foreach my $action (qw(get create upsert delete list patch))  {
        my $app = $self->{$action};

        # alias
        $self->{$action} = $self->{$app} if $app and !ref $app;

        croak "PSGI application '$action' must be code reference"
            if $self->{action} and (reftype($self->{$action}) || '') ne 'CODE';
    }

    while (my ($type, $route) = each %{$self->routes}) {
        $self->{allow}->{$type} = join ', ',
            sort grep { $self->{ $route->{$_} } } keys %$route;
        foreach my $method (keys %$route) {
            $route->{$method} = $self->{ $route->{$method} };
        }
        if ($self->head eq 'auto') {
            $route->{HEAD} = Plack::Middleware::Head->wrap($route->{HEAD});
        }
    }
}

sub call {
    my ($self, $env) = @_;

    my $type   = ($env->{PATH_INFO} || '/') eq '/' ? 'collection' : 'resource';
    my $method = $env->{REQUEST_METHOD};

    if ($method eq 'OPTIONS') {
        if ($self->options) {
            my %headers = ( 'Allow' => $self->{allow}->{$type} );
            if ($self->patch() && $self->patch_types()) {
                $headers{'Accept-Patch'} = join( ',', @{$self->patch_types()} );
            }
            [ 200, [ %headers ], [] ];
        } else {
            [ 405, [ Allow => $self->{allow}->{$type} ?  $self->{allow}->{$type} : 'GET' ],
                   ['Method Not Allowed'] ];
        }
    } else {
        my $app = $self->routes->{$type}->{$method};
        $app ||= $self->{app} if $self->pass_through;
        if ( $app ) {
            if (($method eq 'PATCH') && ($self->patch_types())
                    && ! grep { /^$env->{'CONTENT_TYPE'}$/msx } @{$self->patch_types()} ) {
                [ 415, [], ['Unknown Patch Type'] ];
            } else {
                $app->($env);
            }
        } else {
            [ 405, [ Allow => $self->{allow}->{$type} ], ['Method Not Allowed'] ];
        }
    }
}

1;
__END__