ferret 0.9.6 → 0.10.0

data/lib/ferret/search/range_query.rb

@@ -1,139 +0,0 @@
-module Ferret::Search
-  # A Query that matches documents within an exclusive range. A RangeQuery
-  # is built by QueryParser for input like +[010 120]+.
-  class RangeQuery < Query
-    include Ferret::Index
-
-    attr_reader :lower_term, :upper_term
-
-    # Constructs a query selecting all terms greater than
-    # +lower_term+ but less than +upper_term+.
-    # There must be at least one term and either term may be nil,
-    # in which case there is no bound on that side, but if there are
-    # two terms, both terms *must* be for the same field.
-    #
-    # field:: 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, lower_term, upper_term, include_lower, include_upper) 
-      super()
-      @field = field
-      @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 query for field +field+ matching less than or equal to
-    # +upper_term+.
-    def RangeQuery.new_less(field, upper_term, include_upper = true) 
-      return RangeQuery.new(field, nil, upper_term, false, include_upper)
-    end
-
-    # Constructs a query for field +field+ matching greater than or equal
-    # to +lower_term+.
-    def RangeQuery.new_more(field, lower_term, include_lower = true) 
-      return RangeQuery.new(field, lower_term, nil, include_lower, false)
-    end
-
-    def rewrite(reader)
-      bq = BooleanQuery.new(true)
-      term_enum = reader.terms_from(Term.new(@field, @lower_term||""))
-
-      begin 
-        check_lower = !@include_lower
-        test_field = field()
-        begin 
-          term = term_enum.term
-
-          break if term.nil? or term.field != @field         
-          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 (not @include_upper and compare == 0))
-                break
-              end
-            end
-            tq = TermQuery.new(term) # found a match
-            tq.boost = boost()       # set the boost
-            bq.add_query(tq, BooleanClause::Occur::SHOULD) # add to query
-          end
-        end while term_enum.next?
-      ensure 
-        term_enum.close()
-      end
-      return bq
-    end
-
-    # Returns the field name for this query 
-    attr_reader :field, :lower_term, :upper_term, :include_lower, :include_upper
-
-    # Prints a user-readable version of this query. 
-    def to_s(f=nil)
-      buffer = ""
-      buffer << "#{@field}:" if field() != f
-
-      if @lower_term
-        buffer << (@include_lower ? "[" : "{")
-        buffer << @lower_term
-      else
-        buffer << "<"
-      end
-
-      buffer << " " if @upper_term and @lower_term
-
-      if @upper_term
-        buffer << @upper_term
-        buffer << (@include_upper ? "]" : "}")
-      else
-        buffer << ">"
-      end
-
-      if boost() != 1.0
-        buffer << "^#{boost()}"
-      end
-      return buffer 
-    end
-
-    # Returns true iff +o+ is equal to this. 
-    def eql?(o) 
-      return ((o.instance_of?(RangeQuery)) and 
-          (boost() == o.boost()) and
-          (@include_upper == o.include_upper) and
-          (@include_lower == o.include_lower) and
-          (@upper_term == o.upper_term) and
-          (@lower_term == o.lower_term) and
-          (@field == o.field))
-    end
-    alias :== :eql?
-
-    # Returns a hash code value for this object.
-    def hash() 
-      return (boost().hash ^
-              @field.hash ^
-              @lower_term.hash ^
-              @upper_term.hash ^
-              @include_lower.hash ^
-              @include_upper.hash)
-    end
-  end
-end

data/lib/ferret/search/req_excl_scorer.rb

