ferret 0.9.6 → 0.10.0

data/lib/ferret/search/spans/span_query.rb

@@ -1,25 +0,0 @@
-module Ferret::Search::Spans
-  # Base class for span-based queries. 
-  class SpanQuery < Ferret::Search::Query 
-    # Expert: Returns the matches for this query in an index.  Used internally
-    # to search for spans. 
-    def spans(reader)
-      raise NotImplementedError
-    end
-
-    # Returns the name of the field matched by this query.
-    def field()
-      raise NotImplementedError
-    end
-
-    # Returns a collection of all terms matched by this query.
-    def terms()
-      raise NotImplementedError
-    end
-
-    def create_weight(searcher)
-      return SpanWeight.new(self, searcher)
-    end
-  end
-end
-

data/lib/ferret/search/spans/span_scorer.rb

@@ -1,74 +0,0 @@
-module Ferret::Search::Spans
-  class SpanScorer < Ferret::Search::Scorer 
-    include Ferret::Search
-
-    def initialize(spans, weight, similarity, norms)
-      @first_time = true
-      @more = true
-     
-      super(similarity)
-      @spans = spans
-      @norms = norms
-      @weight = weight
-      @value = weight.value()
-      @freq = 0.0
-    end
-
-    def next?
-      if (@first_time) 
-        @more = @spans.next?
-        @first_time = false
-      end
-
-      return false if not @more
-
-      @freq = 0.0
-      @doc = @spans.doc
-
-      while (@more and @doc == @spans.doc) 
-        match_length = @spans.finish - @spans.start
-        @freq += similarity().sloppy_freq(match_length)
-        @more = @spans.next?
-      end
-
-      return (@more or @freq != 0.0)
-    end
-
-    def doc() return @doc end
-
-    def score()
-      raw = similarity().tf(@freq) * @value           # raw score
-      # normalize
-      return raw * Similarity.decode_norm(@norms[@doc])
-    end
-
-    def skip_to(target)
-      @more = @spans.skip_to(target)
-
-      return false if not @more
-
-      @freq = 0.0
-      @doc = @spans.doc()
-
-      while (@more and @spans.doc() == target) 
-        @freq += similarity().sloppy_freq(@spans.finish - @spans.start)
-        @more = @spans.next?
-      end
-
-      return (@more or @freq != 0.0)
-    end
-
-    def explain(doc)
-      tf_explanation = Explanation.new()
-
-      skip_to(doc)
-
-      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
-
-  end
-end

data/lib/ferret/search/spans/span_term_query.rb

@@ -1,105 +0,0 @@
-module Ferret::Search::Spans
-  # Matches spans containing a term. 
-  class SpanTermQuery < SpanQuery 
-    # Construct a SpanTermQuery matching the named term's spans. 
-    def initialize(term)
-      super()
-      @term = term
-    end
-
-    # Return the term whose spans are matched. 
-    def term() @term end
-
-    def field() @term.field() end
-
-    def terms() [@term] end
-
-    def to_s(field = nil) 
-      if @term.field == field
-        return @term.text
-      else
-        return @term.to_s
-      end
-    end
-
-    # Returns true iff +o+ is equal to this. 
-    def eql?(o) 
-      return (o.instance_of?(SpanTermQuery) and boost() == o.boost and @term == o.term)
-    end
-    alias :== :eql?
-
-    # Returns a hash code value for this object.
-    def hash()
-      return boost().hash ^ @term.hash
-    end
-
-    def spans(reader)
-      return SpanTermEnum.new(self, reader)
-    end
-
-    class SpanTermEnum < SpansEnum
-      def initialize(query, reader) 
-        @query = query
-        @positions = reader.term_positions_for(@query.term)
-        @position = -1
-        @doc = -1
-        @count = 0
-        @freq = 0
-      end
-
-      def next?
-        if (@count == @freq) 
-          if not @positions.next?
-            @doc = Ferret::Search::Scorer::MAX_DOCS
-            return false
-          end
-          @doc = @positions.doc()
-          @freq = @positions.freq()
-          @count = 0
-        end
-        @position = @positions.next_position()
-        @count += 1
-        return true
-      end
-
-      def skip_to(target)
-        # are we already at the correct position?
-        if (@doc >= target) 
-          return true
-        end
-
-        if not @positions.skip_to(target)
-          @doc = Ferret::Search::Scorer::MAX_DOCS
-          return false
-        end
-
-        @doc = @positions.doc()
-        @freq = @positions.freq()
-        @count = 0
-
-        @position = @positions.next_position()
-        @count += 1
-
-        return true
-      end
-
-      def doc() @doc end
-      def start() @position end
-      def finish() @position + 1 end
-
-      def to_s() 
-        buffer = "spans(#{@query})@"
-        if @doc < 0
-          buffer << "START"
-        else
-          if @doc == Ferret::Search::Scorer::MAX_DOCS
-            buffer << "END"
-          else
-            buffer << "#{@doc}-#{@position}"
-          end
-        end
-        return buffer
-      end
-    end
-  end
-end

