gojee-sunspot 2.0.3 → 2.0.4

data/lib/sunspot/search/hit.rb

@@ -0,0 +1,150 @@
+module Sunspot
+  module Search
+    # 
+    # Hit objects represent the raw information returned by Solr for a single
+    # document. As well as the primary key and class name, hit objects give
+    # access to stored field values, keyword relevance score, and keyword
+    # highlighting.
+    #
+    class Hit
+      SPECIAL_KEYS = Set.new(%w(id type score)) #:nodoc:
+
+      # 
+      # Primary key of object associated with this hit, as string.
+      #
+      attr_reader :primary_key
+      # 
+      # Class name of object associated with this hit, as string.
+      #
+      attr_reader :class_name
+      # 
+      # Keyword relevance score associated with this result. Nil if this hit
+      # is not from a keyword search.
+      #
+      attr_reader :score
+      #
+
+      attr_writer :result #:nodoc:
+
+      def initialize(raw_hit, highlights, search) #:nodoc:
+        @class_name, @primary_key = *raw_hit['id'].match(/([^ ]+) (.+)/)[1..2]
+        @score = raw_hit['score']
+        @search = search
+        @stored_values = raw_hit
+        @stored_cache = {}
+        @highlights = highlights
+      end
+      
+      #
+      # Returns all highlights for this hit when called without parameters.
+      # When a field_name is provided, returns only the highlight for this field.
+      #
+      def highlights(field_name = nil)
+        if field_name.nil?
+          highlights_cache.values.flatten 
+        else
+          highlights_cache[field_name.to_sym]
+        end || []
+      end
+
+      #
+      # Return the first highlight found for a given field, or nil if there is
+      # none.
+      #
+      def highlight(field_name)
+        highlights(field_name).first
+      end
+
+      # 
+      # Retrieve stored field value. For any attribute field configured with
+      # :stored => true, the Hit object will contain the stored value for
+      # that field. The value of this field will be typecast according to the
+      # type of the field.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>::
+      #   The name of the field for which to retrieve the stored value.
+      # dynamic_field_name<Symbol>::
+      #   If you want to access a stored dynamic field, this should be the
+      #   dynamic component of the field name.
+      #
+      def stored(field_name, dynamic_field_name = nil)
+        field_key =
+          if dynamic_field_name
+            [field_name.to_sym, dynamic_field_name.to_sym]
+          else
+            field_name.to_sym
+          end
+        return @stored_cache[field_key] if @stored_cache.has_key?(field_key)
+        @stored_cache[field_key] = stored_value(field_name, dynamic_field_name)
+      end
+
+      # 
+      # Retrieve the instance associated with this hit. This is lazy-loaded, but
+      # the first time it is called on any hit, all the hits for the search will
+      # load their instances using the adapter's #load_all method.
+      #
+      def result
+        return @result if defined?(@result)
+        @search.populate_hits
+        @result
+      end
+      alias_method :instance, :result
+
+      def inspect #:nodoc:
+        "#<Sunspot::Search::Hit:#{@class_name} #{@primary_key}>"
+      end
+
+      #
+      # Returns the instance primary key when the Hit is used to generate urls
+      # For example, using a search that stores the :name attribute:
+      #
+      #   hits = Sunspot.search(Object) do ...
+      #
+      #   hits.each do |hit|
+      #     link_to hit.stored(:name), edit_object_path(hit)
+      #   end
+      #
+      def to_param
+        self.primary_key
+      end
+
+      private
+
+      def setup
+        @setup ||= Sunspot::Setup.for(Util.full_const_get(@class_name))
+      end
+
+      def highlights_cache
+        @highlights_cache ||=
+          begin
+            cache = {}
+            if @highlights
+              @highlights.each_pair do |indexed_field_name, highlight_strings|
+                field_name = indexed_field_name.sub(/_[a-z]+$/, '').to_sym
+                cache[field_name] = highlight_strings.map do |highlight_string|
+                  Highlight.new(field_name, highlight_string)
+                end
+              end
+            end
+            cache
+          end
+      end
+
+      def stored_value(field_name, dynamic_field_name)
+        setup.stored_fields(field_name, dynamic_field_name).each do |field|
+          value = @stored_values[field.indexed_name]
+
+          if Array === value
+            return value.map { |item| field.cast(item) }
+          elsif !value.nil?
+            return field.cast(value)
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/sunspot/search/hit_enumerable.rb

@@ -0,0 +1,72 @@
+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
+        verified_hits.each do |hit|
+          yield(hit, hit.result)
+        end
+      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:
+        # FIXME: This method does not belong here, but I was getting bogged
+        # down trying to figure out where it should go. Punted for now.
+        # - AL 27 Nov 2011
+        (@data_accessors ||= {})[clazz.name.to_sym] ||=
+          Adapters::DataAccessor.create(clazz)
+      end
+    end
+  end
+end

data/lib/sunspot/search/more_like_this_search.rb

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

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

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

@@ -0,0 +1,21 @@
+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/search.rb

@@ -0,0 +1,9 @@
+%w(abstract_search standard_search more_like_this_search query_facet field_facet
+   date_facet facet_row hit highlight field_group group hit_enumerable).each do |file|
+  require File.join(File.dirname(__FILE__), 'search', file)
+end
+
+module Sunspot
+  module Search
+  end
+end

data/lib/sunspot/session.rb

@@ -0,0 +1,262 @@
+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/abstract_session_proxy.rb

@@ -0,0 +1,29 @@
+module Sunspot
+  module SessionProxy
+    class AbstractSessionProxy #:nodoc:
+      class <<self
+        def delegate(*args)
+          options = Util.extract_options_from(args)
+          delegate = options[:to]
+          args.each do |method|
+            module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+              def #{method}(*args, &block)
+                #{delegate}.#{method}(*args, &block)
+              end
+            RUBY
+          end
+        end
+
+        def not_supported(*methods)
+          methods.each do |method|
+            module_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+              def #{method}(*args, &block)
+                raise NotSupportedError, "#{name} does not support #{method.inspect}"
+              end
+            RUBY
+          end
+        end
+      end
+    end
+  end
+end