File Coverage

blib/lib/SWISH/WebService.pm

Criterion	Covered	Total	%
statement	80	130	61.5
branch	12	46	26.0
condition	10	25	40.0
subroutine	17	21	80.9
pod	1	8	12.5
total	120	230	52.1

package SWISH::WebService;

use strict;
use warnings;
use Carp;
use Data::Dumper;
use URI::Escape;
use Data::Pageset;
use Template;
use Search::Tools;
use Search::Tools::XML;
use Time::HiRes qw( gettimeofday tv_interval );

use base qw( Class::Accessor::Fast );

our $VERSION = '0.02';
our $Props = 'swishrank,swishreccount,swishdocpath,swishtitle,swishdescription';
our $Server  = 'http://localhost/swished/';
our %Headers = ();                           # cache from index on first connect
our $Index   = 'DEFAULT';
our $Debug   = $ENV{PERL_DEBUG} || 0;
our %Defaults = (
                 q => '',
                 o => '',
                 n => 10,
                 p => 10,
                 s => 1,
                 f => 'html',
                );

our %Content_Types = (
                      xml    => 'application/xml',
                      html   => 'text/html',
                      simple => 'text/plain',
                      rss    => 'application/xml'
                     );

our $XMLDecl = '';

##################################################################################
# Templates
# could break these into separate files but easier for maintenance to include here
#

our %Templates = ();

########################    XML    ##############################

$Templates{xml} = <
$XMLDecl


  [% count = 0;
     WHILE (r = results.NextResult);
     count = count + 1 %]

        id="[% r.Property('swishreccount') %]"
        rank="[% r.Property('swishrank') %]">
    [% self.xml.utf8_safe( r.Property('swishtitle') ) %]
    [% r.Property('swishdocpath') | uri %]
    [% self.hiliter.light(
                self.xml.utf8_safe(
                    self.snipper.snip(
                        r.Property('swishdescription')
                    )
                )
             )
           %]

   [% LAST IF count == self.p %]
  [% END %]


    start="[% self.s %]"
    end="[% self.s + self.p - 1 %]"
    max="[% self.p %]"
    total="[% results.Hits %]"
    runtime="[% self.elapsed | format('%0.3f') %]"
    searchtime="[% self.searchtime | format('%0.3f') %]"
    >
   [% results.Query %]
   [% results.Stopwords %]
   [% self.o %]
   [% self.wordchars %]
   [% self.beginchars %]
   [% self.endchars %]


[% UNLESS pager.current_page == pager.first_page %]

   Prev

 [% IF pager.current_page > pager.first_page %]

   [% pager.first_page %]

 [% END %]
[% END %]
[% FOR p = pager.pages_in_set %]
 [% IF p == pager.current_page %]
[% p %]
 [% ELSE %]

 [% p %]

 [% END %]
[% END %]
[% UNLESS pager.current_page == pager.last_page %]
 [% IF pager.current_page < pager.last_page %]

   [% pager.last_page %]

 [% END %]
  Next
[% END %]


XML

######################    HTML   ###########################

$Templates{html} = <


  [% count = 0;
     WHILE (r = results.NextResult);
     count = count + 1 %]

        id="item_[% r.Property('swishreccount') %]"
        class="item" >
    [% r.Property('swishrank') %]

     [%
        self.xml.utf8_safe(
            r.Property('swishtitle')
        )
     %]

    [% r.Property('swishdocpath') | uri %]
    [% self.hiliter.light(
                            self.xml.utf8_safe(
                                self.snipper.snip(
                                    r.Property('swishdescription')
                                )
                            )
                          )
                        %]

   [% LAST IF count == self.p %]
  [% END %]



     Results [% self.s %] - [% self.s + self.p - 1 %]
     of [% results.Hits %]

    for [% self.snipper.rekw.keywords.join(' ') %]
    [% IF results.Stopwords %]
    The following words were automatically removed:
    [% results.Stopwords %]

    [% END %]
    [% IF self.o %]
    Sorted by: [% self.o %]
    [% END %]

     Run time: [% self.elapsed | format('%0.3f') %] sec -
     Search time: [% self.searchtime | format('%0.3f') %] sec