data/lib/ferret/search/spans/span_weight.rb

@@ -1,84 +0,0 @@
-module Ferret::Search::Spans
-  class SpanWeight < Ferret::Search::Weight
-    include Ferret::Search
-    def initialize(query, searcher)
-      @similarity = query.similarity(searcher)
-      @query = query
-      @terms = query.terms()
-
-      @idf = @similarity.idf_phrase(@terms, searcher)
-    end
-
-    attr_reader :query, :value
-
-    def sum_of_squared_weights()
-      @query_weight = @idf * @query.boost()         # compute query weight
-      return @query_weight * @query_weight             # square it
-    end
-
-    def normalize(query_norm) 
-      @query_norm = query_norm
-      @query_weight *= query_norm                     # normalize query weight
-      @value = @query_weight * @idf                    # idf for document
-    end
-
-    def scorer(reader)
-      return SpanScorer.new(@query.spans(reader), self,
-                            @similarity,
-                            reader.get_norms(@query.field))
-    end
-
-    def explain(reader, doc)
-      result = Explanation.new()
-      result.description = "weight(#{@query} in #{doc}), product of:"
-      field = @query.field
-
-      doc_freqs = @terms.map {|t| "#{t.text}=#{reader.doc_freq(t)}"}.join(' ')
-
-      idf_expl = Explanation.new(@idf, "idf(#{field}: #{doc_freqs})")
-
-      # explain query weight
-      query_expl = Explanation.new()
-      query_expl.description = "query_weight(#{@query}), product of:"
-
-      boost_expl = Explanation.new(@query.boost, "boost")
-      query_expl << boost_expl if (@query.boost != 1.0)
-      query_expl << idf_expl
-
-      query_norm_expl = Explanation.new(@query_norm,"query_norm")
-      query_expl << query_norm_expl
-
-      query_expl.value = boost_expl.value * idf_expl.value * query_norm_expl.value
-
-      result << query_expl
-
-      # explain field weight
-      field_expl = Explanation.new()
-      field_expl.description = "field_weight(#{field}:#{@query.to_s(field)}"+
-                               " in #{doc}), product of:"
-
-      tf_expl = scorer(reader).explain(doc)
-      field_expl << tf_expl
-      field_expl << idf_expl
-
-      field_norm_expl = Explanation.new()
-      field_norms = reader.get_norms(field)
-      field_norm = (field_norms ? Similarity.decode_norm(field_norms[doc]) : 0.0)
-      field_norm_expl.value = field_norm
-      field_norm_expl.description = "field_norm(field=#{field}, doc=#{doc})"
-      field_expl << field_norm_expl
-
-      field_expl.value = tf_expl.value * idf_expl.value * field_norm_expl.value
-
-      result << field_expl
-
-      # combine them
-      result.value = query_expl.value * field_expl.value
-
-      if (query_expl.value == 1.0)
-        return field_expl
-      end
-      return result
-    end
-  end
-end

data/lib/ferret/search/spans/spans_enum.rb

@@ -1,44 +0,0 @@
-module Ferret::Search::Spans
-  # Expert: an enumeration of span matches.  Used to implement span searching.
-  # Each span represents a range of term positions within a document.  Matches
-  # are enumerated in order, by increasing document number, within that by
-  # increasing start position and finally by increasing finish position. 
-  class SpansEnum 
-    # Move to the next match, returning true iff any such exists. 
-    def next?()
-      raise NotImplementedError
-    end
-
-    # Skips to the first match beyond the current, whose document number is
-    # greater than or equal to _target_. Returns true iff there is such a
-    # match.  Behaves as if written:
-    #
-    #   def skip_to(target) 
-    #     begin 
-    #       return false if (!next?)
-    #     end while (target > doc)
-    #     return true
-    #   end
-    #
-    # Most implementations are considerably more efficient than that.
-    def skip_to(target)
-      raise NotImplementedError
-    end
-
-    # Returns the document number of the current match.  Initially invalid. 
-    def doc()
-      raise NotImplementedError
-    end
-
-
-    # Returns the start position of the current match.  Initially invalid. 
-    def start()
-      raise NotImplementedError
-    end
-
-    # Returns the finish position of the current match.  Initially invalid. 
-    def finish()
-      raise NotImplementedError
-    end
-  end
-end

