File Coverage

blib/lib/RDF/Sesame/Response.pm

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

package RDF::Sesame::Response;

use strict;
use warnings;
use XML::Simple;

our $VERSION = '0.17';

# simple accessors
sub errstr        { return $_[0]->{error}   }
sub http_response { return $_[0]->{http}    }
sub parsed_xml    { return $_[0]->{parsed}  }
sub success       { return $_[0]->{success} }
sub xml           { return $_[0]->{xml}     }

sub content {
    my ($self) = @_;
    return $self->http_response()->content();
}

sub is_xml {
    my ($self) = @_;
    my $content_type = $self->http_response()->header('Content-type');
    return $content_type =~ m{ text/xml }xms;
}

sub is_binary_results {
    my ($self) = @_;
    my $content_type = $self->http_response()->header('Content-type');
    return $content_type =~ m{ application/x-binary-rdf-results-table }xms;
}

#
# Creates a new RDF::Sesame::Response object.
#
# The parameter $response is an HTTP::Response object
#
sub new {
    my ($class, $r) = @_;

    my $self = bless {
        http    => $r, # our original HTTP::Response object
        success => 0,  # was the command sucessful?
        xml     => '', # the XML from the server
        error   => '', # the error message from the server
        parsed  => {}, # a hashref representing the parsed XML
    }, $class;

    # return an empty object if we got no HTTP::Response
    return $self unless $r;

    if ( !$r->is_success() ) {
        $self->{error} = $r->message();
        return $self;
    }

    $self->{success} = 1;
    return $self if !$self->is_xml();

    # because the XML for tuples prevents XML::Simple
    # from retaining the attribute order, we do a transform
    # to improve the XML.
    # See the documentation for _fix_tuple()
    my $xml = $self->{xml} = $r->content();
    $xml =~ s#(.*?)#_fix_tuple($1)#siegx;

    # TODO call a custom XML::SAX parser instead
    $self->{parsed} = XMLin(
        $xml,
        ForceArray => [
            qw(repository status notification
                columnName tuple  attribute
                error                         )
        ],
        KeyAttr    => [ ],
    );

    # examine the XML for error responses
    if( exists $self->{parsed}{error} ) {
        $self->{success} = 0;
        $self->{error} = @{$self->{parsed}{error}}[0]->{msg};
    }

    return $self;
}

# The XML returned by Sesame after evaluating a table query
# contains the attributes of each tuple in the same order as
# the attribute (column) names.  This order is not preserved by XML::Simple
# so we need to transform the provided-XML into a more useful form.
# This could be done with XSLT but that's overkill, so
# we jut use regular expressions.
#
# An example transform would take XML like this
#
#
#   node1
#   Hello
#   http://example.com
#   World!
#
#
# and transform it into XML like this
#
#
#   node1
#   Hello
#   http://example.com
#   World!
#
sub _fix_tuple {
    my $content = shift;

    $content =~ s#
        <\s*(bNode|literal|uri)(.*?)>(.*?)
       #$3#sgix;

    $content =~ s#
        <\s*(null)(.*?)\s*/\s*>
       ##sgix;

    return "$content";
}

1;

__END__