sunspot_rails 2.0.0.pre.120720 → 2.0.0.pre.120924

data/sunspot/lib/sunspot/indexer.rb

@@ -0,0 +1,136 @@
+require 'sunspot/batcher'
+
+module Sunspot
+  # 
+  # This class presents a service for adding, updating, and removing data
+  # from the Solr index. An Indexer instance is associated with a particular
+  # setup, and thus is capable of indexing instances of a certain class (and its
+  # subclasses).
+  #
+  class Indexer #:nodoc:
+    include RSolr::Char
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # 
+    # Construct a representation of the model for indexing and send it to the
+    # connection for indexing
+    #
+    # ==== Parameters
+    #
+    # model<Object>:: the model to index
+    #
+    def add(model)
+      documents = Util.Array(model).map { |m| prepare(m) }
+      if batcher.batching?
+        batcher.concat(documents)
+      else
+        add_documents(documents)
+      end
+    end
+
+    # 
+    # Remove the given model from the Solr index
+    #
+    def remove(*models)
+      @connection.delete_by_id(
+        models.map { |model| Adapters::InstanceAdapter.adapt(model).index_id }
+      )
+    end
+
+    # 
+    # Remove the model from the Solr index by specifying the class and ID
+    #
+    def remove_by_id(class_name, *ids)
+      @connection.delete_by_id(
+        ids.map { |id| Adapters::InstanceAdapter.index_id_for(class_name, id) }
+      )
+    end
+
+    # 
+    # Delete all documents of the class indexed by this indexer from Solr.
+    #
+    def remove_all(clazz = nil)
+      if clazz
+        @connection.delete_by_query("type:#{escape(clazz.name)}")
+      else
+        @connection.delete_by_query("*:*")
+      end
+    end
+
+    # 
+    # Remove all documents that match the scope given in the Query
+    #
+    def remove_by_scope(scope)
+      @connection.delete_by_query(scope.to_boolean_phrase)
+    end
+
+    # 
+    # Start batch processing
+    #
+    def start_batch
+      batcher.start_new
+    end
+
+    #
+    # Write batch out to Solr and clear it
+    #
+    def flush_batch
+      add_documents(batcher.end_current)
+    end
+
+    private
+
+    def batcher
+      @batcher ||= Batcher.new
+    end
+
+    # 
+    # Convert documents into hash of indexed properties
+    #
+    def prepare(model)
+      document = document_for(model)
+      setup = setup_for(model)
+      if boost = setup.document_boost_for(model)
+        document.attrs[:boost] = boost
+      end
+      setup.all_field_factories.each do |field_factory|
+        field_factory.populate_document(document, model)
+      end
+      document
+    end
+
+    def add_documents(documents)
+      @connection.add(documents)
+    end
+
+    # 
+    # All indexed documents index and store the +id+ and +type+ fields.
+    # This method constructs the document hash containing those key-value
+    # pairs.
+    #
+    def document_for(model)
+      RSolr::Xml::Document.new(
+        :id => Adapters::InstanceAdapter.adapt(model).index_id,
+        :type => Util.superclasses_for(model.class).map { |clazz| clazz.name }
+      )
+    end
+
+    # 
+    # Get the Setup object for the given object's class.
+    #
+    # ==== Parameters
+    #
+    # object<Object>:: The object whose setup is to be retrieved
+    #
+    # ==== Returns
+    #
+    # Sunspot::Setup:: The setup for the object's class
+    #
+    def setup_for(object)
+      Setup.for(object.class) || raise(NoSetupError, "Sunspot is not configured for #{object.class.inspect}")
+    end
+  end
+end

data/sunspot/lib/sunspot/query.rb

@@ -0,0 +1,11 @@
+%w(filter abstract_field_facet connective boost_query date_field_facet range_facet dismax
+   field_facet highlighting pagination restriction common_query
+   standard_query more_like_this more_like_this_query geo geofilt bbox query_facet
+   scope sort sort_composite text_field_boost function_query
+   composite_fulltext field_group).each do |file|
+  require(File.join(File.dirname(__FILE__), 'query', file))
+end
+module Sunspot
+  module Query #:nodoc:all
+  end
+end

data/sunspot/lib/sunspot/query/abstract_field_facet.rb

@@ -0,0 +1,55 @@
+module Sunspot
+  module Query
+    class AbstractFieldFacet
+      include RSolr::Char
+
+      def initialize(field, options)
+        @field, @options = field, options
+      end
+
+      def to_params
+        params = {
+          :facet => 'true',
+        }
+        case @options[:sort]
+        when :count
+          params[qualified_param('sort')] = 'true'
+        when :index
+          params[qualified_param('sort')] = 'false'
+        when nil
+        else
+          raise(
+            ArgumentError,
+            "#{@options[:sort].inspect} is not an allowed value for :sort. Allowed options are :count and :index"
+          )
+        end
+        if @options[:limit]
+          params[qualified_param('limit')] = @options[:limit].to_i
+        end
+        if @options[:offset]
+          params[qualified_param('offset')] = @options[:offset].to_i
+        end
+        if @options[:prefix]
+          params[qualified_param('prefix')] = @options[:prefix].to_s
+        end
+        params[qualified_param('mincount')] = 
+          case
+          when @options[:minimum_count] then @options[:minimum_count].to_i
+          when @options[:zeros] then 0
+          else 1
+          end
+        params
+      end
+
+      private
+
+      def qualified_param(param)
+        :"f.#{key}.facet.#{param}"
+      end
+      
+      def key
+        @key ||= @options[:name] || @field.indexed_name
+      end
+    end
+  end
+end

