gojee-sunspot 2.0.2 → 2.0.3

data/lib/sunspot/search/date_facet.rb

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

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

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

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

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

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

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

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