gojee-sunspot 2.0.2

data/lib/sunspot/search/date_facet.rb

@@ -0,0 +1,35 @@
+module Sunspot
+  module Search
+    class DateFacet
+      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_dates'][@field.indexed_name]
+            gap = (@options[:time_interval] || 86400).to_i
+            rows = []
+            data.each_pair do |value, count|
+              if value =~ /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/
+                start_time = @field.cast(value)
+                end_time = start_time + gap
+                rows << FacetRow.new(start_time..end_time, 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/lib/sunspot/search/facet_row.rb

@@ -0,0 +1,27 @@
+module Sunspot
+  module 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,88 @@
+module Sunspot
+  module Search
+    # 
+    # A FieldFacet is a facet whose rows are all values for a certain field, in
+    # contrast to a QueryFacet, whose rows represent arbitrary queries.
+    #
+    class FieldFacet < QueryFacet
+      def initialize(field, search, options) #:nodoc:
+        super((options[:name] || field.name).to_sym, search, options)
+        @field = field
+      end
+
+      def field_name
+        @field.name
+      end
+
+      # 
+      # Get the rows returned for this facet.
+      #
+      # ==== Options (options)
+      #
+      # :verify::
+      #   Only return rows for which the referenced object exists in the data
+      #   store. This option is ignored unless the field associated with this
+      #   facet is configured with a :references argument.
+      #
+      # ==== Returns
+      #
+      # Array:: Array of FacetRow objects
+      #
+      def rows(options = {})
+        if options[:verify]
+          verified_rows
+        else
+          @rows ||=
+            begin
+              rows = super
+              has_query_facets = !rows.empty?
+              if @search.facet_response['facet_fields']
+                if data = @search.facet_response['facet_fields'][key]
+                  data.each_slice(2) do |value, count|
+                    row = FacetRow.new(@field.cast(value), count, self)
+                    rows << row
+                  end
+                end
+              end
+              sort_rows!(rows) if has_query_facets
+              rows
+            end
+        end
+      end
+
+      # 
+      # If this facet references a model class, populate the rows with instances
+      # of the model class by loading them out of the appropriate adapter.
+      #
+      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
+          true
+        end
+      end
+
+      private
+
+      def verified_rows
+        if @field.reference
+          @verified_rows ||= rows.select { |row| row.instance }
+        else
+          rows
+        end
+      end
+      
+      def key
+        @key ||= (@options[:name] || @field.indexed_name).to_s
+      end
+    end
+  end
+end

data/lib/sunspot/search/field_group.rb

@@ -0,0 +1,32 @@
+module Sunspot
+  module Search
+    class FieldGroup
+      def initialize(field, search, options) #:nodoc:
+        @field, @search, @options = field, search, options
+      end
+
+      def groups
+        @groups ||=
+          begin
+            if solr_response
+              solr_response['groups'].map do |group|
+                Group.new(group['groupValue'], group['doclist'], @search)
+              end
+            end
+          end
+      end
+
+      def matches
+        if solr_response
+          solr_response['matches'].to_i
+        end
+      end
+
+      private
+
+      def solr_response
+        @search.group_response[@field.indexed_name.to_s]
+      end
+    end
+  end
+end

data/lib/sunspot/search/group.rb

@@ -0,0 +1,50 @@
+require 'sunspot/search/hit_enumerable'
+
+module Sunspot
+  module Search
+    class Group
+      attr_reader :value
+
+      include HitEnumerable
+
+      def initialize(value, doclist, search)
+        @value, @doclist, @search = value, doclist, search
+      end
+
+      def hits(options = {})
+        if options[:verify]
+          super
+        else
+          @hits ||= super
+        end
+      end
+
+      def verified_hits
+        @verified_hits ||= super
+      end
+
+      def results
+        @results ||= verified_hits.map { |hit| hit.instance }
+      end
+
+      def highlights_for(doc)
+        @search.highlights_for(doc)
+      end
+
+      def solr_docs
+        @doclist['docs']
+      end
+      
+      #
+      # The total number of documents matching the query for this group
+      #
+      # ==== Returns
+      #
+      # Integer:: Total matching documents
+      # 
+      def total
+        @doclist['numFound']
+      end      
+    end
+  end
+end

data/lib/sunspot/search/highlight.rb

@@ -0,0 +1,38 @@
+module Sunspot
+  module 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,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