ferret 0.1.1 → 0.1.2

data/lib/ferret/analysis/token.rb

@@ -75,5 +75,13 @@ module Ferret::Analysis
       end
       @position_increment = pos_inc
     end
+
+    # Returns a string representation of the token with all the attributes.
+    def to_s
+      buf = "#{term_text}:#{start_offset}->#{end_offset}"
+      buf << "(pos_inc=#{@position_increment})" if (@position_increment != 1)
+      buf << "(type=#{@type})" if (@type != "word")
+      buf
+    end
   end
 end

data/lib/ferret/analysis/tokenizers.rb

@@ -20,16 +20,16 @@ module Ferret::Analysis
   # An abstract base class for simple regular expression oriented
   # tokenizers. Very powerful tokenizers can be created using this class as
   # can be seen from the StandardTokenizer class. Bellow is an example of a
-  # simple implementation of a LetterTokenizer using an RETokenizer.
+  # simple implementation of a LetterTokenizer using an RegExpTokenizer.
   # Basically, a token is a sequence of alphabetic characters separated by
   # one or more non-alphabetic characters.
   #
-  #   class LetterTokenizer < RETokenizer
+  #   class LetterTokenizer < RegExpTokenizer
   #       def token_re()
   #         /[a-zA-Z]+/
   #       end
   #   end
-  class RETokenizer < Tokenizer
+  class RegExpTokenizer < Tokenizer
 
     # Initialize with an IO implementing input such as a file.
     #
@@ -76,10 +76,10 @@ module Ferret::Analysis
   # A LetterTokenizer is a tokenizer that divides text at non-letters.
   # That's to say, it defines tokens as maximal strings of adjacent letters,
   # as defined by the regular expression _/[a-zA-Z]+/_.
-  class LetterTokenizer < RETokenizer
+  class LetterTokenizer < RegExpTokenizer
     protected
       # Collects only characters which satisfy the regular expression
-    # _/[a-zA-Z]+/_.
+      # _/[a-zA-Z]+/_.
       def token_re()
         /[a-zA-Z]+/
       end
@@ -97,7 +97,7 @@ module Ferret::Analysis
 
   # A WhiteSpaceTokenizer is a tokenizer that divides text at whiteSpace.
   # Adjacent sequences of non-WhiteSpace characters form tokens.
-  class WhiteSpaceTokenizer < RETokenizer
+  class WhiteSpaceTokenizer < RegExpTokenizer
     protected
       # Collects only characters which are not spaces tabs or carraige returns
       def token_re()

data/lib/ferret/index/index.rb

@@ -1,9 +1,81 @@
 module Ferret::Index
+  # This is a simplified interface to the index. See the TUTORIAL for more
+  # information on how to use this class.
   class Index
     include Ferret::Store
     include Ferret::Search
     include Ferret::Document
 
+    # If you create an Index without any options, it'll simply create an index
+    # in memory. But this class is highly configurable and every option that
+    # you can supply to IndexWriter and QueryParser, you can also set here.
+    #
+    # === Options
+    #
+    # path::                 A string representing the path to the index
+    #                        directory. If you are creating the index for the
+    #                        first time the directory will be created if it's
+    #                        missing. You should not choose a directory which
+    #                        contains other files.
+    # create_if_missing::    Create the index if no index is found in the
+    #                        specified directory. Otherwise, use the existing
+    #                        index. This defaults to true and has no effect on
+    #                        in memory indexes.
+    # create::               Creates the index, even if one already exists.
+    #                        That means any existing index will be deleted.
+    #                        This option defaults to false and has no effect
+    #                        for in memory indexes. It is probably better to
+    #                        use the create_if_missing option.
+    # default_field::        This specifies the default field that will be
+    #                        used when you add a simple string to the index
+    #                        using #add_document. This will also be used for
+    #                        default_search_field unless you set it
+    #                        explicitly.
+    # default_search_field:: This specifies the field or fields that will be 
+    #                        searched by the query parser. You can use a
+    #                        string to specify one field, eg, "title". Or you
+    #                        can specify multiple fields with a String -
+    #                        "title|content" - or with an Array - ["title",
+    #                        "content"]. This defaults to the value passed in
+    #                        for default_field. If default_field is nil then
+    #                        the default is "*" which signifies all fields in
+    #                        the index.
+    # analyzer::             Sets the default analyzer for the index. This is
+    #                        used by both the IndexWriter and the QueryParser
+    #                        to tokenize the input. The default is the
+    #                        StandardAnalyzer.
+    # dir::                  This is an Ferret::Store::Directory object. This
+    #                        can be useful if you have an already existing
+    #                        in-memory index which you'd like to read with
+    #                        this class. If you want to create a new index,
+    #                        you are better off passing in a path.
+    # close_dir::            This specifies whether you would this class to
+    #                        close the index directory when this class is
+    #                        closed. This only has any meaning when you pass
+    #                        in a directory object in the *dir* option, in
+    #                        which case it defaults to false. Otherwise it is
+    #                        always true.
+    # occur_default::        Set to either BooleanClause::Occur::SHOULD
+    #                        (default) or BooleanClause::Occur::MUST to
+    #                        specify the default Occur operator.
+    # wild_lower::           Set to false if you don't want the terms in fuzzy
+    #                        and wild queries to be set to lower case. You
+    #                        should do this if your analyzer doesn't downcase.
+    #                        The default is true.
+    # default_slop::         Set the default slop for phrase queries. This
+    #                        defaults to 0.
+    # 
+    # Some examples;
+    #
+    #   index = Index::Index.new(:analyzer => WhiteSpaceAnalyzer.new())
+    #
+    #   index = Index::Index.new(:path => '/path/to/index',
+    #                            :create_if_missing => false)
+    #
+    #   index = Index::Index.new(:dir => directory,
+    #                            :close_dir => false
+    #                            :default_slop => 2)
+    #   
     def initialize(options = {})
       if options[:path]
         options[:create_if_missing] = true if options[:create_if_missing].nil? 
