File Coverage

blib/lib/Protocol/XMLRPC/MethodResponse.pm

Criterion	Covered	Total	%
statement	9	9	100.0
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	12	12	100.0

package Protocol::XMLRPC::MethodResponse;

use strict;
use warnings;

use base 'Protocol::XMLRPC::Method';

use Protocol::XMLRPC::ValueFactory;

sub new {
    my $class = shift;

    my $param;

    if (@_ == 1) {
        $param = shift;
    }

    my $self = $class->SUPER::new(@_);

    $self->param($param) if defined $param;

    return $self;
}

sub new_fault {
    my $class = shift;

    my $self = $class->new();

    $self->fault(@_);

    return $self;
}

sub fault {
    my $self = shift;

    if (@_) {
        my ($code, $string) = @_;

        $self->{_fault} = Protocol::XMLRPC::Value::Struct->new(
            faultCode   => $code,
            faultString => $string
        );

        return $self;
    }

    return $self->{_fault};
}

sub fault_string {
    my $self = shift;

    return unless $self->{_fault};

    return $self->{_fault}->members->{faultString}->value;
}

sub fault_code {
    my $self = shift;

    return unless $self->{_fault};

    return $self->{_fault}->members->{faultCode}->value;
}

sub param {
    my $self = shift;

    if (@_) {
        $self->{_param} = Protocol::XMLRPC::ValueFactory->build(@_);
    }
    else {
        return $self->{_param};
    }
}

sub value { shift->param->value }

sub _parse_document {
    my $class = shift;
    my ($doc) = @_;

    my ($method_response) = $doc->getElementsByTagName('methodResponse');
    die "Node  is missing" unless $method_response;

    if (my ($params) = $method_response->getElementsByTagName('params')) {
        my ($param) = $params->getElementsByTagName('param');
        die "Node  is missing" unless $param;

        my ($value) = $param->getElementsByTagName('value');
        die "Node  is missing" unless $value;

        $param = $class->_parse_value($value);
        die "Can't parse value" unless defined $param;

        return $class->new(_param => $param);
    }
    elsif (my ($fault) = $method_response->getElementsByTagName('fault')) {
        my ($value) = $fault->getElementsByTagName('value');
        die "Node  is missing" unless defined $value;

        my $struct = $class->_parse_value($value);
        die "Value must be 'Struct'" unless $struct && $struct->type eq 'struct';

        return $class->new(_fault => $struct);
    }

    die "Node  or  is missing";
}

sub to_string {
    my $self = shift;

    my $string = qq||;

    if (defined $self->fault) {
        $string .= '';

        my $struct = $self->fault;

        $string .= "$struct";

        $string .= '';
    }
    elsif (defined(my $param = $self->param)) {
        $string .= '';

        $string .= "$param";

        $string .= '';
    }
    else {
        die ' or  is required';
    }

    $string .= '';

    return $string;
}

1;
__END__