File Coverage

blib/lib/Plack/Middleware/FormatOutput.pm

Criterion	Covered	Total	%
statement	66	77	85.7
branch	15	32	46.8
condition	6	11	54.5
subroutine	17	18	94.4
pod	4	4	100.0
total	108	142	76.0

package Plack::Middleware::FormatOutput;

use 5.006;
use strict;
use warnings FATAL => 'all';

use parent qw( Plack::Middleware );
use Plack::Util;

use HTTP::Exception '4XX';

use JSON::XS;
use YAML::Syck;
use URI::Escape::XS qw/decodeURIComponent/;
use Encode;
our $VERSION = '0.10'; # is set automagically with Milla

$YAML::Syck::ImplicitUnicode = 1;

### Try load library
sub _try_load {
	my $mod = shift;
	eval("use $mod; 1") ? return 1 : return 0;
}

### Set default mime types
my $MIME_TYPES = {
	'application/json'   => sub { JSON::XS->new->utf8->allow_nonref->encode($_[0]) },
	'text/yaml'          => sub {
		local $Data::Dumper::Indent=1; local $Data::Dumper::Quotekeys=0; local $Data::Dumper::Terse=1; local $Data::Dumper::Sortkeys=1;
		Dump($_[0])
	},
	'text/plain'         => sub {
		local $Data::Dumper::Indent=1; local $Data::Dumper::Quotekeys=0; local $Data::Dumper::Terse=1; local $Data::Dumper::Sortkeys=1;
		Dump($_[0])
	},
	'text/html'   => sub {
		my ($data, $self, $env, $header) = @_;
		if ($self->htmlvis){
			my $ret = $self->htmlvis->html($data, $env, $header); #struct, env
			return Encode::encode_utf8($ret) if $ret;
		}
		return JSON::XS->new->utf8->allow_nonref->encode($data); # Just show content
	}
};

sub prepare_app {
	my $self = shift;

	### Check mime types
	foreach my $par (keys %{$self->{mime_type}}){
		delete $self->{mime_type}{$par} if ref $self->{mime_type}{$par} ne 'CODE';
	}

	### Add default MimeTypes
	foreach my $par (keys %{$MIME_TYPES}){
		$self->{mime_type}{$par} = $MIME_TYPES->{$par} unless exists $self->{mime_type}{$par};
	}

	### Add htmlvis
	if (_try_load('Rest::HtmlVis')){
		my $params = $self->{htmlvis} if exists $self->{htmlvis};
		$self->{htmlvis} = Rest::HtmlVis->new($params);
	}
}

sub mime_type {
	return $_[0]->{mime_type};
}

sub htmlvis {
	return $_[0]->{htmlvis};
}

sub call {
	my($self, $env) = @_;

	### Run app
	my $res = $self->app->($env);

	### Get accept from request header
	my $accept = _getAccept($self, $env);
	return $res unless $accept;

	### Return handler that manage response
	return Plack::Util::response_cb($res, sub {
		my $res = shift;
		if ( !Plack::Util::status_with_no_entity_body( $res->[0] ) && defined $res->[2] ){

			### File handler streaming body
			if ( Plack::Util::is_real_fh($res->[2]) ) {
				return
			}

			### Set header
			if ($res->[1] && @{$res->[1]}){
				Plack::Util::header_set($res->[1], 'Content-Type', $accept);
			}else{
				$res->[1] = ['Content-Type', $accept];
			}

			### Convert data
			$res->[2] = [$self->mime_type->{$accept}->($res->[2], $self, $env, $res->[1])];
		}elsif(! defined $res->[2]){
			$res->[2] = []; # backward compatibility
		}
		return $res;
	});
}

sub _getAccept {
	my ($self, $env) = @_;

	# Get accept from url
	my $accept;
	# We parse this with reqular because we need this as quick as possible
	my $query_string  = decodeURIComponent($env->{QUERY_STRING});
	if ( $query_string=~/format=([\w\/\+]*)/){
		if (exists $self->mime_type->{$1}){
			$accept = $1;
		}
	};

	# Set accept by http header
	if (!$accept && $env->{HTTP_ACCEPT}){
		foreach (split(/,/, $env->{HTTP_ACCEPT})){
			if ($_ eq '*/*'){
				$accept = exists $self->mime_type->{'text/html'} ? 'text/html' : undef;
				last;
			}
			next unless exists $self->mime_type->{$_};
			$accept = $_;
			last;
		}
	}

	return ($accept||'application/json');
}

1;
__END__