data/sunspot/lib/sunspot/query/bbox.rb

@@ -0,0 +1,15 @@
+module Sunspot
+  module Query
+    class Bbox
+      def initialize(field, first_corner, second_corner)
+        @field, @first_corner, @second_corner = field, first_corner, second_corner
+      end
+
+      def to_params
+        filter = "#{@field.indexed_name}:[#{@first_corner.join(",")} TO #{@second_corner.join(",")}]"
+
+        {:fq => filter}
+      end
+    end
+  end
+end

data/sunspot/lib/sunspot/query/boost_query.rb

@@ -0,0 +1,24 @@
+module Sunspot
+  module Query
+    # 
+    # Representation of a BoostQuery, which allows the searcher to specify a
+    # scope for which matching documents should have an extra boost. This is
+    # essentially a conjunction, with an extra instance variable containing
+    # the boost that should be applied.
+    #
+    class BoostQuery < Connective::Conjunction #:nodoc:
+      def initialize(boost)
+        super(false)
+        @boost = boost
+      end
+
+      def to_boolean_phrase
+        if @boost.is_a?(FunctionQuery)
+          "#{@boost}"
+        else
+          "#{super}^#{@boost}"
+        end
+      end
+    end
+  end
+end

data/sunspot/lib/sunspot/query/common_query.rb

@@ -0,0 +1,96 @@
+module Sunspot
+  module Query #:nodoc:
+    class CommonQuery
+      def initialize(types)
+        @scope = Scope.new
+        @sort = SortComposite.new
+        @components = [@scope, @sort]
+        if types.length == 1
+          @scope.add_positive_restriction(TypeField.instance, Restriction::EqualTo, types.first)
+        else
+          @scope.add_positive_restriction(TypeField.instance, Restriction::AnyOf, types)
+        end
+      end
+
+      def solr_parameter_adjustment=(block)
+        @parameter_adjustment = block
+      end
+
+      def add_sort(sort)
+        @sort << sort
+      end
+
+      def add_group(group)
+        @components << group
+        group
+      end
+
+      def add_field_facet(facet)
+        @components << facet
+        facet
+      end
+
+      def add_query_facet(facet)
+        @components << facet
+        facet
+      end
+
+      def add_function(function)
+        @components << function
+        function
+      end
+
+      def add_geo(geo)
+        @components << geo
+        geo
+      end
+
+      def paginate(page, per_page, offset = nil)
+        if @pagination
+          @pagination.offset = offset
+          @pagination.page = page
+          @pagination.per_page = per_page
+        else
+          @components << @pagination = Pagination.new(page, per_page, offset)
+        end
+      end
+
+      def to_params
+        params = {}
+        @components.each do |component|
+          Sunspot::Util.deep_merge!(params, component.to_params)
+        end
+        @parameter_adjustment.call(params) if @parameter_adjustment
+        params[:q] ||= '*:*'
+        params
+      end
+
+      def [](key)
+        to_params[key.to_sym]
+      end
+
+      def page
+        @pagination.page if @pagination
+      end
+
+      def per_page
+        @pagination.per_page if @pagination
+      end
+
+
+      private
+
+      #
+      # If we have a single fulltext query, merge is normally. If there are
+      # multiple nested queries, serialize them as `_query_` subqueries.
+      #
+      def merge_fulltext(params)
+        return nil if @fulltexts.empty?
+        return Sunspot::Util.deep_merge!(params, @fulltexts.first.to_params) if @fulltexts.length == 1
+        subqueries = @fulltexts.map {|fulltext| fulltext.to_subquery }.join(' ')
+        Sunspot::Util.deep_merge!(params, {:q => subqueries})
+      end
+
+    end
+  end
+end

data/sunspot/lib/sunspot/query/composite_fulltext.rb

@@ -0,0 +1,36 @@
+module Sunspot
+  module Query
+    class CompositeFulltext
+      def initialize
+        @components = []
+      end
+
+      def add(keywords)
+        @components << dismax = Dismax.new(keywords)
+        dismax
+      end
+      
+      def add_location(field, lat, lng, options)
+        @components << location = Geo.new(field, lat, lng, options)
+        location
+      end
+
+      def to_params
+        case @components.length
+        when 0
+          {}
+        when 1
+          @components.first.to_params.merge(:fl => '* score')
+        else
+          to_subqueries.merge(:fl => '* score')
+        end
+      end
+
+      private
+
+      def to_subqueries
+        { :q => @components.map { |dismax| dismax.to_subquery }.join(' ') }
+      end
+    end
+  end
+end

