Provided by: libcatalyst-action-rest-perl_1.21-2_all bug

NAME

       Catalyst::Controller::REST - A RESTful controller

SYNOPSIS

           package Foo::Controller::Bar;
           use Moose;
           use namespace::autoclean;

           BEGIN { extends 'Catalyst::Controller::REST' }

           sub thing : Local : ActionClass('REST') { }

           # Answer GET requests to "thing"
           sub thing_GET {
              my ( $self, $c ) = @_;

              # Return a 200 OK, with the data in entity
              # serialized in the body
              $self->status_ok(
                   $c,
                   entity => {
                       some => 'data',
                       foo  => 'is real bar-y',
                   },
              );
           }

           # Answer PUT requests to "thing"
           sub thing_PUT {
               my ( $self, $c ) = @_;

               $radiohead = $c->req->data->{radiohead};

               $self->status_created(
                   $c,
                   location => $c->req->uri,
                   entity => {
                       radiohead => $radiohead,
                   }
               );
           }

DESCRIPTION

       Catalyst::Controller::REST implements a mechanism for building RESTful services in
       Catalyst.  It does this by extending the normal Catalyst dispatch mechanism to allow for
       different subroutines to be called based on the HTTP Method requested, while also
       transparently handling all the serialization/deserialization for you.

       This is probably best served by an example.  In the above controller, we have declared a
       Local Catalyst action on "sub thing", and have used the ActionClass('REST').

       Below, we have declared "thing_GET" and "thing_PUT".  Any GET requests to thing will be
       dispatched to "thing_GET", while any PUT requests will be dispatched to "thing_PUT".

       Any unimplemented HTTP methods will be met with a "405 Method Not Allowed" response,
       automatically containing the proper list of available methods.  You can override this
       behavior through implementing a custom "thing_not_implemented" method.

       If you do not provide an OPTIONS handler, we will respond to any OPTIONS requests with a
       "200 OK", populating the Allowed header automatically.

       Any data included in "$c->stash->{'rest'}" will be serialized for you.  The serialization
       format will be selected based on the content-type of the incoming request.  It is probably
       easier to use the "STATUS HELPERS", which are described below.

       "The HTTP POST, PUT, and OPTIONS methods will all automatically deserialize the contents
       of "$c->request->body" into the "$c->request->data" hashref", based on the request's
       "Content-type" header. A list of understood serialization formats is below.

       If we do not have (or cannot run) a serializer for a given content-type, a 415
       "Unsupported Media Type" error is generated.

       To make your Controller RESTful, simply have it

         BEGIN { extends 'Catalyst::Controller::REST' }

CONFIGURATION

       See "CONFIGURATION" in Catalyst::Action::Serialize. Note that the "serialize" key has been
       deprecated.

SERIALIZATION

       Catalyst::Controller::REST will automatically serialize your responses, and deserialize
       any POST, PUT or OPTIONS requests. It evaluates which serializer to use by mapping a
       content-type to a Serialization module.  We select the content-type based on:

       The Content-Type Header
           If the incoming HTTP Request had a Content-Type header set, we will use it.

       The content-type Query Parameter
           If this is a GET request, you can supply a content-type query parameter.

       Evaluating the Accept Header
           Finally, if the client provided an Accept header, we will evaluate it and use the
           best-ranked choice.

