File Coverage

blib/lib/Mojolicious/Plugin/RESTful.pm

Criterion	Covered	Total	%
statement	59	60	98.3
branch	18	24	75.0
condition	11	13	84.6
subroutine	7	7	100.0
pod	1	1	100.0
total	96	105	91.4

package Mojolicious::Plugin::RESTful;
use Mojo::Base 'Mojolicious::Plugin';
use Mojo::Exception;
use Mojo::Util qw(decamelize);
use List::Util qw(any);
use Lingua::EN::Inflect 'PL';

our $VERSION = '0.1.4'; # VERSION
# ABSTRACT: A Mojolicious Plugin for RESTful HTTP Actions



has crud2http => sub {
  {
    collection => {
      list => 'get',
      create => 'post',
      options => 'options',
    },
    resource => {
      retrieve => 'get',
      update => 'put',
      delete => 'delete',
      patch => 'patch',
      options => 'options',
    },
    nonresource => {
      search => 'get',
      count => 'get',
    }
  }
};


sub register {
  my ($self, $app) = @_;
  $app->routes->add_shortcut(
    restful => sub {
      my $route = shift;
      my $prefix = $route->name ? $route->name.'_' : '';

      # params to hash
      my $params = { @_ ? ( ref $_[0] ? %{ $_[0] } : @_ eq 1 ? (name => $_[0]) : @_ ) : () };

      Mojo::Exception->throw('Route name is required in rest') unless defined $params->{name};
      # name setting
      my $route_name = lc $params->{name}; # must be lower case.
      my $route_plural = PL( $route_name );
      my $root_methods = $params->{root} // "lcrudpo";

      # Controller
      my $controller = $params->{controller} // ucfirst($route_name);

      # Non-resource routes
      my $nonresource = $params->{nonresource} // $self->crud2http->{nonresource};

      if (($route ne $route->root) and $root_methods =~/\A[lcrudpo]+\z/) {
        my %methods = map { lc($_) => 1 } split //, $root_methods;
        $route->root->restful(
          name => $route_name,
          methods => $root_methods,
          controller => $controller,
          nonresource => $nonresource,
          root => ''
        );
      }

      my %methods = map { lc($_) => 1 } split //, ($params->{methods} // "lcrudpo");

      foreach my $collection_method (sort keys %{$self->crud2http->{collection}}) {
        next unless $methods{substr($collection_method, 0, 1)};
        my $http = $self->crud2http->{collection}->{$collection_method};
        my $url = "/$route_plural";
        my $action = $prefix . $route_plural . '_' . $collection_method;
        next if $route->find($action);
        $route->route($url)->via($http)->to(
          controller => $controller, action => $action
        )->name($action);
      }

      foreach my $nonresource_method (sort keys %{$nonresource}) {
        my $http = $nonresource->{$nonresource_method};
        my $url = "/$route_plural/$nonresource_method";
        my $action = $prefix . $route_plural . '_' . $nonresource_method;
        next if $route->find($action);
        $route->route($url)->via($http)->to(
          controller => $controller, action => $action
        )->name($action);
      };

      for my $resource_method (sort keys %{$self->crud2http->{resource}}) {
        next unless $methods{substr($resource_method, 0, 1)};
        my $http = $self->crud2http->{resource}->{$resource_method};
        my $url = "/$route_plural/:$route_name";
        my $action = $prefix . $route_name . '_' . $resource_method;
        next if $route->find($action);
        $route->route($url)->via($http)->to(
          controller => $controller, action => $action
        )->name($action);
      }

      # Return chained route.
      if (any { /[rudp]/ } keys %methods) {
        return $route->route("/$route_plural/:$route_name")->name("$prefix$route_name");
      } else {
        return $route->route("/$route_plural")->name("$prefix$route_plural");
      }
    }
  );
}
1;

__END__