ferret 0.9.6 → 0.10.0

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

@@ -1,79 +0,0 @@
-module Ferret::Search::Spans
-  # Matches spans near the beginning of a field. 
-  class SpanFirstQuery < SpanQuery 
-    # Construct a SpanFirstQuery matching spans in +match+ whose finish
-    # position is less than or equal to +finish+. 
-    def initialize(match, finish) 
-      super()
-      @match = match
-      @finish = finish
-    end
-
-    # Return the SpanQuery whose matches are filtered. 
-    def match() @match end
-
-    # Return the maximum finish position permitted in a match. 
-    def finish() @finish end
-
-    def field() @match.field() end
-
-    def terms() @match.terms() end
-
-    def to_s(field = nil) 
-      return "span_first(#{@match.to_s(field)}, #{finish})"
-    end
-
-    def spans(reader)
-      SpanFirstEnum.new(self, reader) 
-    end
-
-    class SpanFirstEnum < SpansEnum
-      def initialize(query, reader)
-        super()
-        @query = query
-        @spans = @query.match.spans(reader)
-      end
-
-      def next?()
-        while (@spans.next?()) # scan to next match
-          return true if (finish() <= @query.finish)
-        end
-        return false
-      end
-
-      def skip_to(target)
-        if not @spans.skip_to(target)
-          return false
-        end
-
-        if (@spans.finish <= @query.finish) # there is a match
-          return true
-        end
-
-        return next?()               # scan to next match
-      end
-
-      def doc() @spans.doc() end
-      def start() @spans.start() end
-      def finish() @spans.finish() end
-
-      def to_s() "spans(#{@query})" end
-    end
-
-
-    def rewrite(reader)
-      clone = nil
-      rewritten = @match.rewrite(reader)
-      if (rewritten != @match) 
-        clone = self.clone()
-        clone.match = rewritten
-      end
-
-      if (clone != nil) 
-        return clone                        # some clauses rewrote
-      else 
-        return self                         # no clauses rewrote
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-module Ferret::Search::Spans
-  # Matches spans which are near one another.  One can specify _slop_, the
-  # maximum number of intervening unmatched positions, as well as whether
-  # matches are required to be in-order. 
-  class SpanNearQuery < SpanQuery 
-
-    # Construct a SpanNearQuery.  Matches spans matching a span from each
-    # clause, with up to +slop+ total unmatched positions between them. When
-    # +in_order+ is true, the spans from each clause must be ordered as in
-    # +clauses+. 
-    def initialize(clauses, slop, in_order) 
-      super()
-      # copy clauses array into an ArrayList
-      @clauses = Array.new(clauses.length)
-      @field = nil
-      clauses.each_index do |i|
-        clause = clauses[i]
-        if i == 0 # check field
-          @field = clause.field()
-        elsif clause.field() != @field
-          raise ArgumentError, "Clauses must have same field."
-        end
-        @clauses[i] = clause
-      end
-
-      @slop = slop
-      @in_order = in_order
-    end
-
-    # Return the clauses whose spans are matched. 
-    def clauses() @clauses end
-
-    # Return the maximum number of intervening unmatched positions permitted.
-    def slop() @slop end
-
-    # Return true if matches are required to be in-order.
-    def in_order?() @in_order end
-
-    attr_reader :field
-
-    def terms() 
-      terms = []
-      @clauses.each do |clause|
-        terms += clause.terms
-      end
-      return terms
-    end
-
-    def to_s(field = nil) 
-      buffer = "span_near(["
-      buffer << @clauses.map {|c| c.to_s(field)}.join(", ")
-      buffer << "], #{@slop}, #{@in_order})"
-      return buffer
-    end
-
-    def spans(reader)
-      if (@clauses.size() == 0)                      # optimize 0-clause case
-        return SpanOrQuery.new(@clauses).spans(reader)
-      end
-
-      if (@clauses.size() == 1)                      # optimize 1-clause case
-        return @clauses[0].spans(reader)
-      end
-
-      return NearSpansEnum.new(self, reader)
-    end
-
-    def rewrite(reader)
-      clone = nil
-      @clauses.each_index do |i|
-        clause = @clauses[i]
-        query = clause.rewrite(reader)
-        if (query != clause) # clause rewrote: must clone
-          if (clone == nil)
-            clone = self.clone()
-          end
-          clone.clauses[i] = query
-        end
-      end
-      if (clone != nil) 
-        return clone                        # some clauses rewrote
-      else 
-        return self                         # no clauses rewrote
-      end
-    end
-
-    # Returns true iff +o+ is equal to this. 
-    def eql?(o) 
-      return false if (o == nil or self.class() != o.class())
-
-      return false if (@in_order != o.in_order?)
-      return false if (@slop != o.slop)
-      return false if (@clauses != o.clauses)
-      return false if (@field != o.field)
-
-      return true
-    end
-    alias :== :eql?
-
-    def hash() 
-      result = @clauses.hash()
-      result += @slop * 29
-      result +=  (@in_order ? 1 : 0)
-      result ^= @field.hash()
-      return result
-    end
-  end
-end

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

