Changeset 2556

Timestamp:

02/28/10 22:57:46 (2 years ago)

Author:

karpet

Message:

add docs and prelim tests

Location:

Search-Query-Dialect-KSx/trunk

Files:

• Makefile.PL (modified) (1 diff)
• lib/Search/Query/Dialect/KSx (added)
• lib/Search/Query/Dialect/KSx.pm (modified) (4 diffs)
• lib/Search/Query/Dialect/KSx/Compiler.pm (added)
• lib/Search/Query/Dialect/KSx/NOTWildcardQuery.pm (added)
• lib/Search/Query/Dialect/KSx/Scorer.pm (added)
• lib/Search/Query/Dialect/KSx/WildcardQuery.pm (added)
• t/01-parser.t (modified) (3 diffs)

Search-Query-Dialect-KSx/trunk/Makefile.PL

@@ -3 +3 @@
 use ExtUtils::MakeMaker;
 
+my $MM_Version = $ExtUtils::MakeMaker::VERSION;
+
+if ( $MM_Version =~ /_/ )    # dev version
+{
+    $MM_Version = eval $MM_Version;
+    die $@ if ($@);
+}
+
 WriteMakefile(
-    NAME                => 'Search::Query::Dialect::KSx',
-    AUTHOR              => q{Peter Karman <karman@cpan.org>},
-    VERSION_FROM        => 'lib/Search/Query/Dialect/KSx.pm',
-    ABSTRACT_FROM       => 'lib/Search/Query/Dialect/KSx.pm',
-    ($ExtUtils::MakeMaker::VERSION >= 6.3002
-      ? ('LICENSE'=> 'perl')
-      : ()),
-    PL_FILES            => {},
+    NAME          => 'Search::Query::Dialect::KSx',
+    AUTHOR        => q{Peter Karman <karman@cpan.org>},
+    VERSION_FROM  => 'lib/Search/Query/Dialect/KSx.pm',
+    ABSTRACT_FROM => 'lib/Search/Query/Dialect/KSx.pm',
+    ( $ExtUtils::MakeMaker::VERSION >= 6.3002
+        ? ( 'LICENSE' => 'perl' )
+        : () ),
+    PL_FILES  => {},
     PREREQ_PM => {
-        'Test::More' => 0,
+        'Test::More'    => 0,
+        'Search::Query' => 0.08,
+        'KinoSearch'    => 0.30_082,
     },
-    dist                => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', },
-    clean               => { FILES => 'Search-Query-Dialect-KSx-*' },
+    dist  => { COMPRESS => 'gzip -9f', SUFFIX => 'gz', },
+    clean => { FILES    => 'Search-Query-Dialect-KSx-*' },
+    ( $MM_Version >= 6.48 ? ( MIN_PERL_VERSION => '5.8.3' ) : () ),
+    ( $MM_Version >= 6.31 ? ( LICENSE          => 'perl' )  : () ),
+    (   $MM_Version <= 6.44 ? ()
+        : ( META_MERGE => {
+                resources => {
+                    license  => 'http://dev.perl.org/licenses/',
+                    homepage => 'http://perl.peknet.com/wiki/SearchTools',
+                    bugtracker =>
+                        'http://rt.cpan.org/NoAuth/Bugs.html?Dist=Search-Query-Dialect-KSx',
+                    repository =>
+                        'http://svn.peknet.com/perl/Search-Query-Dialect-KSx',
+                },
+            }
+        )
+    ),
+
 );

Search-Query-Dialect-KSx/trunk/lib/Search/Query/Dialect/KSx.pm

@@ -6 +6 @@
 use Data::Dump qw( dump );
 use Search::Query::Field::KSx;
+use KinoSearch::Search::ANDQuery;
+use KinoSearch::Search::NoMatchQuery;
+use KinoSearch::Search::NOTQuery;
+use KinoSearch::Search::ORQuery;
+use KinoSearch::Search::PhraseQuery;
+use KinoSearch::Search::RangeQuery;
+use KinoSearch::Search::TermQuery;
+use Search::Query::Dialect::KSx::NOTWildcardQuery;
+use Search::Query::Dialect::KSx::WildcardQuery;
 
 our $VERSION = '0.01';
@@ -24 +33 @@
  my $query = Search::Query->parser( dialect => 'KSx' )->parse('foo');
  print $query;
+ my $ks_query = $query->as_ks_query();
+ my $hits = $ks_searcher->hits( query => $ks_query );
 
 =head1 DESCRIPTION
 
-Search::Query::Dialect::KSx supports the KinoSearch::QueryParser syntax.
+Search::Query::Dialect::KSx extends the KinoSearch::QueryParser syntax
+to support wildcards, proximity and ranges, in addition to the standard
+Search::Query features.
 
 =head1 METHODS
@@ -149 +162 @@
         = $clause->{field}
         ? ( $clause->{field} )
-        : ( @{ $default_field ? @$default_field : [] } );
+        : ( defined $default_field ? @$default_field : () );
 
     # what value
@@ -256 +269 @@
 }
 
