gojee-sunspot 2.0.2 → 2.0.3

data/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/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/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/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/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

data/lib/sunspot/session_proxy.rb

@@ -1,95 +0,0 @@
-module Sunspot
-  # 
-  # This module contains several Session Proxy implementations, which can be
-  # used to decorate one or more Session objects and add extra functionality.
-  # The user can also implement their own Session Proxy classes; a Session Proxy
-  # must simply implement the same public API as the Sunspot::Session class.
-  #
-  # When implementing a session proxy, some methods of Session may not be
-  # practical, or even logical, to implement. In this case, the method should
-  # raise a Sunspot::SessionProxy::NotSupportedError (several methods in the
-  # built-in session proxies raise this error).
-  #
-  # To use a session proxy in normal Sunspot usage, you can use the
-  # Sunspot.session= method, which will cause Sunspot to delegate all of its
-  # session-related class methods (most of them) to the proxy. Session proxies
-  # can also easily be chained, although the details of chaining depend on the
-  # proxy implementation.
-  #
-  # ===== Example: Chain a MasterSlaveSessionProxy with a ThreadLocalSessionProxy
-  #
-  #   master_session = Sunspot::SessionProxy::ThreadLocalSessionProxy.new
-  #   slave_session = Sunspot::SessionProxy::ThreadLocalSessionProxy.new
-  #   master_session.config.solr.url = 'http://master-solr.local:9080/solr'
-  #   slave_session.config.solr.url = 'http://slave-solr.local:9080/solr'
-  #   Sunspot.session = Sunspot::SessionProxy::MasterSlaveSessionProxy.new(master_session, slave_session)
-  #
-  module SessionProxy
-    NotSupportedError = Class.new(StandardError)
-
-    autoload(
-      :AbstractSessionProxy,
-      File.join(
-        File.dirname(__FILE__),
-        'session_proxy',
-        'abstract_session_proxy'
-      )
-    )
-    autoload(
-      :ThreadLocalSessionProxy,
-      File.join(
-        File.dirname(__FILE__),
-        'session_proxy',
-        'thread_local_session_proxy'
-      )
-    )
-    autoload(
-      :MasterSlaveSessionProxy,
-      File.join(
-        File.dirname(__FILE__),
-        'session_proxy',
-        'master_slave_session_proxy'
-      )
-    )
-    autoload(
-      :ShardingSessionProxy,
-      File.join(
-        File.dirname(__FILE__),
-        'session_proxy',
-        'sharding_session_proxy'
-      )
-    )
-    autoload(
-      :ClassShardingSessionProxy,
-      File.join(
-        File.dirname(__FILE__),
-        'session_proxy',
-        'class_sharding_session_proxy'
-      )
-    )
-    autoload(
-      :IdShardingSessionProxy,
-      File.join(
-        File.dirname(__FILE__),
-        'session_proxy',
-        'id_sharding_session_proxy'
-      )
-    )
-    autoload(
-      :SilentFailSessionProxy,
-      File.join(
-        File.dirname(__FILE__),
-        'session_proxy',
-        'silent_fail_session_proxy'
-      )
-    )
-    autoload(
-      :MulticoreSessionProxy,
-      File.join(
-        File.dirname(__FILE__),
-        'session_proxy',
-        'multicore_session_proxy'
-      )
-    )
-  end
-end