ferret 0.9.6 → 0.10.0

data/lib/ferret/search/phrase_scorer.rb

@@ -1,152 +0,0 @@
-module Ferret::Search
-  class PhraseScorer < Scorer 
-    attr_reader :first, :last
-    protected   :first, :last
-
-    def initialize(weight, tps, positions, similarity, norms) 
-      super(similarity)
-      @norms = norms
-      @weight = weight
-      @value = weight.value
-      @first_time = true
-      @more = true
-
-      # convert tps to a list
-      tps.length.times do |i|
-        pp = PhrasePositions.new(tps[i], positions[i])
-        if (@last != nil) # add next to end of list
-          @last.next = pp
-        else
-          @first = pp
-        end
-        @last = pp
-      end
-
-      @pq = PhraseQueue.new(tps.length)  # construct empty pq
-    end
-
-    def doc()
-      return @first.doc
-    end
-
-    def next?
-      if (@first_time) 
-        init()
-        @first_time = false
-      elsif (@more) 
-        @more = @last.next?                      # trigger further scanning
-      end
-      return do_next()
-    end
-    
-    # next without initial increment
-    def do_next()
-      while (@more) 
-        while (@more and @first.doc < @last.doc) # find doc w/ all the terms
-          @more = @first.skip_to(@last.doc)      # skip first upto last
-          first_to_last()                        # and move it to the end
-        end
-
-        if (@more) 
-          # found a doc with all of the terms
-          @freq = phrase_freq()                  # check for phrase
-          if (@freq == 0.0)                      # no match
-            @more = @last.next?                  # trigger further scanning
-          else
-            return true                          # found a match
-          end
-        end
-      end
-      return false                               # no more matches
-    end
-
-    def each()
-      pp = @first
-      while (pp != nil)
-        yield pp
-        pp = pp.next
-      end
-    end
-
-    def score()
-      raw = similarity().tf(@freq) * @value      # raw score
-      return raw * Similarity.decode_norm(@norms[@first.doc])  # normalize
-    end
-
-    def skip_to(target)
-      each() { |pp| break if not @more = pp.skip_to(target) }
-      sort() if @more                            # re-sort
-      return do_next()
-    end
-
-    def phrase_freq()
-      raise NotImplementedError
-    end
-
-    def init()
-      each do |pp|
-        break if not @more = pp.next?
-      end
-      if @more
-        sort()
-      end
-    end
-    
-    def sort() 
-      @pq.clear()
-      each() do |pp|
-        @pq.push(pp)
-      end
-      pq_to_list()
-    end
-
-    def pq_to_list() 
-      @last = @first = nil
-      while (@pq.top() != nil) 
-        pp = @pq.pop()
-        if (@last != nil) # add next to end of list
-          @last.next = pp
-        else
-          @first = pp
-        end
-        @last = pp
-        pp.next = nil
-      end
-    end
-
-    def first_to_last() 
-      @last.next = @first  # move first to end of list
-      @last = @first
-      @first = @first.next
-      @last.next = nil
-    end
-
-    def explain(doc)
-      tf_explanation = Explanation.new()
-
-      while (next? and doc() < doc)
-      end
-
-      phrase_freq = (doc() == doc) ? @freq : 0.0
-      tf_explanation.value = @similarity.tf(phrase_freq)
-      tf_explanation.description = "tf(phrase_freq=#{phrase_freq})"
-
-      return tf_explanation
-    end
-
-    def to_s() return "phrase_scorer(#{@weight})" end
-
-  end
-
-
-  class PhraseQueue < Ferret::Utils::PriorityQueue
-    def less_than(pp1, pp2)
-      if (pp1.doc == pp2.doc) 
-        return pp1.position < pp2.position
-      else
-        return pp1.doc < pp2.doc
-      end
-    end
-  end
-
-end

data/lib/ferret/search/prefix_query.rb

@@ -1,54 +0,0 @@
-module Ferret::Search
-  # A Query that matches documents containing terms with a specified prefix. A
-  # PrefixQuery is built by QueryParser for input like +app*+. 
-  class PrefixQuery < Query 
-    attr_reader :prefix
-    # Constructs a query for terms starting with +prefix+. 
-    def initialize(prefix) 
-      super()
-      @prefix = prefix
-    end
-
-    def rewrite(reader)
-      bq = BooleanQuery.new(true)
-      enumerator = reader.terms_from(@prefix)
-      begin 
-        prefix_text = @prefix.text
-        prefix_length = prefix_text.length
-        prefix_field = @prefix.field
-        begin 
-          term = enumerator.term
-          if (term.nil? or
-            term.field != prefix_field or
-            term.text[0,prefix_length] != prefix_text)
-            break
-          end
-          tq = TermQuery.new(term)                        # found a match
-          tq.boost = boost()                              # set the boost
-          bq.add_query(tq, BooleanClause::Occur::SHOULD)  # add to query
-          #puts("added " + term)
-        end while (enumerator.next?)
-      ensure 
-        enumerator.close()
-      end
-      return bq
-    end
-
-    # Prints a user-readable version of this query. 
-    def to_s(f) 
-      buffer = ""
-      buffer << "#{@prefix.field}:" if @prefix.field != f
-      buffer << "#{@prefix.text}*"
-      buffer << "^#{boost()}" if boost() != 1.0 
-      return buffer
-    end
-
-    def eql?(o)
-      (@prefix == o.prefix and boost() == o.boost)
-    end
-
-    def hash()
-      boost().hash ^ @prefix.hash
-    end
-  end
-end

