X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FRequest%2FREST.pm;h=6e96fd84204566597626a0c6ef44a5d56313bec5;hb=0745d6ebf570fa9b75029a7c8b85e647f1a1f09e;hp=4f3dab0ec9fba3a27d8ae597ff56e90520e9fd15;hpb=be3c588afb1dd6d6c8e6171c01c3d38afa75d6d5;p=catagits%2FCatalyst-Action-REST.git

diff --git a/lib/Catalyst/Request/REST.pm b/lib/Catalyst/Request/REST.pm
index 4f3dab0..6e96fd8 100644
--- a/lib/Catalyst/Request/REST.pm
+++ b/lib/Catalyst/Request/REST.pm
@@ -1,18 +1,42 @@
-#
-# REST.pm
-# Created by: Adam Jacob, Marchex, <adam@hjksolutions.com>
-# Created on: 10/13/2006 03:54:33 PM PDT
-#
-# $Id: $
-
 package Catalyst::Request::REST;
+use Moose;
+
+use Catalyst::Utils;
+use namespace::autoclean;
+
+extends 'Catalyst::Request';
+with 'Catalyst::TraitFor::Request::REST';
+
+# Please don't take this as a recommended way to do things.
+# The code below is grotty, badly factored and mostly here for back
+# compat..
+sub _insert_self_into {
+  my ($class, $app_class ) = @_;
+  # the fallback to $app_class is for the (rare and deprecated) case when
+  # people are defining actions in MyApp.pm instead of in a controller.
+  my $app = (blessed($app_class) && $app_class->can('_application'))
+        ? $app_class->_application : Catalyst::Utils::class2appclass( $app_class ) || $app_class;
+
+  my $req_class = $app->request_class;
+  return if $req_class->isa($class);
+  my $req_class_meta = Moose->init_meta( for_class => $req_class );
+  return if $req_class_meta->does_role('Catalyst::TraitFor::Request::REST');
+  if ($req_class eq 'Catalyst::Request') {
+    $app->request_class($class);
+  }
+  else {
+      my $meta = Moose::Meta::Class->create_anon_class(
+          superclasses => [$req_class],
+          roles => ['Catalyst::TraitFor::Request::REST'],
+          cache => 1
+      );
+      $meta->add_method(meta => sub { $meta });
+      $app->request_class($meta->name);
+  }
+}
 
-use strict;
-use warnings;
-
-use base 'Catalyst::Request';
-use HTTP::Headers::Util qw(split_header_words);
-
+__PACKAGE__->meta->make_immutable;
+__END__
 
 =head1 NAME
 
@@ -20,7 +44,7 @@ Catalyst::Request::REST - A REST-y subclass of Catalyst::Request
 
 =head1 SYNOPSIS
 
-     if ( $c->request->accepts('text/x-json') ) {
+     if ( $c->request->accepts('application/json') ) {
          ...
      }
 
@@ -32,17 +56,20 @@ This is a subclass of C<Catalyst::Request> that adds a few methods to
 the request object to faciliate writing REST-y code. Currently, these
 methods are all related to the content types accepted by the client.
 
+Note that if you have a custom request class in your application, and it does
+not inherit from C<Catalyst::Request::REST>, your application will fail with an
+error indicating a conflict the first time it tries to use
+C<Catalyst::Request::REST>'s functionality.  To fix this error, make sure your
+custom request class inherits from C<Catalyst::Request::REST>.
 
 =head1 METHODS
 
-=over 4 data
+=over
 
-If the request went through the Deserializer action, this method will
-returned the deserialized data structure.
-
-=cut
+=item data
 
-__PACKAGE__->mk_accessors(qw(data accept_only));
+If the request went through the Deserializer action, this method will
+return the deserialized data structure.
 
 =item accepted_content_types
 
@@ -73,82 +100,26 @@ relative quality specified for each type.
 If a type appears in more than one of these places, it is ordered based on
 where it is first found.
 
-=cut
-
-sub accepted_content_types {
-    my $self = shift;
-
-    return $self->{content_types} if $self->{content_types};
-
-    my %types;
-
-    # First, we use the content type in the HTTP Request.  It wins all.
-    $types{ $self->content_type } = 3
-        if $self->content_type;
-
-    if ($self->method eq "GET" && $self->param('content-type')) {
-        $types{ $self->param('content-type') } = 2;
-    }
-
-    # Third, we parse the Accept header, and see if the client
-    # takes a format we understand.
-    #
-    # This is taken from chansen's Apache2::UploadProgress.
-    if ( $self->header('Accept') ) {
-        $self->accept_only(1) unless keys %types;
-
-        my $accept_header = $self->header('Accept');
-        my $counter       = 0;
-
-        foreach my $pair ( split_header_words($accept_header) ) {
-            my ( $type, $qvalue ) = @{$pair}[ 0, 3 ];
-            next if $types{$type};
-
-            unless ( defined $qvalue ) {
-                $qvalue = 1 - ( ++$counter / 1000 );
-            }
-
-            $types{$type} = sprintf( '%.3f', $qvalue );
-        }
-    }
-
-    return $self->{content_types} =
-        [ sort { $types{$b} <=> $types{$a} } keys %types ];
-}
-
 =item preferred_content_type
 
 This returns the first content type found. It is shorthand for:
 
   $request->accepted_content_types->[0]
 
-=cut
-
-sub preferred_content_type { $_[0]->accepted_content_types->[0] }
-
 =item accepts($type)
 
 Given a content type, this returns true if the type is accepted.
 
 Note that this does not do any wildcard expansion of types.
 
-=cut
-
-sub accepts {
-    my $self = shift;
-    my $type = shift;
-
-    return grep { $_ eq $type } @{ $self->accepted_content_types };
-}
+=back
 
-=head1 AUTHOR
+=head1 AUTHORS
 
-Adam Jacob <adam@stalecoffee.org>, with lots of help from mst and jrockway
+See L<Catalyst::Action::REST> for authors.
 
 =head1 LICENSE
 
 You may distribute this code under the same terms as Perl itself.
 
 =cut
-
-1;