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

data/sunspot/lib/sunspot/search/hit_enumerable.rb

@@ -1,68 +0,0 @@
-module Sunspot
-  module Search
-    module HitEnumerable #:nodoc:
-      def hits(options = {})
-        if options[:verify]
-          verified_hits
-        elsif solr_docs
-          solr_docs.map { |d| Hit.new(d, highlights_for(d), self) }
-        else
-          []
-        end
-      end
-
-      def verified_hits
-        hits.select { |h| h.result }
-      end
-
-      # 
-      # Populate the Hit objects with their instances. This is invoked the first
-      # time any hit has its instance requested, and all hits are loaded as a
-      # batch.
-      #
-      def populate_hits #:nodoc:
-        id_hit_hash = Hash.new { |h, k| h[k] = {} }
-        hits.each do |hit|
-          id_hit_hash[hit.class_name][hit.primary_key] = hit
-        end
-        id_hit_hash.each_pair do |class_name, hits|
-          ids = hits.map { |id, hit| hit.primary_key }
-          data_accessor = data_accessor_for(Util.full_const_get(class_name))          
-          hits_for_class = id_hit_hash[class_name]
-          data_accessor.load_all(ids).each do |result|
-            hit = hits_for_class.delete(Adapters::InstanceAdapter.adapt(result).id.to_s)
-            hit.result = result
-          end
-          hits_for_class.values.each { |hit| hit.result = nil }
-        end
-      end
-
-      #
-      # Convenience method to iterate over hit and result objects. Block is
-      # yielded a Sunspot::Server::Hit instance and a Sunspot::Server::Result
-      # instance.
-      #
-      # Note that this method iterates over verified hits (see #hits method
-      # for more information).
-      #
-      def each_hit_with_result
-        return enum_for(:each_hit_with_result) unless block_given?
-        verified_hits.each { |hit| yield hit, hit.result }
-      end
-
-      # 
-      # Get the data accessor that will be used to load a particular class out of
-      # persistent storage. Data accessors can implement any methods that may be
-      # useful for refining how data is loaded out of storage. When building a
-      # search manually (e.g., using the Sunspot#new_search method), this should
-      # be used before calling #execute(). Use the
-      # Sunspot::DSL::Search#data_accessor_for method when building searches using
-      # the block DSL.
-      #
-      def data_accessor_for(clazz) #:nodoc:
-        @registry ||= Sunspot::Adapters::Registry.new
-        @registry.retrieve(clazz)
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/search/more_like_this_search.rb

@@ -1,31 +0,0 @@
-module Sunspot
-  # 
-  # This class encapsulates the results of a Solr MoreLikeThis search. It provides access
-  # to search results, total result count, and pagination information.
-  # Instances of MoreLikeThis are returned by the Sunspot.more_like_this and
-  # Sunspot.new_more_like_this methods.
-  #
-  module Search
-    class MoreLikeThisSearch < AbstractSearch
-      def execute
-        if @query.more_like_this.fields.empty?
-          @setup.all_more_like_this_fields.each do |field|
-            @query.more_like_this.add_field(field)
-          end
-        end
-        super
-      end
-
-      def request_handler
-        super || :mlt
-      end
-
-      private
-
-      # override
-      def dsl
-        DSL::MoreLikeThisQuery.new(self, @query, @setup)
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/search/paginated_collection.rb

@@ -1,57 +0,0 @@
-module Sunspot
-  module Search
-
-    class PaginatedCollection
-      instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval|object_id/ }
-
-      attr_reader :current_page, :per_page
-      attr_accessor :total_count
-      alias :total_entries :total_count
-      alias :total_entries= :total_count=
-      alias :limit_value :per_page
-
-      def initialize(collection, page, per_page, total)
-        @collection   = collection
-        @current_page = page
-        @per_page     = per_page
-        @total_count  = total
-      end
-
-      def total_pages
-        (total_count.to_f / per_page).ceil
-      end
-      alias :num_pages :total_pages
-
-      def first_page?
-        current_page == 1
-      end
-
-      def last_page?
-        current_page >= total_pages
-      end
-
-      def previous_page
-        current_page > 1 ? (current_page - 1) : nil
-      end
-
-      def next_page
-        current_page < total_pages ? (current_page + 1) : nil
-      end
-
-      def out_of_bounds?
-        current_page > total_pages
-      end
-
-      def offset
-        (current_page - 1) * per_page
-      end
-
-      private
-
-      def method_missing(method, *args, &block)
-        @collection.send(method, *args, &block)
-      end
-
-    end
-  end
-end

data/sunspot/lib/sunspot/search/query_facet.rb