data/lib/ferret/search/query.rb

@@ -1,140 +0,0 @@
-module Ferret::Search
-  # The abstract base class for queries.
-  # Instantiable subclasses are:
-  #    * TermQuery
-  #    * MultiTermQuery
-  #    * BooleanQuery
-  #    * WildcardQuery
-  #    * PhraseQuery
-  #    * PrefixQuery
-  #    * MultiPhraseQuery
-  #    * FuzzyQuery
-  #    * RangeQuery
-  #    * Span::SpanQuery
-  #
-  # A parser for queries is contained in:
-  #    * Ferret::QueryParser::QueryParser
-  #
-  class Query
-    # documents matching this query clause will (in addition to the normal
-    # weightings) have their score multiplied by the boost factor. It is
-    # 1.0 be default.
-    attr_accessor :boost
-
-    def initialize()
-      @boost = 1.0
-    end
-
-    # Prints a query to a string, with +field+ as the default field for
-    # terms.  The representation used is one that is supposed to be readable
-    # by Ferret::QueryParser::QueryParser. However, there are the following
-    # limitations:
-    # * If the query was created by the parser, the printed representation
-    #   may not be exactly what was parsed. For example, characters that need
-    #   to be escaped will be represented without the required backslash.
-    # * Some of the more complicated queries (e.g. span queries)
-    #   don't have a representation that can be parsed by QueryParser.
-    def to_s(field=nil)
-      raise NotImplementedError
-    end
-
-    # Expert: Constructs an appropriate Weight implementation for this query.
-    # 
-    # Only implemented by primitive queries, which re-write to themselves.
-    def create_weight(searcher)
-      raise NotImplementedError
-    end
-
-    # Expert: Constructs and initializes a Weight for a top-level query. 
-    def weight(searcher)
-      query = searcher.rewrite(self)
-      weight = query.create_weight(searcher)
-      sum = weight.sum_of_squared_weights()
-      norm = similarity(searcher).query_norm(sum)
-      weight.normalize(norm)
-      return weight
-    end
-
-    # Expert: called to re-write queries into primitive queries. 
-    def rewrite(reader)
-      return self
-    end
-
-    # Expert: called when re-writing queries under MultiSearcher.
-    # 
-    # Create a single query suitable for use by all subsearchers (in 1-1
-    # correspondence with queries). This is an optimization of the OR of
-    # all queries. We handle the common optimization cases of equal
-    # queries and overlapping clauses of boolean OR queries (as generated
-    # by MultiTermQuery.rewrite() and RangeQuery.rewrite()).
-    # Be careful overriding this method as queries[0] determines which
-    # method will be called and is not necessarily of the same type as
-    # the other queries.
-    def combine(queries) 
-      uniques = Set.new
-      queries.each do |query|
-        clauses = []
-        # check if we can split the query into clauses
-        splittable = query.respond_to? :clauses
-        if splittable
-          splittable = query.coord_disabled?
-          clauses = query.clauses
-          clauses.each do |clause|
-            splittable = clause.occur == BooleanClause::Occur::SHOULD
-            break unless splittable
-          end
-        end
-        if splittable
-          clauses.each { |clause| uniques << clause.query }
-        else
-          uniques << query
-        end
-      end
-      # optimization: if we have just one query, just return it
-      if uniques.size == 1
-        uniques.each { |query| return query }
-      end
-      
-      result = BooleanQuery.new(true)
-      uniques.each do |query|
-        result.add_query(query, BooleanClause::Occur::SHOULD)
-      end
-      return result
-    end
-
-    # Expert: adds all terms occuring in this query to the terms set
-    def extract_terms(terms) 
-      raise NotImplementedError
-    end
-
-
-    # Expert: merges the clauses of a set of BooleanQuery's into a single
-    # BooleanQuery.
-    # 
-    # A utility for use by #combine() implementations.
-    def merge_boolean_queries(queries) 
-      all_clauses = Set.new
-      queries.each do |query|
-        query.clauses.each do |clause|
-          all_clauses << clause
-        end
-      end
-
-      coord_disabled = queries.size==0 ? false : queries[0].coord_disabled?
-      result = BooleanQuery.new(coord_disabled)
-      all_clauses.each do |clause|
-        result << clause
-      end
-      return result
-    end
-
-    # Expert: Returns the Similarity implementation to be used for this
-    # query.  Subclasses may override this method to specify their own
-    # Similarity implementation, perhaps one that delegates through that of
-    # the Searcher.  By default the Searcher's Similarity implementation is
-    # returned.
-    def similarity(searcher) 
-      return searcher.similarity
-    end
-  end
-end