AVAILABLE SERIALIZERS

       A given serialization mechanism is only available if you have the underlying modules
       installed.  For example, you can't use XML::Simple if it's not already installed.

       In addition, each serializer has its quirks in terms of what sorts of data structures it
       will properly handle.  Catalyst::Controller::REST makes no attempt to save you from
       yourself in this regard. :)

       • "text/x-yaml" => "YAML::Syck"

         Returns YAML generated by YAML::Syck.

       • "text/html" => "YAML::HTML"

         This uses YAML::Syck and URI::Find to generate YAML with all URLs turned to hyperlinks.
         Only usable for Serialization.

       • "application/json" => "JSON"

         Uses JSON to generate JSON output.  It is strongly advised to also have JSON::XS
         installed.  The "text/x-json" content type is supported but is deprecated and you will
         receive warnings in your log.

         You can also add a hash in your controller config to pass options to the json object.
         There are two options. "json_options" are used when decoding incoming JSON, and
         "json_options_encode" is used when encoding JSON for output.

         For instance, to relax permissions when deserializing input, add:

           __PACKAGE__->config(
             json_options => { relaxed => 1 }
           )

         To indent the JSON output so it becomes more human readable, add:

           __PACKAGE__->config(
             json_options_encode => { indent => 1 }
           )

       • "text/javascript" => "JSONP"

         If a callback=? parameter is passed, this returns javascript in the form of:
         $callback($serializedJSON);

         Note - this is disabled by default as it can be a security risk if you are unaware.

         The usual MIME types for this serialization format are: 'text/javascript',
         'application/x-javascript', 'application/javascript'.

       • "text/x-data-dumper" => "Data::Serializer"

         Uses the Data::Serializer module to generate Data::Dumper output.

       • "text/x-data-denter" => "Data::Serializer"

         Uses the Data::Serializer module to generate Data::Denter output.

       • "text/x-data-taxi" => "Data::Serializer"

         Uses the Data::Serializer module to generate Data::Taxi output.

       • "text/x-config-general" => "Data::Serializer"

         Uses the Data::Serializer module to generate Config::General output.

       • "text/x-php-serialization" => "Data::Serializer"

         Uses the Data::Serializer module to generate PHP::Serialization output.

       • "text/xml" => "XML::Simple"

         Uses XML::Simple to generate XML output.  This is probably not suitable for any real
         heavy XML work. Due to XML::Simples requirement that the data you serialize be a
         HASHREF, we transform outgoing data to be in the form of:

           { data => $yourdata }

       • View

         Uses a regular Catalyst view.  For example, if you wanted to have your "text/html" and
         "text/xml" views rendered by TT, set:

           __PACKAGE__->config(
               map => {
                   'text/html' => [ 'View', 'TT' ],
                   'text/xml'  => [ 'View', 'XML' ],
               }
           );

         Your views should have a "process" method like this:

           sub process {
               my ( $self, $c, $stash_key ) = @_;

               my $output;
               eval {
                   $output = $self->serialize( $c->stash->{$stash_key} );
               };
               return $@ if $@;

               $c->response->body( $output );
               return 1;  # important
           }

           sub serialize {
               my ( $self, $data ) = @_;

               my $serialized = ... process $data here ...

               return $serialized;
           }

       • Callback

         For infinite flexibility, you can provide a callback for the
         deserialization/serialization steps.

           __PACKAGE__->config(
               map => {
                   'text/xml'  => [ 'Callback', { deserialize => \&parse_xml, serialize => \&render_xml } ],
               }
           );

         The "deserialize" callback is passed a string that is the body of the request and is
         expected to return a scalar value that results from the deserialization.  The
         "serialize" callback is passed the data structure that needs to be serialized and must
         return a string suitable for returning in the HTTP response.  In addition to receiving
         the scalar to act on, both callbacks are passed the controller object and the context
         (i.e. $c) as the second and third arguments.

       By default, Catalyst::Controller::REST will return a "415 Unsupported Media Type" response
       if an attempt to use an unsupported content-type is made.  You can ensure that something
       is always returned by setting the "default" config option:

         __PACKAGE__->config(default => 'text/x-yaml');

       would make it always fall back to the serializer plugin defined for "text/x-yaml".

CUSTOM SERIALIZERS

       Implementing new Serialization formats is easy!  Contributions are most welcome!  If you
       would like to implement a custom serializer, you should create two new modules in the
       Catalyst::Action::Serialize and Catalyst::Action::Deserialize namespace.  Then assign your
       new class to the content-type's you want, and you're done.

       See Catalyst::Action::Serialize and Catalyst::Action::Deserialize for more information.

STATUS HELPERS

       Since so much of REST is in using HTTP, we provide these Status Helpers.  Using them will
       ensure that you are responding with the proper codes, headers, and entities.

       These helpers try and conform to the HTTP 1.1 Specification.  You can refer to it at:
       <http://www.w3.org/Protocols/rfc2616/rfc2616.txt>.  These routines are all implemented as
       regular subroutines, and as such require you pass the current context ($c) as the first
       argument.

       status_ok
           Returns a "200 OK" response.  Takes an "entity" to serialize.

           Example:

             $self->status_ok(
               $c,
               entity => {
                   radiohead => "Is a good band!",
               }
             );

       status_created
           Returns a "201 CREATED" response.  Takes an "entity" to serialize, and a "location"
           where the created object can be found.

           Example:

             $self->status_created(
               $c,
               location => $c->req->uri,
               entity => {
                   radiohead => "Is a good band!",
               }
             );

           In the above example, we use the requested URI as our location.  This is probably what
           you want for most PUT requests.

       status_accepted
           Returns a "202 ACCEPTED" response.  Takes an "entity" to serialize.  Also takes
           optional "location" for queue type scenarios.

           Example:

             $self->status_accepted(
               $c,
               location => $c->req->uri,
               entity => {
                   status => "queued",
               }
             );

       status_no_content
           Returns a "204 NO CONTENT" response.

       status_multiple_choices
           Returns a "300 MULTIPLE CHOICES" response. Takes an "entity" to serialize, which
           should provide list of possible locations. Also takes optional "location" for
           preferred choice.

       status_found
           Returns a "302 FOUND" response. Takes an "entity" to serialize.  Also takes optional
           "location".

       status_bad_request
           Returns a "400 BAD REQUEST" response.  Takes a "message" argument as a scalar, which
           will become the value of "error" in the serialized response.

           Example:

             $self->status_bad_request(
               $c,
               message => "Cannot do what you have asked!",
             );

       status_forbidden
           Returns a "403 FORBIDDEN" response.  Takes a "message" argument as a scalar, which
           will become the value of "error" in the serialized response.

           Example:

             $self->status_forbidden(
               $c,
               message => "access denied",
             );

       status_not_found
           Returns a "404 NOT FOUND" response.  Takes a "message" argument as a scalar, which
           will become the value of "error" in the serialized response.

           Example:

             $self->status_not_found(
               $c,
               message => "Cannot find what you were looking for!",
             );

       gone
           Returns a "41O GONE" response.  Takes a "message" argument as a scalar, which will
           become the value of "error" in the serialized response.

           Example:

             $self->status_gone(
               $c,
               message => "The document have been deleted by foo",
             );

       status_see_other
           Returns a "303 See Other" response.  Takes an optional "entity" to serialize, and a
           "location" where the client should redirect to.

           Example:

             $self->status_see_other(
               $c,
               location => $some_other_url,
               entity => {
                   radiohead => "Is a good band!",
               }
             );

       status_moved
           Returns a "301 MOVED" response.  Takes an "entity" to serialize, and a "location"
           where the created object can be found.

           Example:

            $self->status_moved(
              $c,
              location => '/somewhere/else',
              entity => {
                radiohead => "Is a good band!",
              },
            );

