ferret 0.1.0

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

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

@@ -0,0 +1,108 @@
+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 << "], #{@stop}, #{@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

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

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