@@ -1,130 +0,0 @@
-module Ferret::Search::Spans
-  # Removes matches which overlap with another SpanQuery. 
-  class SpanNotQuery < SpanQuery 
-    # Construct a SpanNotQuery matching spans from +incl+ which
-    # have no overlap with spans from +excl+.
-    def initialize(incl, excl) 
-      super()
-      @incl = incl
-      @excl = excl
-
-      if incl.field != excl.field
-        raise ArgumentError, "Clauses must have same field."
-      end
-    end
-
-    # Return the SpanQuery whose matches are filtered. 
-    def incl() @incl end
-
-    # Return the SpanQuery whose matches must not overlap those returned. 
-    def excl() @excl end
-
-    def field() @incl.field() end
-
-    def terms() @incl.terms() end
-
-    def to_s(field = nil) 
-      return "span_not(#{incl.to_s(field)}, #{excl.to_s(field)})"
-    end
-
-    def spans(reader)
-      return SpanNotEnum.new(self, reader)
-    end
-    
-    class SpanNotEnum < SpansEnum
-      def initialize(query, reader)
-        @query = query
-        @incl_spans = @query.incl.spans(reader)
-        @more_incl = true
-        @excl_spans = @query.excl.spans(reader)
-        @more_excl = @excl_spans.next? # excl_spans needs to be preset
-      end
-
-      def next?()
-        if (@more_incl)                          # move to next incl
-          @more_incl = @incl_spans.next?()
-        end
-
-        while (@more_incl and @more_excl) 
-          if (@incl_spans.doc > @excl_spans.doc) # skip excl
-            @more_excl = @excl_spans.skip_to(@incl_spans.doc)
-          end
-
-          while (@more_excl and                  # while excl is before
-                 @incl_spans.doc == @excl_spans.doc and
-                 @excl_spans.finish <= @incl_spans.start) 
-            @more_excl = @excl_spans.next?       # increment excl
-          end
-
-          if (not @more_excl or                  # if no intersection
-              @incl_spans.doc != @excl_spans.doc or
-              @incl_spans.finish <= @excl_spans.start)
-            break                                # we found a match
-          end
-
-          @more_incl = @incl_spans.next?         # intersected: keep scanning
-        end
-        return @more_incl
-      end
-
-      def skip_to(target)
-        if @more_incl                            # skip incl
-          @more_incl = @incl_spans.skip_to(target)
-        end
-
-        if not @more_incl
-          return false
-        end
-
-        if (@more_excl and @incl_spans.doc > @excl_spans.doc) # skip excl
-          @more_excl = @excl_spans.skip_to(@incl_spans.doc)
-        end
-
-        while (@more_excl and                    # while excl is before
-               @incl_spans.doc == @excl_spans.doc and
-               @excl_spans.finish <= @incl_spans.start) 
-          @more_excl = @excl_spans.next?         # increment excl
-        end
-
-        if (not @more_excl or                    # if no intersection
-              @incl_spans.doc != @excl_spans.doc or
-              @incl_spans.finish <= @excl_spans.start)
-          return true                            # we found a match
-        end
-
-        return next?()                           # scan to next match
-      end
-
-      def doc() @incl_spans.doc end
-      def start() @incl_spans.start end
-      def finish() @incl_spans.finish end
-
-      def to_s() 
-        return "spans(#{@query})"
-      end
-    end
-
-    def rewrite(reader)
-      clone = nil
-
-      rewritten_incl = @incl.rewrite(reader)
-      if (rewritten_incl != @incl) 
-        clone = self.clone()
-        clone.incl = rewritten_incl
-      end
-
-      rewritten_excl = @excl.rewrite(reader)
-      if (rewritten_excl != @excl) 
-        clone = self.clone() if (clone == nil)
-        clone.excl = rewritten_excl
-      end
-
-      if (clone != nil) 
-        return clone                        # some clauses rewrote
-      else 
-        return self                         # no clauses rewrote
-      end
-    end
-
-  end
-end

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