@@ -23,10 +95,13 @@ module Ferret::Index
       @reader = nil
       @options.delete(:create) # only want to create the first time if at all
       @close_dir = @options.delete(:close_dir) || false # we'll hold this here
+      @default_search_field = (@options[:default_search_field] || \
+                               @options[:default_field] || "*")
       @default_field = @options[:default_field] || ""
       @open = true
     end
 
+    # Closes this index by closing its associated reader and writer objects.
     def close
       if not @open
         raise "tried to close an already closed directory"
@@ -63,6 +138,47 @@ module Ferret::Index
     # the local analyzer if provided.  If the document contains more than
     # IndexWriter::MAX_FIELD_LENGTH terms for a given field, the remainder are
     # discarded.
+    #
+    # There are three ways to add a document to the index. 
+    # To add a document you can simply add a string or an array of strings.
+    # This will store all the strings in the "" (ie empty string) field
+    # (unless you specify the default_field when you create the index).
+    #
+    #   index << "This is a new document to be indexed"
+    #   index << ["And here", "is another", "new document", "to be indexed"]
+    # 
+    # But these are pretty simple documents. If this is all you want to index you
+    # could probably just use SimpleSearch. So let's give our documents some fields;
+    # 
+    #   index << {:title => "Programming Ruby", :content => "blah blah blah"}
+    #   index << {:title => "Programming Ruby", :content => "yada yada yada"}
+    # 
+    # Or if you are indexing data stored in a database, you'll probably want to
+    # store the id;
+    # 
+    #   index << {:id => row.id, :title => row.title, :date => row.date}
+    # 
+    # The methods above while store all of the input data as well tokenizing and
+    # indexing it. Sometimes we won't want to tokenize (divide the string into
+    # tokens) the data. For example, we might want to leave the title as a complete
+    # string and only allow searchs for that complete string. Sometimes we won't
+    # want to store the data as it's already stored in the database so it'll be a
+    # waste to store it in the index. Or perhaps we are doing without a database and 
+    # using Ferret to store all of our data, in which case we might not want to
+    # index it. For example, if we are storing images in the index, we won't want to
+    # index them. All of this can be done using Ferret's Ferret::Document module.
+    # eg;
+    # 
+    #   include Ferret::Document
+    #   doc = Document.new
+    #   doc << Field.new("id",    row.id,    Field::Store::NO,  Field::Index::UNTOKENIZED)
+    #   doc << Field.new("title", row.title, Field::Store::YES, Field::Index::UNTOKENIZED)
+    #   doc << Field.new("data",  row.data,  Field::Store::YES, Field::Index::TOKENIZED)
+    #   doc << Field.new("image", row.image, Field::Store::YES, Field::Index::NO)
+    #   index << doc
+    # 
+    # You can also compress the data that you are storing or store term vectors with
+    # the data. Read more about this in Ferret::Document::Field.
     def add_document(doc, analyzer = nil)
       ensure_writer_open()
       fdoc = nil
@@ -104,14 +220,16 @@ module Ferret::Index
     # num_docs:: The number of results returned. Default is 10
     # sort::     an array of SortFields describing how to sort the results.
     def search(query, options = {})
+      ensure_searcher_open()
       if query.is_a?(String)
         if @qp.nil?
-          @qp = Ferret::QueryParser.new(@default_field, options)
+          @qp = Ferret::QueryParser.new(@default_search_field, @options)
         end
+        # we need to set this ever time, in case a new field has been added
+        @qp.fields = @reader.get_field_names.to_a
         query = @qp.parse(query)
       end
 
-      ensure_searcher_open()
       return @searcher.search(query, options)
     end
 

data/lib/ferret/index/index_writer.rb

@@ -53,12 +53,15 @@ module Index
     # +dir+, replacing the index already there, if any.
     # NOTE:: all options are passed in a hash.
     #
-    # dir::      the index directory
-    # analyzer:: the analyzer to use. Defaults to StandardAnalyzer.
-    # create::   +true+ to create the index or overwrite the existing one 
-    #            +false+ to append to the existing index
+    # dir::               the index directory
+    # analyzer::          the analyzer to use. Defaults to StandardAnalyzer.
+    # create::            +true+ to create the index or overwrite the existing
+    #                     one +false+ to append to the existing index
     # create_if_missing:: +true+ to create the index if it's missing
     #                     +false+ to throw an IOError if it's missing
+    # close_dir::         This specifies whether you would this class to close
+    #                     the index directory when this class is closed. The
+    #                     default is false.
     def initialize(dir, options = {})
       super()
       create = options[:create]||false

data/lib/ferret/index/multi_reader.rb

@@ -178,7 +178,7 @@ module Ferret
       end
 
       # See IndexReader#get_field_names
-      def get_field_names(field_option)
+      def get_field_names(field_option = IndexReader::FieldOption::ALL)
         # maintain a unique set of field names
         field_set = Set.new
         @sub_readers.each do |reader|

data/lib/ferret/index/segment_reader.rb

@@ -188,7 +188,7 @@ module Ferret::Index
     end
 
     # See IndexReader#get_field_names
-    def get_field_names(field_option) 
+    def get_field_names(field_option = IndexReader::FieldOption::ALL) 
       field_set = Set.new
       @field_infos.each do |fi|
         if (field_option == IndexReader::FieldOption::ALL) 

data/lib/ferret/query_parser.rb

@@ -106,12 +106,12 @@ module Ferret
   #
   # Some examples;
   #
