File Coverage

blib/lib/Sphinx/XMLpipe2.pm

Criterion	Covered	Total	%
statement	57	71	80.2
branch	11	22	50.0
condition			n/a
subroutine	8	8	100.0
pod	4	4	100.0
total	80	105	76.1

package Sphinx::XMLpipe2;

use XML::Hash::XS;

our $VERSION = "0.05";

sub new {
    my ($class, %args) = @_;
    return undef unless %args;

    my $self = \%args;
    $self->{'data'} = {};

    $self->{'xmlprocessor'} = XML::Hash::XS->new(
        xml_decl => 0,
        indent   => 4,
        use_attr => 1,
        content  => 'content',
        encoding => 'utf-8',
        utf8     => 0,
    );

    bless $self, $class;
    return $self
}

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

    my $content1 = $self->_fetch_header();
    my $content2 = $self->_fetch_data();
    return qq~\n$content1$content2~;
}

sub add_data {
    my ($self, $data) = @_;
    return undef unless exists $data->{'id'};

    $self->{'data'}->{'sphinx:document'} = []
        unless exists $self->{'data'}->{'sphinx:document'};

    my %params = ();
    my @keys   = ();

    if (ref($self->{'attrs'}) eq 'HASH') {
        @keys = (@{$self->{'fields'}}, keys %{$self->{'attrs'}});
        map { $params{$_} = [$data->{$_}] } @keys;
    }
    elsif (ref($self->{'attrs'}) eq 'ARRAY') {
        my @def = ();
        for my $definition (@{$self->{'attrs'}}) {
            push @def, $definition->{'name'};
        }
        @keys = (@{$self->{'fields'}}, @def);
    }
    map { $params{$_} = [$data->{$_}] if exists $data->{$_}; } @keys;

    push @{$self->{'data'}->{'sphinx:document'}}, {
        id => $data->{'id'},
        %params
    };
    return $self;
}

sub remove_data {
    my ($self, $data) = @_;
    return undef unless exists $data->{'id'};

    $self->{'data'}->{'sphinx:killlist'} = {'id' => []}
        unless exists $self->{'data'}->{'sphinx:killlist'}->{'id'};

    push @{$self->{'data'}->{'sphinx:killlist'}->{'id'}}, [$data->{'id'}];
    return $self;
}


sub _fetch_header {
    my ($self, ) = @_;
    my $header = {
        'sphinx:schema' => {
            'sphinx:field' => [],
            'sphinx:attr'  => [],
        }
    };

    for my $field (@{$self->{'fields'}}) {
        push @{$header->{'sphinx:schema'}->{'sphinx:field'}}, {'name' => $field};
    }

    if (ref($self->{'attrs'}) eq 'HASH') {
        for my $attr (keys %{$self->{'attrs'}}) {
            push @{$header->{'sphinx:schema'}->{'sphinx:attr'}}, {'name' => $attr, 'type' => $self->{'attrs'}->{$attr}};
        }
    }
    elsif (ref($self->{'attrs'}) eq 'ARRAY') {
        for my $definition (@{$self->{'attrs'}}) {
            my $node = {};
            map {$node->{$_} = $definition->{$_} if exists $definition->{$_};} qw(name type bits default);
            push @{$header->{'sphinx:schema'}->{'sphinx:attr'}}, $node;
        }
    }
    @{$header->{'sphinx:schema'}->{'sphinx:attr'}} = sort {$a->{name} cmp $b->{name}} @{$header->{'sphinx:schema'}->{'sphinx:attr'}};

    return _pruning_xml($self->{'xmlprocessor'}->hash2xml($header));
}

sub _fetch_data {
    my ($self, ) = @_;
    return _pruning_xml($self->{'xmlprocessor'}->hash2xml($self->{'data'}));
}

sub _pruning_xml {
    my ($xml) = @_;
    $xml =~ s/^\s*//is;
    $xml =~ s/<\/root>\s*$//is;
    return $xml;
}

1;
__END__