MANUAL RESPONSES

       If you want to construct your responses yourself, all you need to do is put the object you
       want serialized in $c->stash->{'rest'}.

IMPLEMENTATION DETAILS

       This Controller ties together Catalyst::Action::REST, Catalyst::Action::Serialize and
       Catalyst::Action::Deserialize.  It should be suitable for most applications.  You should
       be aware that it:

       Configures the Serialization Actions
           This class provides a default configuration for Serialization.  It is currently:

             __PACKAGE__->config(
                 'stash_key' => 'rest',
                 'map'       => {
                    'text/html'          => 'YAML::HTML',
                    'text/xml'           => 'XML::Simple',
                    'text/x-yaml'        => 'YAML',
                    'application/json'   => 'JSON',
                    'text/x-json'        => 'JSON',
                    'text/x-data-dumper' => [ 'Data::Serializer', 'Data::Dumper' ],
                    'text/x-data-denter' => [ 'Data::Serializer', 'Data::Denter' ],
                    'text/x-data-taxi'   => [ 'Data::Serializer', 'Data::Taxi'   ],
                    'application/x-storable'   => [ 'Data::Serializer', 'Storable' ],
                    'application/x-freezethaw' => [ 'Data::Serializer', 'FreezeThaw' ],
                    'text/x-config-general'    => [ 'Data::Serializer', 'Config::General' ],
                    'text/x-php-serialization' => [ 'Data::Serializer', 'PHP::Serialization' ],
                 },
             );

           You can read the full set of options for this configuration block in
           Catalyst::Action::Serialize.

       Sets a "begin" and "end" method for you
           The "begin" method uses Catalyst::Action::Deserialize.  The "end" method uses
           Catalyst::Action::Serialize.  If you want to override either behavior, simply
           implement your own "begin" and "end" actions and forward to another action with the
           Serialize and/or Deserialize action classes:

             package Foo::Controller::Monkey;
             use Moose;
             use namespace::autoclean;

             BEGIN { extends 'Catalyst::Controller::REST' }

             sub begin : Private {
               my ($self, $c) = @_;
               ... do things before Deserializing ...
               $c->forward('deserialize');
               ... do things after Deserializing ...
             }

             sub deserialize : ActionClass('Deserialize') {}

             sub end :Private {
               my ($self, $c) = @_;
               ... do things before Serializing ...
               $c->forward('serialize');
               ... do things after Serializing ...
             }

             sub serialize : ActionClass('Serialize') {}

           If you need to deserialize multipart requests (i.e. REST data in one part and file
           uploads in others) you can do so by using the Catalyst::Action::DeserializeMultiPart
           action class.

A MILD WARNING

       I have code in production using Catalyst::Controller::REST.  That said, it is still under
       development, and it's possible that things may change between releases.  I promise to not
       break things unnecessarily. :)

SEE ALSO

       Catalyst::Action::REST, Catalyst::Action::Serialize, Catalyst::Action::Deserialize

       For help with REST in general:

       The HTTP 1.1 Spec is required reading. http://www.w3.org/Protocols/rfc2616/rfc2616.txt

       Wikipedia! http://en.wikipedia.org/wiki/Representational_State_Transfer

       The REST Wiki: http://rest.blueoxen.net/cgi-bin/wiki.pl?FrontPage

AUTHORS

       See Catalyst::Action::REST for authors.

LICENSE

       You may distribute this code under the same terms as Perl itself.