@@ -1,125 +0,0 @@
-module Ferret::Search
-  # A Scorer for queries with a required subscorer and an excluding (prohibited)
-  # subscorer.
-  #
-  # This +Scorer+ implements Scorer#skip_to(int), and it uses the skip_to() on
-  # the given scorers.
-  class ReqExclScorer < Scorer 
-    # Construct a +ReqExclScorer+.
-    # req_scorer:: The scorer that must match, except where
-    # excl_scorer:: indicates exclusion.
-    def initialize(req_scorer, excl_scorer) 
-      super(nil) # No similarity used.
-      @req_scorer = req_scorer
-      @excl_scorer = excl_scorer
-
-      @first_time = true
-    end
-
-    
-    def next?
-      if @first_time
-        if not @excl_scorer.next?
-          @excl_scorer = nil # exhausted at start
-        end
-        @first_time = false
-      end
-      if @req_scorer == nil 
-        return false
-      end
-      if not @req_scorer.next?
-        @req_scorer = nil; # exhausted, nothing left
-        return false
-      end
-      if @excl_scorer == nil
-        return true # @req_scorer.next? already returned true
-      end
-      return to_non_excluded()
-    end
-    
-    # Advance to non excluded doc.
-    # On entry:
-    # 
-    # * @req_scorer != nil
-    # * @excl_scorer != nil
-    # * @req_scorer was advanced once via next? or skip_to() and
-    #   @req_scorer.doc() may still be excluded.
-    # 
-    # Advances @req_scorer a non excluded required doc, if any.
-    #
-    # returns:: true iff there is a non excluded required doc.
-    def to_non_excluded()
-      excl_doc = @excl_scorer.doc
-      begin 
-        req_doc = @req_scorer.doc # may be excluded
-        if (req_doc < excl_doc) 
-          return true # @req_scorer advanced to before @excl_scorer, ie. not excluded
-        elsif (req_doc > excl_doc) 
-          unless @excl_scorer.skip_to(req_doc) 
-            @excl_scorer = nil # exhausted, no more exclusions
-            return true
-          end
-          excl_doc = @excl_scorer.doc
-          if excl_doc > req_doc 
-            return true; # not excluded
-          end
-        end
-      end while @req_scorer.next?
-      @req_scorer = nil; # exhausted, nothing left
-      return false
-    end
-
-    # @req_scorer may be nil when next? or skip_to() already return false so
-    # only call when you know that a doc exists
-    def doc() 
-      return @req_scorer.doc
-    end
-
-    # Returns the score of the current document matching the query.
-    #
-    # Initially invalid, until #next? is called the first time.
-    #
-    # returns:: The score of the required scorer.
-    def score()
-      return @req_scorer.score()
-    end
-    
-    # Skips to the first match beyond the current whose document number is
-    # greater than or equal to a given target.
-    #
-    # When this method is used the #explain(int) method should not be used.
-    #
-    # target:: The target document number.
-    # returns:: true iff there is such a match.
-    def skip_to(target)
-      if (@first_time) 
-        @first_time = false
-        if (! @excl_scorer.skip_to(target)) 
-          @excl_scorer = nil; # exhausted
-        end
-      end
-      if (@req_scorer == nil) 
-        return false
-      end
-      if (@excl_scorer == nil) 
-        return @req_scorer.skip_to(target)
-      end
-      if (! @req_scorer.skip_to(target)) 
-        @req_scorer = nil
-        return false
-      end
-      return to_non_excluded()
-    end
-
-    def explain(doc)
-      e = Explanation.new()
-      if @excl_scorer.skip_to(doc) and @excl_scorer.doc == doc
-        e.description = "excluded"
-      else 
-        e.description = "not excluded"
-        e.details << @req_scorer.explain(doc)
-      end
-      return e
-    end
-  end
-end

data/lib/ferret/search/req_opt_sum_scorer.rb

@@ -1,70 +0,0 @@
-module Ferret::Search
-  # A Scorer for queries with a required part and an optional part.
-  # Delays skip_to() on the optional part until a score() is needed.
-  # 
-  # This +Scorer+ implements Scorer#skip_to(int).
-  class ReqOptSumScorer < Scorer 
-    # The scorers passed from the constructor.
-    # These are set to nil as soon as their next? or skip_to() returns false.
-    #
-    # Construct a +ReqOptScorer+.
-    # req_scorer:: The required scorer. This must match.
-    # opt_scorer:: The optional scorer. This is used for scoring only.
-    def initialize(req_scorer, opt_scorer)
-      super(nil) # No similarity used.
-      @req_scorer = req_scorer
-      @opt_scorer = opt_scorer
-
-      @first_time_opt_scorer = true
-    end
-
-
-    def next?
-      return @req_scorer.next?
-    end
-
-    def skip_to(target)
-      return @req_scorer.skip_to(target)
-    end
-
-    def doc() 
-      return @req_scorer.doc()
-    end
-
-    # Returns the score of the current document matching the query.
-    # Initially invalid, until #next? is called the first time.
-    #
-    # returns:: The score of the required scorer, eventually increased by the
-    #           score of the optional scorer when it also matches the current
-    #           document.
-    def score()
-      cur_doc = @req_scorer.doc
-      req_score = @req_scorer.score
-      if @first_time_opt_scorer
-        @first_time_opt_scorer = false
-        if not @opt_scorer.skip_to(cur_doc) 
-          @opt_scorer = nil
-          return req_score
-        end
-      elsif @opt_scorer.nil?
-        return req_score
-      elsif @opt_scorer.doc < cur_doc and not @opt_scorer.skip_to(cur_doc)
-        @opt_scorer = nil
-        return req_score
-      end
-      # assert (@opt_scorer != nil) and (@opt_scorer.doc() >= cur_doc)
-      return (@opt_scorer.doc == cur_doc) ? req_score + @opt_scorer.score() : req_score
-    end
-
-    # Explain the score of a document.
-    # @todo Also show the total score.
-    # See BooleanScorer.explain() on how to do this.
-    def explain(doc)
-      e = Explanation.new()
-      e.description = "required, optional"
-      e.details << @req_scorer.explain(doc)
-      e.details << @opt_scorer.explain(doc)
-      return e
-    end
-  end
-end