@@ -1,176 +0,0 @@
-module Ferret::Search::Spans
-  # Matches the union of its clauses.
-  class SpanOrQuery < SpanQuery 
-
-    # Construct a SpanOrQuery merging the provided clauses. 
-    def initialize(clauses) 
-      super()
-
-      # copy clauses array into an ArrayList
-      @clauses = Array.new(clauses.length)
-      @field = nil
-      clauses.each_index do |i|
-        clause = clauses[i]
-        if i == 0 # check field
-          @field = clause.field()
-        elsif clause.field() != @field
-          raise ArgumentError, "Clauses must have same field."
-        end
-        @clauses[i] = clause
-      end
-    end
-
-    # Return the clauses whose spans are matched. 
-    def clauses() @clauses end
-
-    attr_reader :field
-
-    def terms() 
-      terms = []
-      @clauses.each do |clause|
-        terms += clause.terms
-      end
-      return terms
-    end
-
-    def rewrite(reader)
-      clone = nil
-      @clauses.each_index do |i|
-        clause = @clauses[i]
-        query = clause.rewrite(reader)
-        if (query != clause) # clause rewrote: must clone
-          if (clone == nil)
-            clone = self.clone()
-          end
-          clone.clauses[i] = query
-        end
-      end
-      if (clone != nil) 
-        return clone                        # some clauses rewrote
-      else 
-        return self                         # no clauses rewrote
-      end
-    end
-
-    def to_s(field = nil) 
-      buffer = "spanOr(["
-      buffer << @clauses.map {|c| c.to_s(field()) }.join(", ")
-      buffer << "])"
-      return buffer
-    end
-
-    def eql?(o) 
-      return false if (o == nil or self.class() != o.class())
-
-      return false if (@clauses != o.clauses)
-      return false if (@field != o.field)
-
-      return true
-    end
-    alias :== :eql?
-
-    def hash() 
-      return @clauses.hash ^ @field.hash
-    end
-
-    class SpanQueue < Ferret::Utils::PriorityQueue 
-      def less_than(o1, o2) 
-        if (o1.doc == o2.doc) 
-          if (o1.start == o2.start) 
-            return o1.finish < o2.finish
-          else 
-            return o1.start < o2.start
-          end
-        else 
-          return o1.doc < o2.doc
-        end
-      end
-    end
-
-    def spans(reader)
-      if (@clauses.size == 1)                      # optimize 1-clause case
-        return @clauses[0].spans(reader)
-      end
-
-      return SpanOrEnum.new(self, reader) 
-    end
-
-    class SpanOrEnum < SpansEnum
-      def initialize(query, reader)
-        @query = query
-        @queue = SpanQueue.new(query.clauses.size)
-        @all = query.clauses.map {|c| c.spans(reader)}
-        @first_time = true
-      end
-
-      def next?
-        if (@first_time) # first time -- initialize
-          @all.delete_if do |spans|
-            if (spans.next?) # move to first entry
-              @queue.push(spans) # build queue
-              next false
-            else 
-              next true
-            end
-          end
-          @first_time = false
-          return @queue.size() != 0
-        end
-
-        if @queue.size == 0 # all done
-          return false
-        end
-
-        if top().next? # move to next
-          @queue.adjust_top()
-          return true
-        end
-
-        @all.delete(@queue.pop()) # exhausted a clause
-
-        return @queue.size() != 0
-      end
-
-      def top() return @queue.top() end
-
-      def skip_to(target)
-        if (@first_time) 
-          @all.delete_if do |spans|
-            if (spans.skip_to(target)) # skip each spans in all
-              @queue.push(spans) # build queue
-              next false
-            else 
-              next true
-            end
-          end
-          @first_time = false
-        else 
-          while (@queue.size != 0 and top().doc < target) 
-            if (top().skip_to(target)) 
-              @queue.adjust_top()
-            else 
-              @all.delete(@queue.pop())
-            end
-          end
-        end
-
-        return @queue.size() != 0
-      end
-
-      def doc() top().doc() end
-      def start() top().start() end
-      def finish() top().finish() end
-
-      def to_s() 
-        buffer = "spans(#{@query})@"
-        if @first_time
-          buffer << "START"
-        else
-          buffer << (@queue.size>0 ? ("#{doc}:#{start()}-#{finish}") : "END")
-        end
-        return buffer
-      end
-    end
-
-  end
-end