+=head2 as_ks_query
+
+Returns the Dialect object as a KinoSearch::Search::Query-based object.
+The Dialect object is walked and converted to a 
+KinoSearch::Searcher-compatible tree.
+
+=cut
+
+sub as_ks_query {
+    my $self = shift;
+    my $tree = shift || $self;
+
+    my @q;
+    foreach my $prefix ( '+', '', '-' ) {
+        my @clauses;
+        my $joiner = $op_map{$prefix};
+        next unless exists $tree->{$prefix};
+        for my $clause ( @{ $tree->{$prefix} } ) {
+            push( @clauses, $self->_ks_clause( $clause, $prefix ) );
+        }
+        next if !@clauses;
+
+        my $ks_class = 'KinoSearch::Search::' . $joiner . 'Query';
+
+        push @q, @clauses == 1
+            ? $clauses[0]
+            : $ks_class->new( children => [ grep {defined} @clauses ] );
+    }
+
+    return @q == 1
+        ? $q[0]
+        : KinoSearch::Search::ANDQuery->new( children => \@q );
+}
+
+sub _ks_clause {
+    my $self   = shift;
+    my $clause = shift;
+    my $prefix = shift;
+
+    #warn dump $clause;
+    #warn "prefix = '$prefix'";
+
+    if ( $clause->{op} eq '()' ) {
+        return $self->as_ks_query( $clause->{value} );
+    }
+
+    # make sure we have a field
+    my $default_field = $self->default_field || $self->parser->default_field;
+    my @fields
+        = $clause->{field}
+        ? ( $clause->{field} )
+        : ( defined $default_field ? @$default_field : () );
+
+    # what value
+    my $value
+        = ref $clause->{value}
+        ? $clause->{value}
+        : $self->_doctor_value($clause);
+
+    # if we have no fields, we can't proceed, because KS
+    # requires a field for every term.
+    if ( !@fields ) {
+        croak
+            "No field specified for term '$value' -- set a default_field in Parser or Dialect";
+    }
+
+    my $wildcard = $self->wildcard;
+
+    # normalize operator
+    my $op = $clause->{op} || ":";
+    if ( $op eq '=' ) {
+        $op = ':';
+    }
+    if ( $prefix eq '-' ) {
+        $op = '!' . $op;
+    }
+    if ( $value =~ m/\%/ ) {
+        $op = $prefix eq '-' ? '!~' : '~';
+    }
+
+    my $quote = $clause->quote || '';
+
+    my @buf;
+NAME: for my $name (@fields) {
+        my $field = $self->_get_field($name);
+
+        if ( defined $field->callback ) {
+            push( @buf, $field->callback->( $field, $op, $value ) );
+            next NAME;
+        }
+
+        #warn dump [ $name, $op, $quote, $value ];
+
+        # invert fuzzy
+        if ( $op eq '!~' || ( $op eq '!:' and $value =~ m/[$wildcard\*\?]/ ) )
+        {
+            $value .= $wildcard unless $value =~ m/\Q$wildcard/;
+
+            push(
+                @buf,
+                Search::Query::Dialect::KSx::NOTWildcardQuery->new(
+                    field => $name,
+                    term  => $value,
+                )
+            );
+        }
+
+        # fuzzy
+        elsif ( $op eq '~'
+            || ( $op eq ':' and $value =~ m/[$wildcard\*\?]/ ) )
+        {
+            $value .= $wildcard unless $value =~ m/\Q$wildcard/;
+
+            push(
+                @buf,
+                Search::Query::Dialect::KSx::WildcardQuery->new(
+                    field => $name,
+                    term  => $value,
+                )
+            );
+        }
+
+        # invert
+        elsif ( $op eq '!:' ) {
+            push(
+                @buf,
+                KinoSearch::Search::NOTQuery->new(
+                    field => $name,
+                    term  => $value,
+                )
+            );
+        }
+
+        # range
+        elsif ( $op eq '..' ) {
+            if ( ref $value ne 'ARRAY' or @$value != 2 ) {
+                croak "range of values must be a 2-element ARRAY";
+            }
+
+            my $range_query = KinoSearch::Search::RangeQuery->new(
+                field         => $name,
+                lower_term    => $value->[0],
+                upper_term    => $value->[1],
+                include_lower => 1,
+                include_upper => 1,
+            );
+
+            push( @buf, $range_query );
+
+        }
+
+        # invert range
+        elsif ( $op eq '!..' ) {
+            if ( ref $value ne 'ARRAY' or @$value != 2 ) {
+                croak "range of values must be a 2-element ARRAY";
+            }
+
+            croak "NOT Range query not yet supported";
+        }
+
+        # standard
+        else {
+            push(
+                @buf,
+                KinoSearch::Search::TermQuery->new(
+                    field => $name,
+                    term  => $value,
+                )
+            );
+        }
+    }
+    if ( @buf == 1 ) {
+        return $buf[0];
+    }
+    my $joiner = $prefix eq '-' ? 'AND' : 'OR';
+    my $ks_class = 'KinoSearch::Search::' . $joiner . 'Query';
+    return $ks_class->new( children => \@buf );
+}
+
 =head2 field_class
 

Search-Query-Dialect-KSx/trunk/t/01-parser.t

@@ -3 +3 @@
 use strict;
 use warnings;
-use Test::More tests => 47;
+use Test::More tests => 53;
 use Data::Dump qw( dump );
 
@@ -22 +22 @@
 
 is( $query1, qq/foo:bar/, "query1 string" );
+
+ok( my $ks_query1 = $query1->as_ks_query(), "as_ks_query" );
+ok( $ks_query1->isa('KinoSearch::Search::TermQuery'),
+    "ks_query isa TermQuery" );
 
 ok( my $query2 = $parser->parse('foo:bar'), "query2" );
@@ -181 +185 @@
 );
 is( $query_alias_for2, qq/foo/, "query expanded omits aliases" );
+
+# wildcards
+ok( my $fuzzy_parser = Search::Query->parser(
+        dialect          => 'KSx',
+        query_class_opts => { default_field => 'field1' }
+    ),
+    "new fuzzy parser"
+);
+ok( my $fuzzy_query = $fuzzy_parser->parse('foo*'), "parse foo*" );
+ok( my $fuzzy_ks    = $fuzzy_query->as_ks_query,    "fuzzy as_ks_query" );
+is( $fuzzy_ks->to_string, $fuzzy_query->stringify,
+    "stringification matches" );