data/lib/ferret/search/query_filter.rb

@@ -1,51 +0,0 @@
-module Ferret::Search
-  require 'monitor'
-  # Constrains search results to only match those which also match a provided
-  # query.  Results are cached, so that searches after the first on the same
-  # index using this filter are much faster.
-  # 
-  # This could be used, for example, with a RangeQuery on a suitably formatted
-  # date field to implement date filtering.  One could re-use a single
-  # QueryFilter that matches, e.g., only documents modified within the last
-  # week.  The QueryFilter and RangeQuery would only need to be reconstructed
-  # once per day.
-  class QueryFilter < Filter 
-
-    # Constructs a filter which only matches documents matching
-    # +query+.
-    def initialize(query) 
-      @query = query
-      @cache = nil 
-    end
-
-    def bits(reader)
-
-      if (@cache == nil) 
-        @cache = Ferret::Utils::WeakKeyHash.new
-      end
-
-      @cache.synchronize() do # check cache
-        bits = @cache[reader]
-        if bits
-          return bits
-        end
-      end
-
-      bits = Ferret::Utils::BitVector.new()
-
-      IndexSearcher.new(reader).search_each(@query) do |doc, score|
-        bits.set(doc)  # set bit for hit
-      end
-
-      @cache.synchronize() do # update cache
-        @cache[reader] = bits
-      end
-
-      return bits
-    end
-
-    def to_s() 
-      return "QueryFilter(#{@query})"
-    end
-  end
-end

data/lib/ferret/search/range_filter.rb

@@ -1,103 +0,0 @@
-module Ferret::Search
-  # A Filter that restricts search results to a range of values in a given
-  # field.
-  # 
-  # This code borrows heavily from RangeQuery, but is implemented as a Filter.
-  class RangeFilter < Filter 
-    include Ferret::Index
-
-    # field_name:: The field this range applies to
-    # lower_term:: The lower bound on this range
-    # upper_term:: The upper bound on this range
-    # include_lower:: Does this range include the lower bound?
-    # include_upper:: Does this range include the upper bound?
-    def initialize(field_name, lower_term, upper_term, include_lower, include_upper) 
-      @field_name = field_name
-      @lower_term = lower_term
-      @upper_term = upper_term
-      @include_lower = include_lower
-      @include_upper = include_upper
-      
-      if (lower_term.nil? and upper_term.nil?) 
-        raise ArgumentError, "At least one value must be non-nil"
-      end
-      if (include_lower and lower_term.nil?) 
-        raise ArgumentError, "The lower bound must be non-nil to be inclusive"
-      end
-      if (include_upper and upper_term.nil?) 
-        raise ArgumentError, "The upper bound must be non-nil to be inclusive"
-      end
-      if (upper_term and lower_term and upper_term < lower_term)
-        raise ArgumentError, "The lower bound must less than the upper bound"
-      end
-    end
-    
-    # Constructs a filter for field +field_name+ matching less than or equal to
-    # +upper_term+.
-    def RangeFilter.new_less(field_name, upper_term, include_upper = true) 
-      return RangeFilter.new(field_name, nil, upper_term, false, include_upper)
-    end
-
-    # Constructs a filter for field +field_name+ matching greater than or equal
-    # to +lower_term+.
-    def RangeFilter.new_more(field_name, lower_term, include_lower = true) 
-      return RangeFilter.new(field_name, lower_term, nil, include_lower, false)
-    end
-    
-    # Returns a BitVector with true for documents which should be permitted in
-    # search results, and false for those that should not.
-    def bits(reader)
-      bits = Ferret::Utils::BitVector.new()
-      term_enum = reader.terms_from(Term.new(@field_name, @lower_term||""))
-      
-      begin 
-        if (term_enum.term() == nil) 
-          return bits
-        end
-        check_lower = !@include_lower # make adjustments to set to exclusive
-      
-        term_docs = reader.term_docs
-        begin 
-          begin 
-            term = term_enum.term()
-            break if (term.nil? or term.field != @field_name) 
-
-            if (!check_lower or @lower_term.nil? or term.text > @lower_term) 
-              check_lower = false
-              if @upper_term
-                compare = @upper_term <=> term.text
-                # if beyond the upper term, or is exclusive and
-                # this is equal to the upper term, break out 
-                if ((compare < 0) or (!@include_upper and compare == 0))
-                  break
-                end
-              end
-              # we have a good term, find the docs 
-              
-              term_docs.seek(term_enum)
-              while term_docs.next?
-                bits.set(term_docs.doc)
-              end
-            end
-          end while term_enum.next?
-        ensure 
-          term_docs.close()
-        end
-      ensure 
-        term_enum.close()
-      end
-
-      return bits
-    end
-    
-    def to_s() 
-      buffer = "#{@field_name}:"
-      buffer << "[" if @include_lower
-      buffer << @lower_term if @lower_term
-      buffer << "-"
-      buffer << @upper_term if @upper_term
-      buffer << @include_upper ? "]" : "end"
-      return buffer
-    end
-  end
-end