-  #   '+sport:ski -sport:snowboard sport:toboggen'
+  #   '+sport:ski -sport:snowboard sport:toboggan'
   #   '+ingredient:chocolate +ingredient:strawberries -ingredient:wheat'
   #
   # You may also use the boolean operators "AND", "&&", "OR" and "||". eg;
   #
-  #   'sport:ski AND NOT sport:snowboard OR sport:toboggen'
+  #   'sport:ski AND NOT sport:snowboard OR sport:toboggan'
   #   'ingredient:chocolate AND ingredient:strawberries AND NOT ingredient:wheat'
   #
   # You can set the default operator when you create the query parse.
@@ -128,10 +128,10 @@ module Ferret
   #
   # You can also do open ended queries like this;
   #
-  #   'date:[20050725|' # all dates >= 20050725
-  #   'date:{20050725|' # all dates >  20050725
-  #   'date:|20050905]' # all dates <= 20050905
-  #   'date:|20050905}' # all dates <  20050905
+  #   'date:[20050725>' # all dates >= 20050725
+  #   'date:{20050725>' # all dates >  20050725
+  #   'date:<20050905]' # all dates <= 20050905
+  #   'date:<20050905}' # all dates <  20050905
   #
   # Or like this;
   #
@@ -233,18 +233,26 @@ module Ferret
     #
     # default_field:: all queries without a specified query string are run on
     #                 this field.
-    # options:: the following options exist;
     #
-    # * *analyzer* the analyzer is used to break phrases up into terms and
-    #   to turn terms in tokens recognized in the index. Analysis::Analyzer
-    #   is the default
-    # * *occur_default* Set to either BooleanClause::Occur::SHOULD (default)
-    #   or BooleanClause::Occur::MUST to specify the default Occur operator.
-    # * *wild_lower* Set to false if you don't want the terms in fuzzy and
-    #   wild queries to be set to lower case. You should do this if your
-    #   analyzer doesn't downcase. The default is true.
-    # * *default_slop* Set the default slop for phrase queries. This defaults
-    #   to 0.
+    # options::       the following options exist and should be passed in as a
+    #                 hash. eg;
+    #
+    #   qp = QueryParser.new("*", { :analyzer => WhiteSpaceAnalyzer.new(),
+    #                               :wild_lower => true})
+    #
+    # === Options
+    #
+    # analyzer::      The analyzer is used to break phrases up into terms and
+    #                 to turn terms in tokens recognized in the index.
+    #                 Analysis::Analyzer is the default
+    # occur_default:: Set to either BooleanClause::Occur::SHOULD (default)
+    #                 or BooleanClause::Occur::MUST to specify the default
+    #                 Occur operator.
+    # wild_lower::    Set to false if you don't want the terms in fuzzy and
+    #                 wild queries to be set to lower case. You should do this
+    #                 if your analyzer doesn't downcase. The default is true.
+    # default_slop::  Set the default slop for phrase queries. This defaults
+    #                 to 0.
     def initialize(default_field = "", options = {})
     end
 

data/lib/ferret/query_parser/query_parser.tab.rb

@@ -1,7 +1,7 @@
 #
 # DO NOT MODIFY!!!!
 # This file is automatically generated by racc 1.4.4
-# from racc grammer file "lib/ferret/query_parser/query_parser.y".
+# from racc grammer file "query_parser.y".
 #
 
 require 'racc/parser'
@@ -11,8 +11,8 @@ module Ferret
 
   class QueryParser < Racc::Parser
 
-module_eval <<'..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e53', 'lib/ferret/query_parser/query_parser.y', 121
-  attr_accessor :default_field
+module_eval <<'..end query_parser.y modeval..id2aa118b008', 'query_parser.y', 126
+  attr_accessor :default_field, :fields
 
   # true if you want to downcase wild card queries. This is set to try by
   # default.
@@ -21,13 +21,17 @@ module_eval <<'..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e5
   def wild_lower?() @wild_lower end
 
 
-  def initialize(default_field = "", options = {})
+  def initialize(default_field = "*", options = {})
     @yydebug = true
+    if default_field.is_a?(String) and default_field.index("|")
+      default_field = default_field.split("|")
+    end
     @field = @default_field = default_field
     @analyzer = options[:analyzer] || Analysis::Analyzer.new
     @wild_lower = options[:wild_lower].nil? ? true : options[:wild_lower]
     @occur_default = options[:occur_default] || BooleanClause::Occur::SHOULD
     @default_slop = options[:default_slop] || 0
