KSx::Searcher::Abstract - build searches from Perl data structures

 0.002

  use KSx::Searcher::Abstract;

  my $searcher = KSx::Searcher::Abstract->new(%args);

  my $hits = $searcher->search(\%query, \%options);

  $searcher->search({ foo => 1, bar => 2 })

  my $hits = $searcher->search(\%query, \%options);

  my %arg = $searcher->build_abstract(\%query, \%options);

  { foo => 1 }

  { foo => { '='  => 1 } } # foo = 1, equivalent to the first example
  { foo => { '!=' => 1 } } # foo != 1

    perldoc KSx::Searcher::Abstract

use strict;
use warnings;

package KSx::Searcher::Abstract;

our $VERSION = '0.002';
use 5.008003; # KinoSearch requires this

use base qw(KinoSearch::Searcher);

use KinoSearch::Search::BooleanQuery;
use KinoSearch::Search::MatchFieldQuery;
use KinoSearch::Search::TermQuery;
use KinoSearch::Search::PolyFilter;
use KinoSearch::Search::RangeFilter;
# we should figure out a way to use this for better performance
#use aliased 'KinoSearch::Search::QueryFilter';
use KinoSearch::Search::SortSpec;
use KinoSearch::Index::Term;

sub search {
  my ($self, $query, $options) = @_;
  unless ($query) {
    Carp::croak "'query' argument is mandatory for search";
  }
  $options ||= {};
  $self->SUPER::search(
    $self->build_abstract($query, $options)
  );
}

sub _clause_is  { shift; return query => _term(@_), occur => 'MUST' }
sub _clause_not { shift; return query => _term(@_), occur => 'MUST_NOT' }

sub _term {
  KinoSearch::Search::TermQuery->new(
    term => KinoSearch::Index::Term->new(@_)
  )
}  

sub _process_hash {
  my ($self, $key, $val, $bq) = @_;
  for my $k (keys %$val) {
    if ($k eq '=') { 
      $bq->add_clause($self->_clause_is($key, $val));
    } elsif ($k eq '!=') {
      $bq->add_clause($self->_clause_not($key, $val));
    } else {
      die "unhandled operator: $k";
    }
  }
}

sub build_abstract {
  my ($self, $query, $options) = @_;
   
  Carp::croak "can't process empty query" unless %$query;
  my $bq = KinoSearch::Search::BooleanQuery->new;
  
  # TODO: allow arrayref queries
  for my $key (sort keys %$query) {
    my $val = $query->{$key};
    if (ref $val eq 'HASH') {
      $self->_process_hash($key, $val, $bq);
    } elsif (not ref $val) {
      $bq->add_clause($self->_clause_is($key, $val));
    } else {
      Carp::croak "unhandled value: $val";
    }
  }

  my $sort_spec;
  # XXX I hate this format.  It is still too wordy.  It should change.
  if (my $sort = delete $options->{sort}) {
    $sort_spec = KinoSearch::Search::SortSpec->new;
    for (@$sort) { $sort_spec->add(%$_) }
  }
  return (
    query => $bq,
    # filter => ???
    %$options,
    $sort_spec ? (sort_spec => $sort_spec) : (),
  )
}

1;
__END__