File Coverage

blib/lib/Plack/Middleware/JSONP/Headers.pm

Criterion	Covered	Total	%
statement	88	89	98.8
branch	19	26	73.0
condition	1	3	33.3
subroutine	18	18	100.0
pod	2	4	50.0
total	128	140	91.4

package Plack::Middleware::JSONP::Headers;
{
  $Plack::Middleware::JSONP::Headers::VERSION = '0.11';
}
#ABSTRACT: Wraps JSON response with HTTP headers in JSONP
use strict;

use parent qw(Plack::Middleware);

use Plack::Util;
use Plack::Builder;
use URI::Escape ();
use JSON ();
use Scalar::Util 'reftype';
use HTTP::Headers ();
use Plack::Util::Accessor qw(callback_key headers template);

sub prepare_app {
    my $self = shift;

    unless (defined $self->callback_key) {
        $self->callback_key('callback');
    }

    unless (defined $self->headers) {
        $self->headers( sub { 1 } );
    }

    unless (reftype $self->headers eq 'CODE') {
        my $headers = $self->headers;
        if (ref $self->headers eq ref qr//) {
            $self->headers( sub { $_[0] =~ $headers; } );
        } elsif (reftype $self->headers eq 'ARRAY') {
            $self->headers( sub { grep { $_[0] eq $_ } @$headers } );
        } else {
            die "headers must be code, array, or regexp";
        }
    }

    unless ($self->template) {
        $self->template('{ "meta": %s, "data": %s }')
    }
}

sub wrap_json {
    my ($self, $status, $headers, $data) = @_;

    my $meta = { status => $status };
    my @links;

    $headers->iter(    sub {
        my ($key, $value) = @_;
        return unless $self->headers->($key, $value);
        if ($key eq 'Link') {
            push @{$meta->{'Link'}}, $self->parse_link_header( $value );
        } else {
            $meta->{$key} = $value; # just ignores repeatable headers
        }
    });

    $meta->{Link} = \@links if @links;
    $meta = JSON->new->encode( $meta );

    sprintf $self->template, $meta, $data;
}

sub parse_link_header {
    my ($self, $link) = @_;

    my @links;

    while( $link =~ /^(\s*<([^>]*)>\s*[;,]?\s*)/) {
        my $url = $2;
        $link = substr($link, length($1));
        my %attr = ();
        while ($link =~ /^((\/|[a-z0-9-]+\*?)\s*\=\s*("[^"]*"|[^\s\"\;\,]+)\s*[;,]?\s*)/i) {
            $link = substr($link, length($1));
            my $key = lc $2;
            my $val = $3;
            $val =~ s/(^"|"$)//g if ($val =~ /^".*"$/);
            $attr{$key} = $val;
        }
        push @links, [ $url, \%attr ];
    }

    return @links;
}

# Most of this method is copied from Plack::Middleware::JSONP.
# I found no easy way to reuse this module, so it had to be forked.
sub call {
    my($self, $env) = @_;
    my $res = $self->app->($env);
    $self->response_cb($res, sub {
        my $res = shift;
        if (defined $res->[2]) {
            my $h = Plack::Util::headers($res->[1]);
            my $callback_key = $self->callback_key;
            if ($h->get('Content-Type') =~ m!/(?:json|javascript)! &&
                $env->{QUERY_STRING} =~ /(?:^|&)$callback_key=([^&]+)/) {
                my $cb = URI::Escape::uri_unescape($1);
                if ($cb =~ /^[\w\.\[\]]+$/) {
                    my $body;
                    Plack::Util::foreach($res->[2], sub { $body .= $_[0] });

                    # this line added
                      $body = $self->wrap_json( $res->[0], $h, $body );

                    my $jsonp = "$cb($body)";
                    $res->[2] = [ $jsonp ];
                    $h->set('Content-Length', length $jsonp);
                    $h->set('Content-Type', 'text/javascript');
                }
            }
        }
    });
}

1;



__END__