[% UNLESS pager.current_page == pager.first_page %]

   « Prev
   ·

 [% IF pager.current_page > (pager.first_page + (self.n / 2) - 1) %]

   [% pager.first_page %]
   [% IF pager.current_page > (pager.first_page + (self.n / 2) ) %] ... [% END %]

 [% END %]
[% END %]
[% FOR p = pager.pages_in_set %]
 [% IF p == pager.current_page %]
[% p %]
 [% ELSE %]

  [% p %]

 [% END %]
[% END %]
[% UNLESS pager.current_page == pager.last_page %]
 [% IF pager.current_page < (pager.last_page - (self.n / 2)) %]

  [% IF pager.current_page < (pager.last_page - (self.n / 2) - 1) %] ... [% END %]
   [% pager.last_page %]

 [% END %]

  ·
   Next »

[% END %]


HTML

############################   simple  ##############################

$Templates{simple} = <
[%  count = 0;
    WHILE (r = results.NextResult);
    count = count + 1 %]
t:[% r.Property('swishtitle') | uri %]
u:[% r.Property('swishdocpath') | uri %]
r:[% r.Property('swishrank') %]
n:[% r.Property('swishreccount') %]
-[% LAST IF count == self.p %][% END %]
--
SIMPLE

############################  RSS  ###################################

$Templates{rss} = <
$XMLDecl


  [% self.xml.utf8_safe( self.rss.title ) OR self.xml.utf8_safe( self.title ) %]
  [% self.rss.link || self.uri %]
  [% self.xml.utf8_safe( self.rss.description ) OR self.xml.utf8_safe( self.description ) %]
  [% self.rss.lang || 'en-us' %]

   [% self.xml.utf8_safe( self.rss.img.title ) %]
   [% self.rss.img.url %]
   [% self.rss.img.link %]

  [% count = 0;
     WHILE (r = results.NextResult);
     count = count + 1 %]

    [% self.xml.utf8_safe( r.Property('swishtitle') ) %]
    [% r.Property('swishdocpath') | uri %]
    [% self.hiliter.light(
                      self.xml.utf8_safe(
                        self.snipper.snip(
                            r.Property('swishdescription')
                        )
                      )
                    )
                  %]

   [% LAST IF count == self.p %]
  [% END %]


RSS

################################################################################

sub new
{
    my $class = shift;
    my $self  = {};
    bless($self, $class);

    $self->mk_accessors(
        qw/
          error
          template
          searchtime
          query
          stopwords
          wordchars
          beginchars
          endchars
          swish
          templates
          debug
          server
          index
          uri
          results
          title
          rss
          hiliter
          snipper
          xml
          /,

        keys %Defaults
    );

    return $self->_init(@_);
}

sub _init
{
    my $self = shift;
    $self->{_start} = [gettimeofday()];
    if (@_ > 1)
    {
        my %extra = @_;
        @$self{keys %extra} = values %extra;
        for (keys %Defaults)
        {
            $self->{$_} ||= $Defaults{$_};
        }
    }
    elsif (@_)
    {
        for (keys %Defaults)
        {
            $self->$_(
                   defined $_[0]->param($_) ? $_[0]->param($_) : $Defaults{$_});
        }
    }
    else
    {
        croak "need name/value pairs or a CGI object";
    }

    # enforce max hits
    if ($self->p > 100)
    {
        $self->p(100);
    }

    unless ($self->q)
    {
        $self->error('Query is required at a minimum');
        return;
    }
    else
    {

        # filter query to match swish convention
        # TODO a filter() callback?
        # TODO build this =/: opt into swish itself
        my $q = $self->q;
        $q =~ s,:,=,g;
        $self->q($q);
    }

    # create template object
    $self->{template} ||= Template->new()
      or croak $Template::ERROR;

    # shortcut to S::T::XML
    $self->xml(Search::Tools::XML->new);

    # defaults
    $self->{templates} ||= \%Templates;
    $self->{index}     ||= $Index;
    $self->{server}    ||= $Server;
    $self->{debug}     ||= $Debug;

    return $self;
}

sub params
{
    my $self = shift;

    # this is not terribly efficient
    # but since we can't really cache how else to do it?
    return $self->uri . '?'
      . join(';', map { $_ . '=' . uri_escape($self->$_) } sort keys %Defaults);
}