@@ -1,67 +0,0 @@
-module Sunspot
-  module Search
-    class QueryFacet
-      RequestedFacet = Struct.new(:label, :boolean_phrase) #:nodoc:
-
-      attr_reader :name
-
-      def initialize(name, search, options) #:nodoc:
-        @name, @search, @options = name, search, options
-        @requested_facets = []
-      end
-
-      def rows(options = {})
-        @rows ||=
-          begin
-            data = @search.facet_response['facet_queries']
-            rows = []
-            minimum_count =
-              case
-              when @options[:minimum_count] then @options[:minimum_count]
-              when @options[:zeros] then 0
-              else 1
-              end
-            @requested_facets.each do |requested_facet|
-              count = data[requested_facet.boolean_phrase] || 0
-              if count >= minimum_count
-                rows << FacetRow.new(requested_facet.label, count, self)
-              end
-            end
-            sort_rows!(rows)
-          end
-      end
-
-      def add_row(label, boolean_phrase) #:nodoc:
-        @requested_facets << RequestedFacet.new(label, boolean_phrase)
-      end
-
-      private
-
-      def sort_rows!(rows)
-        case @options[:sort] || (:count if limit)
-        when :count
-          rows.sort! { |lrow, rrow| rrow.count <=> lrow.count }
-        when :index
-          rows.sort! do |lrow, rrow|
-            if lrow.respond_to?(:<=>)
-              lrow.value <=> rrow.value
-            elsif lrow.respond_to?(:first) && rrow.respond_to?(:first) && lrow.first.respond_to?(:<=>)
-              lrow.first.value <=> rrow.first.value
-            else
-              lrow.value.to_s <=> rrow.value.to_s
-            end
-          end
-        end
-        if limit
-          rows.replace(rows.first(limit))
-        end
-        rows
-      end
-
-      def limit
-        return @limit if defined?(@limit)
-        @limit = (@options[:limit].to_i if @options[:limit].to_i > 0)
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/search/range_facet.rb

@@ -1,37 +0,0 @@
-module Sunspot
-  module Search
-    class RangeFacet
-      def initialize(field, search, options)
-        @field, @search, @options = field, search, options
-      end
-
-      def field_name
-        @field.name
-      end
-
-      def rows
-        @rows ||=
-          begin
-            data = @search.facet_response['facet_ranges'][@field.indexed_name]
-            gap = (@options[:range_interval] || 10).to_i
-            rows = []
-            
-            if data['counts']
-              Hash[*data['counts']].each_pair do |start_str, count|
-                start = start_str.to_f
-                finish = start + gap
-                rows << FacetRow.new(start..finish, count, self)
-              end
-            end
-
-            if @options[:sort] == :count
-              rows.sort! { |lrow, rrow| rrow.count <=> lrow.count }
-            else
-              rows.sort! { |lrow, rrow| lrow.value.first <=> rrow.value.first }
-            end
-            rows
-          end
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/search/standard_search.rb

@@ -1,21 +0,0 @@
-module Sunspot
-  module Search
-    # 
-    # This class encapsulates the results of a Solr search. It provides access
-    # to search results, total result count, facets, and pagination information.
-    # Instances of Search are returned by the Sunspot.search and
-    # Sunspot.new_search methods.
-    #
-    class StandardSearch < AbstractSearch
-      def request_handler
-        super || :select
-      end
-  
-      private
-  
-      def dsl
-        DSL::Search.new(self, @setup)
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/session.rb

