sunspot_solr 2.0.0.pre.120924 → 2.0.0.pre.120925

data/sunspot/lib/sunspot/indexer.rb

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

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

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

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

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

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

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

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