sub page
{

    # set the correct s() value based on $page and ->p()
    # example: $page = 3 and ->p = 10, so ->s = 31
    my $self = shift;
    my $page = shift || 1;

    $self->s(($page * $self->p) - $self->p + 1);

    # important to return empty string so template doesn't get value
    return '';
}

sub search
{
    my $self = shift;

    $self->{_startsearch} = [gettimeofday()];

    unless ($self->swish)
    {
        eval "require SWISH::API::Remote";
        if ($@)
        {
            eval "require SWISH::API";

            if ($@)
            {
                croak
                  "SWISH::API::Remote or SWISH::API must be installed to use "
                  . ref $self;
            }
            else
            {
                $self->swish(SWISH::API->new($self->index));
            }

        }
        else
        {
            $self->swish(
                        SWISH::API::Remote->new(
                            $self->server, $self->index, {DEBUG => $self->debug}
                                               )
                        );
        }

    }

    if (ref $self->swish eq 'SWISH::API')
    {

        my $search = $self->swish->new_search_object;
        return $self->error if $self->_check_swish_err;

        $search->set_sort($self->o) if $self->o;
        return $self->error         if $self->_check_swish_err;

        $self->results($search->execute($self->q));
        return $self->error if $self->_check_swish_err;

        $self->results->seek_result($self->s - 1);
        return $self->error if $self->_check_swish_err;

        if (!%Headers)
        {
            my $i = ($self->swish->index_names)[0];
            my @h = $self->swish->header_names;
            for (@h)
            {
                $Headers{$_} = join(' ', $self->swish->header_value($i, $_));
            }
        }

    }
    elsif ($self->swish->isa('SWISH::API::Remote'))
    {

        # TODO order ?
        $self->results(
            $self->swish->Execute(
                $self->q,
                {
                 BEGIN      => $self->s - 1,    # swished is 0-based
                 PROPERTIES => $Props,
                 MAX        => $self->p
                }
            )
        );

        if ($self->results->Error())
        {
            return $self->error($self->results->ErrorString());
        }

        if (!%Headers)
        {
            my @h = $self->swish->HeaderList;
            for (@h)
            {
                $Headers{$_->Name} = $_->Value;
            }
        }

    }

    $self->searchtime(tv_interval($self->{_startsearch}, [gettimeofday()]));

    $self->wordchars($Headers{WordCharacters});
    $self->beginchars($Headers{BeginCharacters});
    $self->endchars($Headers{EndCharacters});

    # create hiliter and snipper
    my $re =
      Search::Tools->regexp(
                            query            => $self->q,
                            word_characters  => $self->wordchars,
                            begin_characters => $self->beginchars,
                            end_characters   => $self->endchars
                           );
    $self->snipper(
                   Search::Tools->snipper(
                                          query   => $re,
                                          context => 12,
                                          occur   => 2
                                         )
                  );
    $self->hiliter(Search::Tools->hiliter(query => $re, class => 'hilite'));

    #carp Dumper \%Headers;

    return $self->render;

}

sub _check_swish_err
{
    my $self = shift;
    if ($self->swish->critical_error)
    {
        $self->error(
              $self->swish->error_string . ": " . $self->swish->last_error_msg);
        return $self->error;
    }
    return 0;
}

sub format
{
    return $Content_Types{$_[0]->f} . '; charset=utf-8';
}

sub elapsed
{
    return tv_interval($_[0]->{_start}, [gettimeofday()]);
}

# the guts
sub render
{
    my $self   = shift;
    my $method = lc($self->f);

    unless (exists $self->templates->{$method})
    {
        $self->error("no Template format for " . $self->f);
        return;
    }

    my $response = '';

    $self->template->process(
                             \$self->templates->{$method},
                             {
                              results => $self->results,
                              pager   => $self->pager,
                              self    => $self,
                             },
                             \$response
                            )
      or croak $self->template->error;

    return $response;
}

sub pager
{
    my $self = shift;

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

    my $results   = shift || $self->results;
    my $this_page = (($self->s - 1) / $self->p) + 1;

    $self->{pager} ||=
      Data::Pageset->new(
                         {
                          total_entries    => $results->Hits,
                          entries_per_page => $self->p,
                          current_page     => $this_page,
                          pages_per_set    => $self->n,
                          mode             => 'slide',
                         }
                        );

    return $self->{pager};

}

1;

__END__