data/lib/ferret/search/term_query.rb

@@ -1,128 +0,0 @@
-module Ferret::Search
-  # A Query that matches documents containing a @term.
-  #  This may be combined with other terms with a BooleanQuery.
-  class TermQuery < Query 
-
-    attr_reader :term
-
-    class TermWeight < Weight 
-      attr_reader :value, :query
-
-      def initialize(query, searcher)
-        @similarity = query.similarity(searcher)
-        @idf = @similarity.idf(searcher.doc_freq(query.term),
-                               searcher.max_doc) # compute idf
-        @query = query
-        @value = 0
-      end
-
-      def to_s() return "TermWeight(#{@value})"; end
-
-      def sum_of_squared_weights() 
-        @query_weight = @idf * @query.boost()       # compute query weight
-        return @query_weight * @query_weight # square it
-      end
-
-      def normalize(query_norm) 
-        @query_norm = query_norm
-        @query_weight *= query_norm   # normalize query weight
-        @value = @query_weight * @idf # idf for document
-      end
-
-      def scorer(reader)
-        term_docs = reader.term_docs_for(@query.term)
-
-        return nil if term_docs.nil?
-
-        return TermScorer.new(self, term_docs, @similarity,
-                              reader.get_norms(@query.term.field))
-      end
-
-      def explain(reader, doc)
-        explanation = Explanation.new()
-        explanation.description = "weight(#{@query} in #{doc}), product of:"
-
-        idf_expl = Explanation.new(@idf, "idf(doc_freq=#{reader.doc_freq(@query.term)})")
-
-        # explain query weight
-        query_expl = Explanation.new(nil, "query_weight(#{@query}), product of:")
-
-        boost_expl = Explanation.new(@query.boost(), "boost")
-        if (@query.boost() != 1.0)
-          query_expl << boost_expl
-        end
-        query_expl << idf_expl
-
-        query_norm_expl = Explanation.new(@query_norm||0.0,"query_norm")
-        query_expl << query_norm_expl
-
-        query_expl.value = boost_expl.value * idf_expl.value * query_norm_expl.value
-
-        explanation << query_expl
-
-        # explain field weight
-        field_name = @query.term.field
-        field_expl = Explanation.new()
-        field_expl.description = "field_weight(#{@query.term} in #{doc}), product of:"
-
-        tf_expl = scorer(reader).explain(doc)
-        field_expl << (tf_expl)
-        field_expl << (idf_expl)
-
-        field_norms = reader.get_norms(field_name)
-        field_norm = field_norms.nil? ? 0.0 : Similarity.decode_norm(field_norms[doc])
-        field_norm_expl = Explanation.new(field_norm,
-                                          "field_norm(field=#{field_name}, doc=#{doc})")
-        field_expl << field_norm_expl
-
-        field_expl.value = tf_expl.value * idf_expl.value * field_norm_expl.value 
-        explanation << field_expl
-
-        # combine them
-        explanation.value = (query_expl.value * field_expl.value)
-
-        if (query_expl.value == 1.0)
-          return field_expl
-        end
-
-        return explanation
-      end
-    end
-
-    # Constructs a query for the @query.term +t+. 
-    def initialize(t) 
-      super()
-      @term = t
-    end
-
-    def create_weight(searcher)
-      return TermWeight.new(self, searcher)
-    end
-
-    def extract_terms(terms) 
-      terms << @term
-    end
-
-    # Prints a user-readable version of this query. 
-    def to_s(field = nil) 
-      buffer = ""
-      buffer << "#{@term.field}:" if field != @term.field
-      buffer << "#{@term.text}"
-      buffer << "^#{@boost}" if @boost != 1.0
-      return buffer
-    end
-
-    # Returns true iff +o+ is equal to this. 
-    def eql?(other) 
-      return false if not other.instance_of?(TermQuery)
-      return (@boost == other.boost and @term == other.term)
-    end
-    alias :== :eql?
-
-    # Returns a hash code value for this object.
-    def hash() 
-      return @boost.hash ^ @term.hash
-    end
-
-  end
-end