data/sunspot/lib/sunspot/query/connective.rb

@@ -0,0 +1,206 @@
+module Sunspot
+  module Query
+    module Connective #:nodoc:all
+      # 
+      # Base class for connectives (conjunctions and disjunctions).
+      #
+      class Abstract
+        include Filter
+
+        def initialize(negated = false) #:nodoc:
+          @negated = negated
+          @components = []
+        end
+
+        # 
+        # Add a restriction to the connective.
+        #
+        def add_restriction(negated, field, restriction_type, *value)
+          add_component(restriction_type.new(negated, field, *value))
+        end
+
+        # 
+        # Add a shorthand restriction; the restriction type is determined by
+        # the value.
+        #
+        def add_shorthand_restriction(negated, field, value)
+          restriction_type =
+            case value
+            when Array then Restriction::AnyOf
+            when Range then Restriction::Between
+            else Restriction::EqualTo
+            end
+          add_restriction(negated, field, restriction_type, value)
+        end
+
+        # 
+        # Add a positive restriction. The restriction will match all
+        # documents who match the terms fo the restriction.
+        #
+        def add_positive_restriction(field, restriction_type, value)
+          add_restriction(false, field, restriction_type, value)
+        end
+
+        # 
+        # Add a positive shorthand restriction (see add_shorthand_restriction)
+        #
+        def add_positive_shorthand_restriction(field, value)
+          add_shorthand_restriction(false, field, value)
+        end
+
+        # 
+        # Add a negated restriction. The added restriction will match all
+        # documents who do not match the terms of the restriction.
+        #
+        def add_negated_restriction(field, restriction_type, value)
+          add_restriction(true, field, restriction_type, value)
+        end
+
+        # 
+        # Add a negated shorthand restriction (see add_shorthand_restriction)
+        #
+        def add_negated_shorthand_restriction(field, value)
+          add_shorthand_restriction(true, field, value)
+        end
+
+        # 
+        # Add a new conjunction and return it.
+        #
+        def add_conjunction
+          add_component(Conjunction.new)
+        end
+
+        # 
+        # Add a new disjunction and return it.
+        #
+        def add_disjunction
+          add_component(Disjunction.new)
+        end
+
+        # 
+        # Add an arbitrary component to the conjunction, and return it.
+        # The component must respond to #to_boolean_phrase
+        #
+        def add_component(component)
+          @components << component
+          component
+        end
+
+        # 
+        # Express the connective as a Lucene boolean phrase.
+        #
+        def to_boolean_phrase #:nodoc:
+          unless @components.empty?
+            phrase =
+              if @components.length == 1
+                @components.first.to_boolean_phrase
+              else
+                component_phrases = @components.map do |component|
+                  component.to_boolean_phrase
+                end
+                "(#{component_phrases.join(" #{connector} ")})"
+              end
+            if negated?
+              "-#{phrase}"
+            else
+              phrase
+            end
+          end
+        end
+
+        # 
+        # Connectives can be negated during the process of denormalization that
+        # is performed when a disjunction contains a negated component. This
+        # method conforms to the duck type for all boolean query components.
+        #
+        def negated?
+          @negated
+        end
+
+        # 
+        # Returns a new connective that's a negated version of this one.
+        #
+        def negate
+          negated = self.class.new(!negated?)
+          @components.each do |component|
+            negated.add_component(component)
+          end
+          negated
+        end
+      end
+
+      # 
+      # Disjunctions combine their components with an OR operator.
+      #
+      class Disjunction < Abstract
+        class <<self
+          def inverse
+            Conjunction
+          end
+        end
+
+        # 
+        # Express this disjunction as a Lucene boolean phrase
+        #
+        def to_boolean_phrase
+          if @components.any? { |component| component.negated? }
+            denormalize.to_boolean_phrase
+          else
+            super
+          end
+        end
+
+        # 
+        # No-op - this is already a disjunction
+        #
+        def add_disjunction
+          self
+        end
+
+        private
+
+        def connector
+          'OR'
+        end
+
+        # 
+        # If a disjunction contains negated components, it must be
+        # "denormalized", because the Lucene parser interprets any negated
+        # boolean phrase using AND semantics (this isn't a bug, it's just a
+        # subtlety of how Lucene parses queries). So, per DeMorgan's law we
+        # create a negated conjunction and add to it all of our components,
+        # negated themselves, which creates a query whose Lucene semantics are
+        # in line with our intentions.
+        #
+        def denormalize
+          denormalized = self.class.inverse.new(!negated?)
+          @components.each do |component|
+            denormalized.add_component(component.negate)
+          end
+          denormalized
+        end
+      end
+
+      # 
+      # Conjunctions combine their components with an AND operator.
+      #
+      class Conjunction < Abstract
+        class <<self
+          def inverse
+            Disjunction
+          end
+        end
+
+        def add_conjunction
+          self
+        end
+
+        private
+
+        def connector
+          'AND'
+        end
+      end
+    end
+  end
+end