ferret 0.1.0

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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,84 @@
+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 = @query.similarity(searcher).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

@@ -0,0 +1,44 @@
+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 ensure 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

@@ -0,0 +1,128 @@
+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