nxa-sunspot 0.10.7

data/lib/sunspot/search/facet_row.rb

@@ -0,0 +1,27 @@
+module Sunspot
+  class Search
+    class FacetRow
+      attr_reader :value, :count
+      attr_writer :instance #:nodoc:
+
+      def initialize(value, count, facet) #:nodoc:
+        @value, @count, @facet = value, count, facet
+      end
+
+      # 
+      # Return the instance referenced by this facet row. Only valid for field
+      # facets whose fields are defined with the :references key.
+      #
+      def instance
+        if !defined?(@instance)
+          @facet.populate_instances
+        end
+        @instance
+      end
+
+      def inspect
+        "<Sunspot::Search::FacetRow:#{value.inspect} (#{count})>"
+      end
+    end
+  end
+end

data/lib/sunspot/search/field_facet.rb

@@ -0,0 +1,44 @@
+module Sunspot
+  class Search
+    class FieldFacet < QueryFacet
+      alias_method :field_name, :name
+
+      def initialize(field, search, options) #:nodoc:
+        super(field.name, search, options)
+        @field = field
+      end
+
+      def rows
+        @rows ||=
+          begin
+            rows = super
+            has_query_facets = !rows.empty?
+            if @search.facet_response['facet_fields']
+              if data = @search.facet_response['facet_fields'][@field.indexed_name]
+                data.each_slice(2) do |value, count|
+                  rows << FacetRow.new(@field.cast(value), count, self)
+                end
+              end
+            end
+            sort_rows!(rows) if has_query_facets
+            rows
+          end
+      end
+
+      def populate_instances #:nodoc:
+        if reference = @field.reference
+          values_hash = rows.inject({}) do |hash, row|
+            hash[row.value] = row
+            hash
+          end
+          instances = Adapters::DataAccessor.create(Sunspot::Util.full_const_get(reference)).load_all(
+            values_hash.keys
+          )
+          instances.each do |instance|
+            values_hash[Adapters::InstanceAdapter.adapt(instance).id].instance = instance
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/search/highlight.rb

@@ -0,0 +1,38 @@
+module Sunspot
+  class Search
+    # 
+    # A Highlight represents a single highlighted fragment of text from a
+    # document. Depending on the highlighting parameters used for search, there
+    # may be more than one Highlight object for a given field in a given result.
+    #
+    class Highlight
+      HIGHLIGHT_MATCHER = /@@@hl@@@(.*?)@@@endhl@@@/ #:nodoc:
+      
+      #
+      # The name of the field in which the highlight appeared.
+      #
+      attr_reader :field_name
+            
+      def initialize(field_name, highlight) #:nodoc:
+        @field_name = field_name.to_sym
+        @highlight = highlight.to_s.strip
+      end
+      
+      #
+      # Returns the highlighted text with formatting according to the template given in &block.
+      # When no block is given, <em> and </em> are used to surround the highlight.
+      #
+      # ==== Example
+      #
+      #   search.highlights(:body).first.format { |word| "<strong>#{word}</strong>" }
+      #
+      def format(&block)
+        block ||= proc { |word| "<em>#{word}</em>" }
+        @highlight.gsub(HIGHLIGHT_MATCHER) do
+          block.call(Regexp.last_match[1])
+        end
+      end
+      alias_method :formatted, :format
+    end
+  end
+end

data/lib/sunspot/search/hit.rb

@@ -0,0 +1,117 @@
+module Sunspot
+  class 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 geographical
+    # distance (for geographical search).
+    #
+    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
+      #
+      # For geographical searches, this is the distance between the search
+      # centerpoint and the document's location. Otherwise, it's nil.
+      # 
+      attr_reader :distance
+
+      attr_writer :instance #:nodoc:
+
+      def initialize(raw_hit, highlights, search) #:nodoc:
+        @class_name, @primary_key = *raw_hit['id'].match(/([^ ]+) (.+)/)[1..2]
+        @score = raw_hit['score']
+        @distance = raw_hit['geo_distance'].to_f if raw_hit['geo_distance']
+        @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
+
+      # 
+      # 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.
+      #
+      def stored(field_name)
+        @stored_cache[field_name.to_sym] ||= stored_value(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 instance
+        if @instance.nil?
+          @search.populate_hits!
+        end
+        @instance
+      end
+
+      def inspect #:nodoc:
+        "#<Sunspot::Search::Hit:#{@class_name} #{@primary_key}>"
+      end
+
+      private
+
+      def setup
+        @setup ||= Sunspot::Setup.for(@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)
+        setup.stored_fields(field_name).each do |field|
+          if value = @stored_values[field.indexed_name]
+            return field.cast(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/search/query_facet.rb

@@ -0,0 +1,62 @@
+module Sunspot
+  class 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
+        @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 @options[: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 @options[:limit]
+          rows.slice!(@options[:limit], rows.length)
+        end
+        rows
+      end
+    end
+  end
+end

data/lib/sunspot/session.rb

@@ -0,0 +1,236 @@
+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, master_connection = nil)
+      @config = config
+      yield(@config) if block_given?
+      @connection = connection
+      @master_connection = master_connection
+      @deletes = @adds = 0
+    end
+
+    # 
+    # See Sunspot.new_search
+    #
+    def new_search(*types)
+      types.flatten!
+      if types.empty?
+        raise(ArgumentError, "You must specify at least one type to search")
+      end
+      setup =
+        if types.length == 1
+          Setup.for(types.first)
+        else
+          CompositeSetup.for(types)
+          end
+      Search.new(connection, setup, Query::Query.new(types), @config)
+    end
+
+    #
+    # See Sunspot.search
+    #
+    def search(*types, &block)
+      search = new_search(*types)
+      search.build(&block) if block
+      search.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
+      master_connection.commit
+    end
+
+    # 
+    # See Sunspot.remove
+    #
+    def remove(*objects)
+      objects.flatten!
+      @deletes += objects.length
+      objects.each do |object|
+        indexer.remove(object)
+      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(master_connection)
+      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
+    #
+    # Solr::Connection:: The connection for this session
+    #
+    def connection
+      @connection ||=
+        begin
+          connection = self.class.connection_class.connect(
+            :url => config.solr.url
+          )
+          connection
+        end
+    end
+
+    # 
+    # Retrieve the Solr connection to the master for this session, creating one
+    # if it does not already exist.
+    #
+    # ==== Returns
+    #
+    # Solr::Connection:: The connection for this session
+    #
+    def master_connection
+      @master_connection ||=
+        begin
+          if config.master_solr.url && config.master_solr.url != config.solr.url
+            master_connection = self.class.connection_class.new(
+              RSolr::Connection::NetHttp.new(:url => config.master_solr.url)
+            )
+            master_connection
+          else
+            connection
+          end
+        end
+    end
+
+    def indexer
+      @indexer ||= Indexer.new(master_connection)
+    end
+  end
+end