File Coverage

blib/lib/JSON/RPC/Spec.pm

Criterion	Covered	Total	%
statement	75	77	97.4
branch	20	20	100.0
condition	2	2	100.0
subroutine	18	18	100.0
pod	3	3	100.0
total	118	120	98.3

package JSON::RPC::Spec;
use Moo;
use Carp ();
use version; our $VERSION = version->declare("v1.2.0");
use Try::Tiny;
use Router::Simple;
use JSON::RPC::Spec::Procedure;
use JSON::RPC::Spec::Client;
with qw(
  JSON::RPC::Spec::Common
);

use constant DEBUG => $ENV{PERL_JSON_RPC_SPEC_DEBUG} || 0;

has router => (
    is  => 'lazy',
    isa => sub {
        my $self = shift;
        $self->can('match') or Carp::croak('method match required.');
    },
);

has _procedure => (is => 'lazy');

has _client => (
    is      => 'lazy',
    handles => [qw(compose)],
);

has [qw(_is_batch _content)] => (is => 'rw');

use namespace::clean;


sub _build_router {
    Router::Simple->new;
}

sub _build__procedure {
    JSON::RPC::Spec::Procedure->new(router => shift->router);
}

sub _build__client {
    JSON::RPC::Spec::Client->new;
}

sub _parse_json {
    my ($self, $extra_args) = @_;
    warn qq{-- start parsing @{[$self->_content]}\n} if DEBUG;

    unless (length $self->_content) {
        return $self->_rpc_invalid_request;
    }

    # JSON decode
    # rpc call with invalid JSON:
    # rpc call Batch, invalid JSON:
    my ($req, $err);
    try {
        $req = $self->coder->decode($self->_content);
    }
    catch {
        $err = $_;
        warn qq{-- error : @{[$err]} } if DEBUG;
    };
    if ($err) {
        return $self->_rpc_parse_error;
    }

    # Batch mode flag
    if (ref $req eq 'ARRAY') {
        $self->_is_batch(1);
    }
    else {
        $self->_is_batch(0);
        $req = [$req];
    }

    # rpc call with an empty Array:
    unless (scalar @{$req}) {
        return $self->_rpc_invalid_request;
    }

    # procedure call and create response
    my @response;
    for my $obj (@{$req}) {
        my $res = $self->_procedure->parse($obj, $extra_args);

        # notification is ignore
        push @response, $res if $res;
    }
    return unless @response;
    return [@response] if $self->_is_batch;
    return $response[0];
}

# parse JSON string to hash
sub parse_without_encode {
    my $self        = shift;
    my $json_string = shift;
    my $extra_args  = +[@_];
    $self->_content($json_string);
    return $self->_parse_json($extra_args);
}

# parse JSON string to JSON string
sub parse {
    my $self        = shift;
    my $json_string = shift;
    my $extra_args  = +[@_];
    $self->_content($json_string);
    my $result = $self->_parse_json($extra_args);
    return unless $result;
    return $self->coder->encode($result);
}

# register method
sub register {
    my ($self, $pattern, $cb) = @_;
    if (!defined $pattern) {
        Carp::croak('pattern required');
    }
    if (ref $cb ne 'CODE') {
        Carp::croak('code required');
    }
    $self->router->connect($pattern, +{$self->_callback_key => $cb}, +{});
    return $self;
}

1;
__END__