+    @fields = options[:fields]||[]
   end
 
   RESERVED = {
@@ -156,43 +160,47 @@ module_eval <<'..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e5
     return new_str.pack("c*")  
   end
 
-  def get_range_query(start_word, end_word, inc_upper, inc_lower)
-    return RangeQuery.new(@field, start_word, end_word, inc_upper, inc_lower)
+  def get_range_query(field, start_word, end_word, inc_upper, inc_lower)
+     RangeQuery.new(field, start_word, end_word, inc_upper, inc_lower)
   end
 
-  def get_term_query(word)
+  def get_term_query(field, word)
     tokens = []
-    stream = @analyzer.token_stream(@field, word)
+    stream = @analyzer.token_stream(field, word)
     while token = stream.next
       tokens << token
     end
     if tokens.length == 0
       return nil
     elsif tokens.length == 1
-      return TermQuery.new(Term.new(@field, tokens[0].term_text))
+      return TermQuery.new(Term.new(field, tokens[0].term_text))
     else
       pq = PhraseQuery.new()
       tokens.each do |token|
-        pq.add(Term.new(@field, token.term_text), nil, token.position_increment)
+        pq.add(Term.new(field, token.term_text), nil, token.position_increment)
       end
       return pq
     end
   end
 
-  def get_fuzzy_query(word, min_sim = nil)
+  def get_fuzzy_query(field, word, min_sim = nil)
     tokens = []
-    stream = @analyzer.token_stream(@field, word)
+    stream = @analyzer.token_stream(field, word)
     if token = stream.next # only makes sense to look at one term for fuzzy
       if min_sim
-        return FuzzyQuery.new(Term.new(@field, token.term_text), min_sim.to_f)
+        return FuzzyQuery.new(Term.new(field, token.term_text), min_sim.to_f)
       else
-        return FuzzyQuery.new(Term.new(@field, token.term_text))
+        return FuzzyQuery.new(Term.new(field, token.term_text))
       end
     else
       return nil
     end
   end
 
+  def get_wild_query(field, regexp)
+    WildcardQuery.new(Term.new(field, regexp))
+  end
+
   def add_multi_word(words, word)
     last_word = words[-1]
     if not last_word.is_a?(Array)
@@ -202,7 +210,7 @@ module_eval <<'..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e5
     return words
   end
 
-  def get_normal_phrase_query(positions)
+  def get_normal_phrase_query(field, positions)
     pq = PhraseQuery.new()
     pq.slop = @default_slop
     pos_inc = 0
@@ -212,13 +220,13 @@ module_eval <<'..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e5
         pos_inc += 1
         next
       end
-      stream = @analyzer.token_stream(@field, position)
+      stream = @analyzer.token_stream(field, position)
       tokens = []
       while token = stream.next
         tokens << token
       end
       tokens.each do |token|
-        pq.add(Term.new(@field, token.term_text), nil,
+        pq.add(Term.new(field, token.term_text), nil,
                token.position_increment + pos_inc)
         pos_inc = 0
       end
@@ -226,7 +234,7 @@ module_eval <<'..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e5
     return pq
   end
 
-  def get_multi_phrase_query(positions)
+  def get_multi_phrase_query(field, positions)
     mpq = MultiPhraseQuery.new()
     mpq.slop = @default_slop
     pos_inc = 0
@@ -240,21 +248,21 @@ module_eval <<'..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e5
         position.compact! # it doesn't make sense to have an empty spot here
         terms = []
         position.each do |word|
-          stream = @analyzer.token_stream(@field, word)
+          stream = @analyzer.token_stream(field, word)
           if token = stream.next # only put one term per word
-            terms << Term.new(@field, token.term_text)
+            terms << Term.new(field, token.term_text)
           end
         end
         mpq.add(terms, nil, pos_inc + 1) # must go at least one forward
         pos_inc = 0
       else
-        stream = @analyzer.token_stream(@field, position)
+        stream = @analyzer.token_stream(field, position)
         tokens = []
         while token = stream.next
           tokens << token
         end
         tokens.each do |token|
-          mpq.add([Term.new(@field, token.term_text)], nil,
+          mpq.add([Term.new(field, token.term_text)], nil,
                  token.position_increment + pos_inc)
           pos_inc = 0
         end
@@ -265,7 +273,7 @@ module_eval <<'..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e5
 
   def get_phrase_query(positions, slop = nil)
     if positions.size == 1 and not positions[0].is_a?(Array)
-      return get_term_query(words[0])
+      return _get_term_query(positions[0])
     end
 
     multi_phrase = false
@@ -278,14 +286,16 @@ module_eval <<'..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e5
       end
     end
 
-    q = nil
-    if not multi_phrase
-      q = get_normal_phrase_query(positions.flatten)
-    else
-      q = get_multi_phrase_query(positions)
+    return do_multiple_fields() do |field|
+      q = nil
+      if not multi_phrase
+        q = get_normal_phrase_query(field, positions.flatten)
+      else
+        q = get_multi_phrase_query(field, positions)
+      end
+      q.slop = slop if slop
+      next q
     end
-    q.slop = slop if slop
-    return q
   end
 
   def add_and_clause(clauses, clause)
@@ -323,7 +333,7 @@ module_eval <<'..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e5
       return clauses[0].query
     end
     bq = BooleanQuery.new()
-    clauses.each {|clause|   bq << clause }
+    clauses.each {|clause| bq << clause }
     return bq                
   end                        
                              
@@ -332,131 +342,171 @@ module_eval <<'..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e5
     return BooleanClause.new(query, occur)
   end
 
-..end lib/ferret/query_parser/query_parser.y modeval..id4dd1430e53
+  def do_multiple_fields()
+    # set @field to all fields if @field is the multi-field operator
+    @field = @fields if @field.is_a?(String) and @field == "*"
+    if @field.is_a?(String)
+      return yield(@field)
+    elsif @field.size == 1
+      return yield(@field[0])
+    else
+      bq = BooleanQuery.new()
+      @field.each do |field|
+        q = yield(field)
+        bq << BooleanClause.new(q) if q
+      end
+      return bq                
+    end
+  end
+
+  def method_missing(meth, *args)
+    if meth.to_s =~ /_(get_[a-z_]+_query)/
+      do_multiple_fields() do |field|
+        send($1, *([field] + args))
+      end
+    else
+      raise NoMethodError.new("No such method #{meth} in #{self.class}", meth, args)
+    end
+  end
+
+
+..end query_parser.y modeval..id2aa118b008
 
 ##### racc 1.4.4 generates ###
 
 racc_reduce_table = [
  0, 0, :racc_error,
- 1, 25, :_reduce_1,
- 1, 26, :_reduce_2,
- 3, 26, :_reduce_3,
- 3, 26, :_reduce_4,
- 2, 26, :_reduce_5,
- 2, 27, :_reduce_6,
- 2, 27, :_reduce_7,
- 1, 27, :_reduce_8,
+ 1, 26, :_reduce_1,
+ 1, 27, :_reduce_2,
+ 3, 27, :_reduce_3,
+ 3, 27, :_reduce_4,
+ 2, 27, :_reduce_5,
+ 2, 28, :_reduce_6,
+ 2, 28, :_reduce_7,
+ 1, 28, :_reduce_8,
+ 1, 30, :_reduce_none,
+ 3, 30, :_reduce_10,
+ 1, 29, :_reduce_none,
+ 3, 29, :_reduce_12,
+ 1, 29, :_reduce_none,
+ 1, 29, :_reduce_none,
+ 1, 29, :_reduce_none,
  1, 29, :_reduce_none,
- 3, 29, :_reduce_10,
- 1, 28, :_reduce_none,
- 3, 28, :_reduce_12,
- 1, 28, :_reduce_none,
- 1, 28, :_reduce_none,
- 1, 28, :_reduce_none,
- 1, 28, :_reduce_none,
- 1, 30, :_reduce_17,
- 3, 30, :_reduce_18,
- 2, 30, :_reduce_19,
- 1, 34, :_reduce_20,
- 0, 36, :_reduce_21,
- 4, 31, :_reduce_22,
- 1, 35, :_reduce_23,
- 3, 32, :_reduce_24,
+ 1, 31, :_reduce_17,
+ 3, 31, :_reduce_18,
+ 2, 31, :_reduce_19,
+ 1, 35, :_reduce_20,
+ 0, 37, :_reduce_21,
+ 4, 32, :_reduce_22,
+ 0, 38, :_reduce_23,
+ 0, 39, :_reduce_24,
  5, 32, :_reduce_25,
- 2, 32, :_reduce_26,
- 4, 32, :_reduce_27,
- 1, 37, :_reduce_28,
- 2, 37, :_reduce_29,
- 3, 37, :_reduce_30,
- 3, 37, :_reduce_31,
- 4, 33, :_reduce_32,
- 4, 33, :_reduce_33,
- 4, 33, :_reduce_34,
- 4, 33, :_reduce_35,
- 3, 33, :_reduce_36,
- 3, 33, :_reduce_37,
- 3, 33, :_reduce_38,
- 3, 33, :_reduce_39,
- 2, 33, :_reduce_40,
- 3, 33, :_reduce_41,
- 3, 33, :_reduce_42,
- 2, 33, :_reduce_43 ]
-
-racc_reduce_n = 44
-
-racc_shift_n = 73
+ 1, 36, :_reduce_26,
+ 3, 36, :_reduce_27,
+ 3, 33, :_reduce_28,
+ 5, 33, :_reduce_29,
+ 2, 33, :_reduce_30,
+ 4, 33, :_reduce_31,
+ 1, 40, :_reduce_32,
+ 2, 40, :_reduce_33,
+ 3, 40, :_reduce_34,
+ 3, 40, :_reduce_35,
+ 4, 34, :_reduce_36,
+ 4, 34, :_reduce_37,
+ 4, 34, :_reduce_38,
+ 4, 34, :_reduce_39,
+ 3, 34, :_reduce_40,
+ 3, 34, :_reduce_41,
+ 3, 34, :_reduce_42,
+ 3, 34, :_reduce_43,
+ 2, 34, :_reduce_44,
+ 3, 34, :_reduce_45,
+ 3, 34, :_reduce_46,
+ 2, 34, :_reduce_47 ]
+
+racc_reduce_n = 48
+
+racc_shift_n = 78
 
 racc_action_table = [
-     7,    10,    61,    47,    38,    36,    48,    21,     3,    41,
-    60,     6,     9,    12,    14,    16,    18,    37,    35,     1,
-     7,    10,    33,    34,    58,    59,    40,    21,     3,    45,
-   -23,     6,     9,    12,    14,    16,    18,     7,    10,     1,
-    55,    42,    30,    56,    21,     3,    44,    28,     6,     9,
-    12,    14,    16,    18,    43,    57,     1,     7,    10,    33,
-    34,    70,    71,    39,    21,     3,    63,    64,     6,     9,
-    12,    14,    16,    18,     7,    10,     1,    27,    62,    25,
-    66,    21,     3,    67,    68,     6,     9,    12,    14,    16,
-    18,     7,    10,     1,    69,    23,    72,   nil,    21,     3,
-   nil,   nil,     6,     9,    12,    14,    16,    18,    21,     3,
-     1,   nil,     6,     9,    12,    14,    16,    18,    21,     3,
-     1,   nil,     6,     9,    12,    14,    16,    18,    21,     3,
-     1,   nil,     6,     9,    12,    14,    16,    18,    52,   nil,
-     1,   nil,   nil,    49,    50,   nil,    51 ]
+     8,    10,    60,    59,    75,    74,    50,    21,     2,    25,
+   -26,     7,     9,    41,    13,    15,    17,    19,     8,    10,
+     3,    43,    64,    26,   -26,    21,     2,    40,    38,     7,
+     9,    63,    13,    15,    17,    19,     8,    10,     3,    36,
+    46,    53,    37,    21,     2,    49,    34,     7,     9,    45,
+    13,    15,    17,    19,    58,    57,     3,     8,    10,    31,
+    33,    54,    55,    56,    21,     2,    44,    48,     7,     9,
+    61,    13,    15,    17,    19,    67,    66,     3,     8,    10,
+    31,    33,    62,    42,    65,    21,     2,    39,    30,     7,
+     9,    70,    13,    15,    17,    19,     8,    10,     3,    71,
+    72,    73,    24,    21,     2,    77,   nil,     7,     9,   nil,
+    13,    15,    17,    19,    21,     2,     3,   nil,     7,     9,
+   nil,    13,    15,    17,    19,    21,     2,     3,   nil,     7,
+     9,   nil,    13,    15,    17,    19,    21,     2,     3,   nil,
+     7,     9,   nil,    13,    15,    17,    19,    21,     2,     3,
+   nil,     7,     9,   nil,    13,    15,    17,    19,   nil,   nil,
+     3 ]
 
 racc_action_check = [
-     0,     0,    41,    27,    14,    12,    28,     0,     0,    18,
-    41,     0,     0,     0,     0,     0,     0,    14,    12,     0,
-    24,    24,    24,    24,    40,    40,    16,    24,    24,    24,
-    21,    24,    24,    24,    24,    24,    24,     3,     3,    24,
-    35,    21,     9,    37,     3,     3,    23,     9,     3,     3,
-     3,     3,     3,     3,    23,    39,     3,    11,    11,    11,
-    11,    61,    61,    15,    11,    11,    44,    44,    11,    11,
-    11,    11,    11,    11,    34,    34,    11,     8,    42,     5,
-    48,    34,    34,    49,    50,    34,    34,    34,    34,    34,
-    34,    33,    33,    34,    51,     1,    67,   nil,    33,    33,
-   nil,   nil,    33,    33,    33,    33,    33,    33,    10,    10,
-    33,   nil,    10,    10,    10,    10,    10,    10,    25,    25,
-    10,   nil,    25,    25,    25,    25,    25,    25,     7,     7,
-    25,   nil,     7,     7,     7,     7,     7,     7,    29,   nil,
-     7,   nil,   nil,    29,    29,   nil,    29 ]
+     0,     0,    38,    38,    64,    64,    30,     0,     0,     6,
+    21,     0,     0,    17,     0,     0,     0,     0,     2,     2,
+     0,    21,    42,     6,    21,     2,     2,    17,    15,     2,
+     2,    42,     2,     2,     2,     2,    33,    33,     2,    13,
+    24,    34,    15,    33,    33,    28,    13,    33,    33,    24,
+    33,    33,    33,    33,    37,    35,    33,    23,    23,    23,
+    23,    35,    35,    35,    23,    23,    23,    26,    23,    23,
+    39,    23,    23,    23,    23,    46,    46,    23,    12,    12,
+    12,    12,    40,    19,    43,    12,    12,    16,    11,    12,
+    12,    53,    12,    12,    12,    12,    31,    31,    12,    54,
+    55,    56,     3,    31,    31,    72,   nil,    31,    31,   nil,
+    31,    31,    31,    31,    49,    49,    31,   nil,    49,    49,
+   nil,    49,    49,    49,    49,    25,    25,    49,   nil,    25,
+    25,   nil,    25,    25,    25,    25,     8,     8,    25,   nil,
+     8,     8,   nil,     8,     8,     8,     8,    10,    10,     8,
+   nil,    10,    10,   nil,    10,    10,    10,    10,   nil,   nil,
+    10 ]
 
 racc_action_pointer = [
-    -3,    85,   nil,    34,   nil,    77,   nil,   118,    77,    32,
-    98,    54,    -5,   nil,    -6,    54,    16,   nil,    -1,   nil,
-   nil,    28,   nil,    36,    17,   108,   nil,     3,    -7,   128,
-   nil,   nil,   nil,    88,    71,    30,   nil,    33,   nil,    45,
-     4,    -8,    68,   nil,    46,   nil,   nil,   nil,    70,    70,
-    67,    84,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    41,   nil,   nil,   nil,   nil,   nil,    86,   nil,   nil,
-   nil,   nil,   nil ]
+    -3,   nil,    15,    92,   nil,   nil,     7,   nil,   126,   nil,
+   137,    88,    75,    29,   nil,    18,    78,     3,   nil,    73,
+   nil,     8,   nil,    54,    30,   115,    57,   nil,    43,   nil,
+     6,    93,   nil,    33,    28,    45,   nil,    44,   -19,    60,
+    72,   nil,    12,    74,   nil,   nil,    54,   nil,   nil,   104,
+   nil,   nil,   nil,    81,    89,    87,    82,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   -17,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    95,   nil,   nil,   nil,   nil,   nil ]
 
 racc_action_default = [
-   -44,   -44,   -15,   -44,   -16,   -44,   -20,   -44,   -44,   -44,
-   -44,    -1,   -44,    -2,   -44,    -9,   -44,    -8,   -44,   -11,
-   -13,   -17,   -14,   -44,   -44,   -44,    -6,   -44,   -26,   -44,
-   -28,    -7,    -5,   -44,   -44,   -44,   -40,   -44,   -43,   -44,
-   -44,   -44,   -19,   -39,   -44,   -12,   -21,    73,   -44,   -24,
-   -44,   -44,   -29,    -3,    -4,   -41,   -42,   -10,   -37,   -36,
-   -38,   -44,   -18,   -34,   -35,   -22,   -27,   -44,   -30,   -31,
-   -32,   -33,   -25 ]
+   -48,   -14,   -48,   -48,   -15,   -16,   -48,   -20,   -48,   -23,
+   -48,   -48,    -1,   -48,    -2,   -48,    -9,   -48,    -8,   -48,
+   -11,   -17,   -13,   -48,   -48,   -48,   -48,    -6,   -48,    -7,
+   -48,   -48,    -5,   -48,   -30,   -48,   -32,   -48,   -44,   -48,
+   -48,   -47,   -48,   -19,   -12,   -43,   -48,   -21,   -27,   -48,
+    78,    -3,    -4,   -48,   -48,   -28,   -48,   -33,   -45,   -40,
+   -41,   -10,   -46,   -42,   -48,   -18,   -39,   -38,   -22,   -24,
+   -31,   -35,   -48,   -34,   -37,   -36,   -25,   -29 ]
 
 racc_goto_table = [
-    32,    26,    11,     8,    31,    24,    65,    29,   nil,   nil,
-   nil,   nil,   nil,    32,   nil,   nil,   nil,   nil,   nil,    46,
-   nil,   nil,    53,    54 ]
+    27,    32,    29,    12,    68,    23,    11,    28,    76,    35,
+   nil,   nil,    32,   nil,   nil,   nil,   nil,    47,   nil,   nil,
+    51,   nil,    52,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,    69 ]
 
 racc_goto_check = [
-     3,     4,     2,     1,     4,     2,    12,    13,   nil,   nil,
-   nil,   nil,   nil,     3,   nil,   nil,   nil,   nil,   nil,     4,
-   nil,   nil,     3,     3 ]
+     4,     3,     4,     2,    12,     2,     1,    13,    14,    15,
+   nil,   nil,     3,   nil,   nil,   nil,   nil,     4,   nil,   nil,
+     3,   nil,     3,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,     4 ]
 
 racc_goto_pointer = [
-   nil,     3,     2,   -11,    -6,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   -40,    -2 ]
+   nil,     6,     3,   -11,    -8,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   -43,    -2,   -61,    -4 ]
 
 racc_goto_default = [
-   nil,   nil,   nil,    13,    15,    17,    19,    20,    22,     2,
-     4,     5,   nil,   nil ]
+   nil,   nil,   nil,    14,    16,    18,    20,    22,     1,     4,
+     5,     6,   nil,   nil,   nil,   nil ]
 
 racc_token_table = {
  false => 0,
@@ -474,19 +524,20 @@ racc_token_table = {
  ")" => 12,
  "~" => 13,
  :WILD_STRING => 14,
- "\"" => 15,
- "<" => 16,
- ">" => 17,
- "|" => 18,
- "[" => 19,
- "]" => 20,
- "}" => 21,
- "{" => 22,
- "=" => 23 }
+ "*" => 15,
+ "|" => 16,
+ "\"" => 17,
+ "<" => 18,
+ ">" => 19,
+ "[" => 20,
+ "]" => 21,
+ "}" => 22,
+ "{" => 23,
+ "=" => 24 }
 
 racc_use_result_var = false
 