@@ -1,262 +0,0 @@
-module Sunspot
-  # 
-  # A Sunspot session encapsulates a connection to Solr and a set of
-  # configuration choices. Though users of Sunspot may manually instantiate
-  # Session objects, in the general case it's easier to use the singleton
-  # stored in the Sunspot module. Since the Sunspot module provides all of
-  # the instance methods of Session as class methods, they are not documented
-  # again here.
-  #
-  class Session
-    class <<self
-      attr_writer :connection_class #:nodoc:
-      
-      # 
-      # For testing purposes
-      #
-      def connection_class #:nodoc:
-        @connection_class ||= RSolr
-      end
-    end
-
-    # 
-    # Sunspot::Configuration object for this session
-    #
-    attr_reader :config
-
-    # 
-    # Sessions are initialized with a Sunspot configuration and a Solr
-    # connection. Usually you will want to stick with the default arguments
-    # when instantiating your own sessions.
-    #
-    def initialize(config = Configuration.build, connection = nil)
-      @config = config
-      yield(@config) if block_given?
-      @connection = connection
-      @deletes = @adds = 0
-    end
-
-    # 
-    # See Sunspot.new_search
-    #
-    def new_search(*types, &block)
-      types.flatten!
-      search = Search::StandardSearch.new(
-        connection,
-        setup_for_types(types),
-        Query::StandardQuery.new(types),
-        @config
-      )
-      search.build(&block) if block
-      search
-    end
-
-    #
-    # See Sunspot.search
-    #
-    def search(*types, &block)
-      search = new_search(*types, &block)
-      search.execute
-    end
-
-    # 
-    # See Sunspot.new_more_like_this
-    #
-    def new_more_like_this(object, *types, &block)
-      types[0] ||= object.class
-      mlt = Search::MoreLikeThisSearch.new(
-        connection,
-        setup_for_types(types),
-        Query::MoreLikeThisQuery.new(object, types),
-        @config
-      )
-      mlt.build(&block) if block
-      mlt
-    end
-
-    #
-    # See Sunspot.more_like_this
-    #
-    def more_like_this(object, *types, &block)
-      mlt = new_more_like_this(object, *types, &block)
-      mlt.execute
-    end
-
-    #
-    # See Sunspot.index
-    #
-    def index(*objects)
-      objects.flatten!
-      @adds += objects.length
-      indexer.add(objects)
-    end
-
-    # 
-    # See Sunspot.index!
-    #
-    def index!(*objects)
-      index(*objects)
-      commit
-    end
-
-    #
-    # See Sunspot.commit
-    #
-    def commit
-      @adds = @deletes = 0
-      connection.commit
-    end
-
-    #
-    # See Sunspot.optimize
-    #
-    def optimize
-      @adds = @deletes = 0
-      connection.optimize
-    end
-
-    # 
-    # See Sunspot.remove
-    #
-    def remove(*objects, &block)
-      if block
-        types = objects
-        conjunction = Query::Connective::Conjunction.new
-        if types.length == 1
-          conjunction.add_positive_restriction(TypeField.instance, Query::Restriction::EqualTo, types.first)
-        else
-          conjunction.add_positive_restriction(TypeField.instance, Query::Restriction::AnyOf, types)
-        end
-        dsl = DSL::Scope.new(conjunction, setup_for_types(types))
-        Util.instance_eval_or_call(dsl, &block)
-        indexer.remove_by_scope(conjunction)
-      else
-        objects.flatten!
-        @deletes += objects.length
-        objects.each do |object|
-          indexer.remove(object)
-        end
-      end
-    end
-
-    # 
-    # See Sunspot.remove!
-    #
-    def remove!(*objects)
-      remove(*objects)
-      commit
-    end
-
-    # 
-    # See Sunspot.remove_by_id
-    #
-    def remove_by_id(clazz, id)
-      class_name =
-        if clazz.is_a?(Class)
-          clazz.name
-        else
-          clazz.to_s
-        end
-      indexer.remove_by_id(class_name, id)
-    end
-
-    # 
-    # See Sunspot.remove_by_id!
-    #
-    def remove_by_id!(clazz, id)
-      remove_by_id(clazz, id)
-      commit
-    end
-
-    #
-    # See Sunspot.remove_all
-    #
-    def remove_all(*classes)
-      classes.flatten!
-      if classes.empty?
-        @deletes += 1
-        indexer.remove_all
-      else
-        @deletes += classes.length
-        classes.each { |clazz| indexer.remove_all(clazz) }
-      end
-    end
-
-    # 
-    # See Sunspot.remove_all!
-    #
-    def remove_all!(*classes)
-      remove_all(*classes)
-      commit
-    end
-
-    # 
-    # See Sunspot.dirty?
-    #
-    def dirty?
-      (@deletes + @adds) > 0
-    end
-
-    # 
-    # See Sunspot.commit_if_dirty
-    #
-    def commit_if_dirty
-      commit if dirty?
-    end
-    
-    # 
-    # See Sunspot.delete_dirty?
-    #
-    def delete_dirty?
-      @deletes > 0
-    end
-
-    # 
-    # See Sunspot.commit_if_delete_dirty
-    #
-    def commit_if_delete_dirty
-      commit if delete_dirty?
-    end
-    
-    # 
-    # See Sunspot.batch
-    #
-    def batch
-      indexer.start_batch
-      yield
-      indexer.flush_batch
-    end
-
-    private
-
-    # 
-    # Retrieve the Solr connection for this session, creating one if it does not
-    # already exist.
-    #
-    # ==== Returns
-    #
-    # RSolr::Connection::Base:: The connection for this session
-    #
-    def connection
-      @connection ||=
-        self.class.connection_class.connect(:url          => config.solr.url,
-                                            :read_timeout => config.solr.read_timeout,
-                                            :open_timeout => config.solr.open_timeout)
-    end
-
-    def indexer
-      @indexer ||= Indexer.new(connection)
-    end
-
-    def setup_for_types(types)
-      if types.empty?
-        raise(ArgumentError, "You must specify at least one type to search")
-      end
-      if types.length == 1
-        Setup.for(types.first)
-      else
-        CompositeSetup.for(types)
-      end
-    end
-  end
-end