data/lib/ferret/search/score_doc.rb

@@ -1,38 +0,0 @@
-module Ferret::Search
-  # Expert: Returned by low-level search implementations.
-  # See TopDocs 
-  class ScoreDoc
-    include Comparable
-    # Expert: The score of this document for the query. 
-    attr_accessor :score
-
-    # Expert: A hit document's number.
-    attr_accessor :doc
-
-    # Expert: Constructs a ScoreDoc. 
-    def initialize(doc, score) 
-      @doc = doc
-      @score = score
-    end
-
-    # returns a hash value for storage in a Hash
-    def hash()
-      return 100 * doc * score
-    end
-
-    # score_docA < score_docB if score_docA.score < score_docB.score or
-    # score_docA.doc > score_docB.doc
-    def <=>(other)
-      result = @score.<=>(other.score)
-      if (result == 0)
-        return other.doc.<=>(@doc)
-      else
-        return result
-      end
-    end
-
-    def to_s
-      "#{@doc} -> %0.2f" % @score
-    end
-  end
-end

data/lib/ferret/search/score_doc_comparator.rb

@@ -1,114 +0,0 @@
-module Ferret::Search
-  # Expert: Compares two ScoreDoc objects for sorting.
-  class ScoreDocComparator 
-
-    # Special comparator for sorting hits according to computed relevance (score). 
-    RELEVANCE = ScoreDocComparator.new() 
-    class <<RELEVANCE
-      def compare(i, j) 
-        return j.score <=> i.score
-      end
-      def sort_value(i) 
-        return i.score
-      end
-      def sort_type() 
-        return SortField::SortType::SCORE
-      end
-    end
-
-
-    # Special comparator for sorting hits according to index order (number). 
-    INDEX_ORDER = ScoreDocComparator.new() 
-    class <<INDEX_ORDER
-      def compare(i, j) 
-        return i.doc <=> j.doc
-      end
-      def sort_value(i) 
-        return i.doc
-      end
-      def sort_type() 
-        return SortField::SortType::DOC
-      end
-    end
-
-
-    # Compares two ScoreDoc objects and returns a result indicating their
-    # sort order.
-    # i:: First ScoreDoc
-    # j:: Second ScoreDoc
-    # returns:: +-1+ if +i+ should come before +j+
-    #           +1+  if +i+ should come after +j+
-    #           +0+  if they are equal
-    def compare(i, j)
-      return NotImplementedError
-    end
-
-
-    # Returns the value used to sort the given document.  The object returned
-    # must implement the java.io.Serializable interface.  This is used by
-    # multisearchers to determine how to collate results from their searchers.
-    #
-    # See FieldDoc
-    # i:: Document
-    # returns:: Serializable object
-    def sort_value(i)
-      return NotImplementedError
-    end
-
-
-    # Returns the type of sort.  Should return +SortField.SCORE+,
-    # +SortField.DOC+, +SortField.STRING+, +SortField.INTEGER+,
-    # +SortField.FLOAT+ or +SortField.CUSTOM+.  It is not valid to return
-    # +SortField.AUTO+.
-    # This is used by multisearchers to determine how to collate results from
-    # their searchers.  returns:: One of the constants in SortField.
-    # See SortField
-    def sort_type()
-      return NotImplementedError
-    end
-  end
-
-  class SimpleFieldComparator < ScoreDocComparator
-    def initialize(index, sort_type)
-      @index = index
-      @sort_type = sort_type
-    end
-
-    def compare(i, j) 
-      return @index[i.doc] <=> @index[j.doc]
-    end
-    def sort_value(i) 
-      return @index[i.doc]
-    end
-    def sort_type() 
-      return @sort_type
-    end
-  end
-
-  class SpecialFieldComparator < SimpleFieldComparator
-    def initialize(index, sort_type, comparator)
-      super(index, sort_type)
-      @comparator = comparator
-    end
-    def compare(i, j) 
-      return @comparator.call(@index[i.doc], @index[j.doc])
-    end
-  end
-
-  class StringFieldComparator < ScoreDocComparator
-    def initialize(index)
-      @str_index = index.str_index
-      @str_map = index.str_map
-    end
-
-    def compare(i, j) 
-      return @str_index[i.doc] <=> @str_index[j.doc]
-    end
-    def sort_value(i) 
-      return @str_map[@str_index[i.doc]]
-    end
-    def sort_type() 
-      return SortField::SortType::STRING
-    end
-  end
-end