-racc_nt_base = 24
+racc_nt_base = 25
 
 Racc_arg = [
  racc_action_table,
@@ -520,10 +571,11 @@ Racc_token_to_s_table = [
 '")"',
 '"~"',
 'WILD_STRING',
+'"*"',
+'"|"',
 '"\""',
 '"<"',
 '">"',
-'"|"',
 '"["',
 '"]"',
 '"}"',
@@ -540,8 +592,10 @@ Racc_token_to_s_table = [
 'phrase_query',
 'range_query',
 'wild_query',
-'field_name',
+'field',
 '@1',
+'@2',
+'@3',
 'phrase_words']
 
 Racc_debug_parser = false
@@ -550,49 +604,49 @@ Racc_debug_parser = false
 
  # reduce 0 omitted
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 19
+module_eval <<'.,.,', 'query_parser.y', 19
   def _reduce_1( val, _values)
                     get_boolean_query(val[0])
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 24
+module_eval <<'.,.,', 'query_parser.y', 24
   def _reduce_2( val, _values)
                     [val[0]]
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 28
+module_eval <<'.,.,', 'query_parser.y', 28
   def _reduce_3( val, _values)
                     add_and_clause(val[0], val[2])
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 32
+module_eval <<'.,.,', 'query_parser.y', 32
   def _reduce_4( val, _values)
                     add_or_clause(val[0], val[2])
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 36
+module_eval <<'.,.,', 'query_parser.y', 36
   def _reduce_5( val, _values)
                     add_default_clause(val[0], val[1])
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 41
+module_eval <<'.,.,', 'query_parser.y', 41
   def _reduce_6( val, _values)
                     get_boolean_clause(val[1], BooleanClause::Occur::MUST)
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 45
+module_eval <<'.,.,', 'query_parser.y', 45
   def _reduce_7( val, _values)
                     get_boolean_clause(val[1], BooleanClause::Occur::MUST_NOT)
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 49
+module_eval <<'.,.,', 'query_parser.y', 49
   def _reduce_8( val, _values)
                     get_boolean_clause(val[0], BooleanClause::Occur::SHOULD)
   end
@@ -600,7 +654,7 @@ module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 49
 
  # reduce 9 omitted
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 51
+module_eval <<'.,.,', 'query_parser.y', 51
   def _reduce_10( val, _values)
  val[0].boost = val[2].to_f; return val[0]
   end
@@ -608,7 +662,7 @@ module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 51
 
  # reduce 11 omitted
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 58
+module_eval <<'.,.,', 'query_parser.y', 58
   def _reduce_12( val, _values)
                     get_boolean_query(val[1])
   end
@@ -622,165 +676,189 @@ module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 58
 
  # reduce 16 omitted
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 67
+module_eval <<'.,.,', 'query_parser.y', 67
   def _reduce_17( val, _values)
-                    get_term_query(val[0])
+                    _get_term_query(val[0])
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 71
+module_eval <<'.,.,', 'query_parser.y', 71
   def _reduce_18( val, _values)
-                    get_fuzzy_query(val[0], val[2])
+                    _get_fuzzy_query(val[0], val[2])
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 75
+module_eval <<'.,.,', 'query_parser.y', 75
   def _reduce_19( val, _values)
-                    get_fuzzy_query(val[0])
+                    _get_fuzzy_query(val[0])
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 80
+module_eval <<'.,.,', 'query_parser.y', 80
   def _reduce_20( val, _values)
-                    WildcardQuery.new(Term.new(@field, val[0]))
+                    _get_wild_query(val[0])
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 81
+module_eval <<'.,.,', 'query_parser.y', 81
   def _reduce_21( val, _values)
 @field = @default_field
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 85
+module_eval <<'.,.,', 'query_parser.y', 85
   def _reduce_22( val, _values)
                     val[2]
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 86
+module_eval <<'.,.,', 'query_parser.y', 85
   def _reduce_23( val, _values)
- @field = val[0]
+@field = "*"
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 92
+module_eval <<'.,.,', 'query_parser.y', 85
   def _reduce_24( val, _values)
-                    get_phrase_query(val[1])
+@field = @default_field
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 96
+module_eval <<'.,.,', 'query_parser.y', 89
   def _reduce_25( val, _values)
-                    get_phrase_query(val[1], val[4].to_i)
+                    val[3]
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 96
+module_eval <<'.,.,', 'query_parser.y', 90
   def _reduce_26( val, _values)
- nil
+ @field = [val[0]]
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 97
+module_eval <<'.,.,', 'query_parser.y', 91
   def _reduce_27( val, _values)
- nil
+ @field = val[0] += [val[2]]
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 99
+module_eval <<'.,.,', 'query_parser.y', 97
   def _reduce_28( val, _values)
- [val[0]]
+                    get_phrase_query(val[1])
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 100
+module_eval <<'.,.,', 'query_parser.y', 101
   def _reduce_29( val, _values)
- val[0] << val[1]
+                    get_phrase_query(val[1], val[4].to_i)
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 101
+module_eval <<'.,.,', 'query_parser.y', 101
   def _reduce_30( val, _values)
- val[0] << nil
+ nil
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 102
+module_eval <<'.,.,', 'query_parser.y', 102
   def _reduce_31( val, _values)
- add_multi_word(val[0], val[2])
+ nil
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 104
+module_eval <<'.,.,', 'query_parser.y', 104
   def _reduce_32( val, _values)
- get_range_query(val[1], val[2], true, true)
+ [val[0]]
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 105
+module_eval <<'.,.,', 'query_parser.y', 105
   def _reduce_33( val, _values)
- get_range_query(val[1], val[2], true, false)
+ val[0] << val[1]
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 106
+module_eval <<'.,.,', 'query_parser.y', 106
   def _reduce_34( val, _values)
- get_range_query(val[1], val[2], false, true)
+ val[0] << nil
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 107
+module_eval <<'.,.,', 'query_parser.y', 107
   def _reduce_35( val, _values)
- get_range_query(val[1], val[2], false, false)
+ add_multi_word(val[0], val[2])
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 108
+module_eval <<'.,.,', 'query_parser.y', 109
   def _reduce_36( val, _values)
- get_range_query(nil,    val[1], false, false)
+ _get_range_query(val[1], val[2], true, true)
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 109
+module_eval <<'.,.,', 'query_parser.y', 110
   def _reduce_37( val, _values)
- get_range_query(nil,    val[1], false, true)
+ _get_range_query(val[1], val[2], true, false)
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 110
+module_eval <<'.,.,', 'query_parser.y', 111
   def _reduce_38( val, _values)
- get_range_query(val[1], nil,    true, false)
+ _get_range_query(val[1], val[2], false, true)
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 111
+module_eval <<'.,.,', 'query_parser.y', 112
   def _reduce_39( val, _values)
- get_range_query(val[1], nil,    false, false)
+ _get_range_query(val[1], val[2], false, false)
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 112
+module_eval <<'.,.,', 'query_parser.y', 113
   def _reduce_40( val, _values)
- get_range_query(nil,    val[1], false, false)
+ _get_range_query(nil,    val[1], false, false)
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 113
+module_eval <<'.,.,', 'query_parser.y', 114
   def _reduce_41( val, _values)
- get_range_query(nil,    val[2], false, true)
+ _get_range_query(nil,    val[1], false, true)
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 114
+module_eval <<'.,.,', 'query_parser.y', 115
   def _reduce_42( val, _values)
- get_range_query(val[2], nil,    true, false)
+ _get_range_query(val[1], nil,    true, false)
   end
 .,.,
 
-module_eval <<'.,.,', 'lib/ferret/query_parser/query_parser.y', 115
+module_eval <<'.,.,', 'query_parser.y', 116
   def _reduce_43( val, _values)
- get_range_query(val[1], nil,    false, false)
+ _get_range_query(val[1], nil,    false, false)
+  end
+.,.,
+
+module_eval <<'.,.,', 'query_parser.y', 117
+  def _reduce_44( val, _values)
+ _get_range_query(nil,    val[1], false, false)
+  end
+.,.,
+
+module_eval <<'.,.,', 'query_parser.y', 118
+  def _reduce_45( val, _values)
+ _get_range_query(nil,    val[2], false, true)
+  end
+.,.,
+
+module_eval <<'.,.,', 'query_parser.y', 119
+  def _reduce_46( val, _values)
+ _get_range_query(val[2], nil,    true, false)
+  end
+.,.,
+
+module_eval <<'.,.,', 'query_parser.y', 120
+  def _reduce_47( val, _values)
+ _get_range_query(val[1], nil,    false, false)
   end
 .,.,
 
@@ -795,6 +873,7 @@ end   # module Ferret
 
 if __FILE__ == $0
   $:.unshift File.join(File.dirname(__FILE__), '..')
+  $:.unshift File.join(File.dirname(__FILE__), '../..')
   require 'utils'
   require 'analysis'
   require 'document'
@@ -802,10 +881,15 @@ if __FILE__ == $0
   require 'index'
   require 'search'
 
+  include Ferret::Search
+  include Ferret::Index
+
   st = "\033[7m"
   en = "\033[m"
 
-  parser = Ferret::QueryParser.new("default")
+  parser = Ferret::QueryParser.new("default",
+                                   :fields => ["f1", "f2", "f3"],
+                                   :analyzer => Ferret::Analysis::StandardAnalyzer.new)
 
   $stdin.each do |line|
     query = parser.parse(line)