File Coverage

blib/lib/PocketIO.pm

Criterion	Covered	Total	%
statement	47	54	87.0
branch	5	8	62.5
condition	8	15	53.3
subroutine	14	14	100.0
pod	4	4	100.0
total	78	95	82.1

package PocketIO;

use strict;
use warnings;

our $VERSION = '0.17';

use overload '&{}' => sub { shift->to_app(@_) }, fallback => 1;

use PocketIO::Exception;
use PocketIO::Resource;
use PocketIO::Pool;

sub new {
    my $class = shift;

    my $self = {@_};
    bless $self, $class;

    $self->{handler} = $self->_get_handler;

    $self->{socketio} ||= {};

    return $self;
}

sub to_app {
    my $self = shift;

    return sub { $self->call(@_) };
}

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

    my $response;
    eval {
        my $dispatcher = $self->_build_dispatcher(%{$self->{socketio}});

        $response = $dispatcher->dispatch($env, $self->{handler});
    } or do {
        my $e = $@;

        require Scalar::Util;
        die $e unless Scalar::Util::blessed($e);

        my $code = $e->code;
        my $message = $e->message || 'Internal Server Error';

        my @headers = (
            'Content-Type'   => 'text/plain',
            'Content-Length' => length($message),
        );

        $response = [$code, \@headers, [$message]];
    };

    return $response;
}

sub pool {
    my $self = shift;

    $self->{pool} ||= PocketIO::Pool->new;

    return $self->{pool};
}

sub _build_dispatcher {
    my $self = shift;

    return PocketIO::Resource->new(pool => $self->pool, @_);
}

sub _get_handler {
    my $self = shift;

    return $self->{handler} if $self->{handler};

    die q{Either 'handler', 'class' or 'instance' must be specified}
      unless $self->{instance} || $self->{class};

    my $method = $self->{method} || 'run';

    my $instance = $self->{instance}
      || do {
        my $class = $self->{class};

        my $path = $class;
        $path =~ s{::}{/}g;
        $path .= '.pm';

        require $path;
        $class->new;
      };

    return $instance->$method;
}

1;
__END__