X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FAction%2FSerialize.pm;h=110c4dafe986df4bd999fe9a15937a0a0bc84c2c;hb=44fa7f9429568532ea892e2020c20177b71cb736;hp=489643804348b204cdfea7f1e13bf0ca8c2b4c92;hpb=eccb21379de1fbdc65740e0cb4158d3b4d055cab;p=catagits%2FCatalyst-Action-REST.git diff --git a/lib/Catalyst/Action/Serialize.pm b/lib/Catalyst/Action/Serialize.pm index 4896438..110c4da 100644 --- a/lib/Catalyst/Action/Serialize.pm +++ b/lib/Catalyst/Action/Serialize.pm @@ -1,77 +1,165 @@ -# -# Catlyst::Action::Serialize.pm -# Created by: Adam Jacob, Marchex, -# -# $Id$ - package Catalyst::Action::Serialize; -use strict; -use warnings; +use Moose; +use namespace::autoclean; -use base 'Catalyst::Action'; +extends 'Catalyst::Action::SerializeBase'; use Module::Pluggable::Object; +use MRO::Compat; + +our $VERSION = '1.04'; +$VERSION = eval $VERSION; -__PACKAGE__->mk_accessors(qw(plugins)); +has _encoders => ( + is => 'ro', + isa => 'HashRef', + default => sub { {} }, +); sub execute { my $self = shift; my ( $controller, $c ) = @_; + $self->maybe::next::method(@_); + return 1 if $c->req->method eq 'HEAD'; - return 1 if length( $c->response->body ); + return 1 if $c->response->has_body; return 1 if scalar @{ $c->error }; - return 1 if $c->response->status =~ /^(?:204|3\d\d)$/; - - # Load the Serialize Classes - unless ( defined( $self->plugins ) ) { - my $mpo = Module::Pluggable::Object->new( - 'require' => 1, - 'search_path' => ['Catalyst::Action::Serialize'], - ); - my @plugins = $mpo->plugins; - $self->plugins( \@plugins ); - } + return 1 if $c->response->status =~ /^(?:204)$/; - # Look up what serializer to use from content_type map - # - # If we don't find one, we use the default - my $content_type = $c->request->content_type; - my $sclass = 'Catalyst::Action::Serialize::'; - my $sarg; - my $map = $controller->serialize->{'map'}; - if ( exists( $map->{$content_type} ) ) { - my $mc; - if ( ref( $map->{$content_type} ) eq "ARRAY" ) { - $mc = $map->{$content_type}->[0]; - $sarg = $map->{$content_type}->[1]; - } else { - $mc = $map->{$content_type}; - } - $sclass .= $mc; - if ( !grep( /^$sclass$/, @{ $self->plugins } ) ) { - die "Cannot find plugin $sclass for $content_type!"; - } - } else { - if ( exists( $controller->serialize->{'default'} ) ) { - $sclass .= $controller->serialize->{'default'}; + my ( $sclass, $sarg, $content_type ) = + $self->_load_content_plugins( "Catalyst::Action::Serialize", + $controller, $c ); + unless ( defined($sclass) ) { + if ( defined($content_type) ) { + $c->log->info("Could not find a serializer for $content_type"); } else { - die "I cannot find a default serializer!"; + $c->log->info( + "Could not find a serializer for an empty content-type"); } + return 1; } + $c->log->debug( + "Serializing with $sclass" . ( $sarg ? " [$sarg]" : '' ) ) if $c->debug; - # Go ahead and serialize ourselves - if ( defined($sarg) ) { - $sclass->execute( $controller, $c, $sarg ); - } else { - $sclass->execute( $controller, $c ); - } + $self->_encoders->{$sclass} ||= $sclass->new; + my $sobj = $self->_encoders->{$sclass}; - if ( !$c->response->content_type ) { - $c->response->content_type( $c->request->content_type ); + my $rc; + eval { + if ( defined($sarg) ) { + $rc = $sobj->execute( $controller, $c, $sarg ); + } else { + $rc = $sobj->execute( $controller, $c ); + } + }; + if ($@) { + return $self->serialize_bad_request( $c, $content_type, $@ ); + } elsif (!$rc) { + return $self->unsupported_media_type( $c, $content_type ); } return 1; } +__PACKAGE__->meta->make_immutable; + 1; + +=head1 NAME + +Catalyst::Action::Serialize - Serialize Data in a Response + +=head1 SYNOPSIS + + package Foo::Controller::Bar; + + __PACKAGE__->config( + 'default' => 'text/x-yaml', + 'stash_key' => 'rest', + 'map' => { + 'text/html' => [ 'View', 'TT', ], + 'text/x-yaml' => 'YAML', + 'text/x-data-dumper' => [ 'Data::Serializer', 'Data::Dumper' ], + } + ); + + sub end :ActionClass('Serialize') {} + +=head1 DESCRIPTION + +This action will serialize the body of an HTTP Response. The serializer is +selected by introspecting the HTTP Requests content-type header. + +It requires that your Catalyst controller is properly configured to set up the +mapping between Content Type's and Serialization classes. + +The specifics of serializing each content-type is implemented as a plugin to +L. + +Typically, you would use this ActionClass on your C method. However, +nothing is stopping you from choosing specific methods to Serialize: + + sub foo :Local :ActionClass('Serialize') { + .. populate stash with data .. + } + +When you use this module, the request class will be changed to +L. + +=head1 CONFIGURATION + +=head2 map + +Takes a hashref, mapping Content-Types to a given serializer plugin. + +=head2 default + +This is the 'fall-back' Content-Type if none of the requested or acceptable +types is found in the L. It must be an entry in the L. + +=head2 stash_key + +Specifies the key of the stash entry holding the data that is to be serialized. +So if the value is "rest", we will serialize the data under: + + $c->stash->{'rest'} + +=head2 content_type_stash_key + +Specifies the key of the stash entry that optionally holds an overriding +Content-Type. If set, and if the specified stash entry has a valid value, +then it takes priority over the requested content types. + +This can be useful if you want to dynamically force a particular content type, +perhaps for debugging. + +=head1 HELPFUL PEOPLE + +Daisuke Maki pointed out that early versions of this Action did not play +well with others, or generally behave in a way that was very consistent +with the rest of Catalyst. + +=head1 CUSTOM ERRORS + +For building custom error responses when serialization fails, you can create +an ActionRole (and use L to apply it to the +C action) which overrides C and/or C<_serialize_bad_request> +methods. + +=head1 SEE ALSO + +You likely want to look at L, which implements +a sensible set of defaults for doing a REST controller. + +L, L + +=head1 AUTHORS + +See L for authors. + +=head1 LICENSE + +You may distribute this code under the same terms as Perl itself. + +=cut