pduey-sunspot 1.2.1.1

data/lib/sunspot/query/scope.rb

@@ -0,0 +1,9 @@
+module Sunspot
+  module Query
+    class Scope < Connective::Conjunction
+      def to_params
+        { :fq => @components.map { |component| component.to_filter_query }}
+      end
+    end
+  end
+end

data/lib/sunspot/query/sort.rb

@@ -0,0 +1,95 @@
+module Sunspot
+  module Query
+    # 
+    # The classes in this module implement query components that build sort
+    # parameters for Solr. As well as regular sort on fields, there are several
+    # "special" sorts that allow ordering for metrics calculated during the
+    # search.
+    # 
+    module Sort #:nodoc: all
+      DIRECTIONS = {
+        :asc => 'asc',
+        :ascending => 'asc',
+        :desc => 'desc',
+        :descending => 'desc'
+      }
+
+      class <<self
+        # 
+        # Certain field names are "special", referring to specific non-field
+        # sorts, which are generally by other metrics associated with hits.
+        #
+        # XXX I'm not entirely convinced it's a good idea to prevent anyone from
+        # ever sorting by a field named 'score', etc.
+        #
+        def special(name)
+          special_class_name = "#{Util.camel_case(name.to_s)}Sort"
+          if const_defined?(special_class_name) && special_class_name != 'FieldSort'
+            const_get(special_class_name)
+          end
+        end
+      end
+
+      # 
+      # Base class for sorts. All subclasses should implement the #to_param
+      # method, which is a string that is then concatenated with other sort
+      # strings by the SortComposite to form the sort parameter.
+      #
+      class Abstract
+        def initialize(direction)
+          @direction = (direction || :asc).to_sym
+        end
+
+        private
+
+        # 
+        # Translate fairly forgiving direction argument into solr direction
+        #
+        def direction_for_solr
+          DIRECTIONS[@direction] || 
+            raise(
+              ArgumentError,
+              "Unknown sort direction #{@direction}. Acceptable input is: #{DIRECTIONS.keys.map { |input| input.inspect } * ', '}"
+          )
+        end
+      end
+
+      # 
+      # A FieldSort is the usual kind of sort, by the value of a particular
+      # field, ascending or descending
+      #
+      class FieldSort < Abstract
+        def initialize(field, direction = nil)
+          if field.multiple?
+            raise(ArgumentError, "#{field.name} cannot be used for ordering because it is a multiple-value field")
+          end
+          @field, @direction = field, (direction || :asc).to_sym
+        end
+
+        def to_param
+          "#{@field.indexed_name.to_sym} #{direction_for_solr}"
+        end
+      end
+
+      # 
+      # A RandomSort uses Solr's random field functionality to sort results
+      # (usually) randomly.
+      #
+      class RandomSort < Abstract
+        def to_param
+          "random_#{rand(1<<16)} #{direction_for_solr}"
+        end
+      end
+
+      # 
+      # A ScoreSort sorts by keyword relevance score. This is only useful when
+      # performing fulltext search.
+      #
+      class ScoreSort < Abstract
+        def to_param
+          "score #{direction_for_solr}"
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/sort_composite.rb

@@ -0,0 +1,33 @@
+module Sunspot
+  module Query
+    # 
+    # The SortComposite class encapsulates an ordered collection of Sort
+    # objects. It's necessary to keep this as a separate class as Solr takes
+    # the sort as a single parameter, so adding sorts as regular components
+    # would not merge correctly in the #to_params method.
+    #
+    class SortComposite #:nodoc:
+      def initialize
+        @sorts = []
+      end
+
+      # 
+      # Add a sort to the composite
+      #
+      def <<(sort)
+        @sorts << sort
+      end
+
+      # 
+      # Combine the sorts into a single param by joining them
+      #
+      def to_params
+        unless @sorts.empty?
+          { :sort => @sorts.map { |sort| sort.to_param } * ', ' }
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/standard_query.rb

@@ -0,0 +1,16 @@
+module Sunspot
+  module Query
+    class StandardQuery < CommonQuery
+      attr_accessor :scope, :fulltext
+
+      def initialize(types)
+        super
+        @components << @fulltext = CompositeFulltext.new
+      end
+
+      def add_fulltext(keywords)
+        @fulltext.add(keywords)
+      end
+    end
+  end
+end

data/lib/sunspot/query/text_field_boost.rb

@@ -0,0 +1,17 @@
+module Sunspot
+  module Query
+    class TextFieldBoost #:nodoc:
+      attr_reader :boost
+
+      def initialize(field, boost = nil)
+        @field, @boost = field, boost
+      end
+
+      def to_boosted_field
+        boosted_field = @field.indexed_name
+        boosted_field.concat("^#{@boost}") if @boost
+        boosted_field
+      end
+    end
+  end
+end

data/lib/sunspot/schema.rb

@@ -0,0 +1,151 @@
+require 'erb'
+
+module Sunspot
+  # 
+  # Object that encapsulates schema information for building a Solr schema.xml
+  # file. This class is used by the schema:compile task as well as the
+  # sunspot-configure-solr executable.
+  #
+  class Schema #:nodoc:all
+    FieldType = Struct.new(:name, :class_name, :suffix)
+    FieldVariant = Struct.new(:attribute, :suffix)
+
+    DEFAULT_TOKENIZER = 'solr.StandardTokenizerFactory'
+    DEFAULT_FILTERS = %w(solr.StandardFilterFactory solr.LowerCaseFilterFactory)
+
+    FIELD_TYPES = [
+      FieldType.new('boolean', 'Bool', 'b'),
+      FieldType.new('sfloat', 'SortableFloat', 'f'),
+      FieldType.new('date', 'Date', 'd'),
+      FieldType.new('sint', 'SortableInt', 'i'),
+      FieldType.new('string', 'Str', 's'),
+      FieldType.new('sdouble', 'SortableDouble', 'e'),
+      FieldType.new('slong', 'SortableLong', 'l'),
+      FieldType.new('tint', 'TrieInteger', 'it'),
+      FieldType.new('tfloat', 'TrieFloat', 'ft'),
+      FieldType.new('tdate', 'TrieInt', 'dt')
+
+    ]
+
+    FIELD_VARIANTS = [
+      FieldVariant.new('multiValued', 'm'),
+      FieldVariant.new('stored', 's')
+    ]
+
+    attr_reader :tokenizer, :filters
+
+    def initialize
+      @tokenizer = DEFAULT_TOKENIZER
+      @filters = DEFAULT_FILTERS.dup
+    end
+
+    # 
+    # Attribute field types defined in the schema
+    #
+    def types
+      FIELD_TYPES
+    end
+
+    # 
+    # DynamicField instances representing all the available types and variants
+    #
+    def dynamic_fields
+      fields = []
+      variant_combinations.each do |field_variants|
+        FIELD_TYPES.each do |type|
+          fields << DynamicField.new(type, field_variants)
+        end
+      end
+      fields
+    end
+
+    # 
+    # Which tokenizer to use for text fields
+    #
+    def tokenizer=(tokenizer)
+      @tokenizer = 
+        if tokenizer =~ /\./
+          tokenizer
+        else
+          "solr.#{tokenizer}TokenizerFactory"
+        end
+    end
+
+    # 
+    # Add a filter for text field tokenization
+    #
+    def add_filter(filter)
+      @filters <<
+        if filter =~ /\./
+          filter
+        else
+          "solr.#{filter}FilterFactory"
+        end
+    end
+
+    # 
+    # Return an XML representation of this schema using the ERB template
+    #
+    def to_xml
+      template = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'schema.xml.erb')
+      ERB.new(File.read(template), nil, '-').result(binding)
+    end
+
+    private
+
+    #
+    # All of the possible combinations of variants
+    #
+    def variant_combinations
+      combinations = []
+      0.upto(2 ** FIELD_VARIANTS.length - 1) do |b|
+        combinations << combination = []
+        FIELD_VARIANTS.each_with_index do |variant, i|
+          combination << variant if b & 1<<i > 0
+        end
+      end
+      combinations
+    end
+
+    # 
+    # Represents a dynamic field (in the Solr schema sense, not the Sunspot
+    # sense).
+    #
+    class DynamicField
+      def initialize(type, field_variants)
+        @type, @field_variants = type, field_variants
+      end
+
+      # 
+      # Name of the field in the schema
+      #
+      def name
+        variant_suffixes = @field_variants.map { |variant| variant.suffix }.join
+        "*_#{@type.suffix}#{variant_suffixes}"
+      end
+
+      # 
+      # Name of the type as defined in the schema
+      #
+      def type
+        @type.name
+      end
+
+      # 
+      # Implement magic methods to ask if a field is of a particular variant.
+      # Returns "true" if the field is of that variant and "false" otherwise.
+      #
+      def method_missing(name, *args, &block)
+        if name.to_s =~ /\?$/ && args.empty?
+          if @field_variants.any? { |variant| "#{variant.attribute}?" == name.to_s }
+            'true'
+          else
+            'false'
+          end
+        else
+          super(name.to_sym, *args, &block)
+        end
+      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).each do |file|
+  require File.join(File.dirname(__FILE__), 'search', file)
+end
+
+module Sunspot
+  module Search
+  end
+end

data/lib/sunspot/search/abstract_search.rb

@@ -0,0 +1,335 @@
+require 'sunspot/search/paginated_collection'
+
+module Sunspot
+  module Search #:nodoc:
+
+    #
+    # 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 AbstractSearch
+      #
+      # Retrieve all facet objects defined for this search, in order they were
+      # defined. To retrieve an individual facet by name, use #facet()
+      #
+      attr_reader :facets
+      attr_reader :query #:nodoc:
+      attr_accessor :request_handler
+
+      def initialize(connection, setup, query, configuration) #:nodoc:
+        @connection, @setup, @query = connection, setup, query
+        @query.paginate(1, configuration.pagination.default_per_page)
+        @facets = []
+        @facets_by_name = {}
+      end
+
+      #
+      # Execute the search on the Solr instance and store the results. If you
+      # use Sunspot#search() to construct your searches, there is no need to call
+      # this method as it has already been called. If you use
+      # Sunspot#new_search(), you will need to call this method after building the
+      # query.
+      #
+      def execute
+        reset
+        params = @query.to_params
+        @solr_result = @connection.post "#{request_handler}", :params => params, :headers => { 'Content-Type' => 'application/x-www-form-urlencoded' }
+        self
+      end
+
+      def execute! #:nodoc: deprecated
+        execute
+      end
+
+      #
+      # Get the collection of results as instantiated objects. If WillPaginate is
+      # available, the results will be a WillPaginate::Collection instance; if
+      # not, it will be a vanilla Array.
+      #
+      # If not all of the results referenced by the Solr hits actually exist in
+      # the data store, Sunspot will only return the results that do exist.
+      #
+      # ==== Returns
+      #
+      # WillPaginate::Collection or Array:: Instantiated result objects
+      #
+      def results
+        @results ||= paginate_collection(verified_hits.map { |hit| hit.instance })
+      end
+
+      #
+      # Access raw Solr result information. Returns a collection of Hit objects
+      # that contain the class name, primary key, keyword relevance score (if
+      # applicable), and any stored fields.
+      #
+      # ==== Options (options)
+      #
+      # :verify::
+      #   Only return hits that reference objects that actually exist in the data
+      #   store. This causes results to be eager-loaded from the data store,
+      #   unlike the normal behavior of this method, which only loads the
+      #   referenced results when Hit#result is first called.
+      #
+      # ==== Returns
+      #
+      # Array:: Ordered collection of Hit objects
+      #
+      def hits(options = {})
+        if options[:verify]
+          verified_hits
+        else
+          @hits ||=
+            begin
+              hits = if solr_response && solr_response['docs']
+                solr_response['docs'].map do |doc|
+                  Hit.new(doc, highlights_for(doc), self)
+                end
+              end
+              paginate_collection(hits || [])
+            end
+        end
+      end
+      alias_method :raw_results, :hits
+
+      #
+      # 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
+
+      #
+      # The total number of documents matching the query parameters
+      #
+      # ==== Returns
+      #
+      # Integer:: Total matching documents
+      #
+      def total
+        @total ||= solr_response['numFound'] || 0
+      end
+
+      #
+      # Get the facet object for the given name. `name` can either be the name
+      # given to a query facet, or the field name of a field facet. Returns a
+      # Sunspot::Facet object.
+      #
+      # ==== Parameters
+      #
+      # name<Symbol>::
+      #   Name of the field to return the facet for, or the name given to the
+      #   query facet when the search was constructed.
+      # dynamic_name<Symbol>::
+      #   If faceting on a dynamic field, this is the dynamic portion of the field
+      #   name.
+      #
+      # ==== Example:
+      #
+      #   search = Sunspot.search(Post) do
+      #     facet :category_ids
+      #     dynamic :custom do
+      #       facet :cuisine
+      #     end
+      #     facet :age do
+      #       row 'Less than a month' do
+      #         with(:published_at).greater_than(1.month.ago)
+      #       end
+      #       row 'Less than a year' do
+      #         with(:published_at, 1.year.ago..1.month.ago)
+      #       end
+      #       row 'More than a year' do
+      #         with(:published_at).less_than(1.year.ago)
+      #       end
+      #     end
+      #   end
+      #   search.facet(:category_ids)
+      #     #=> Facet for :category_ids field
+      #   search.facet(:custom, :cuisine)
+      #     #=> Facet for the dynamic field :cuisine in the :custom field definition
+      #   search.facet(:age)
+      #     #=> Facet for the query facet named :age
+      #
+      def facet(name, dynamic_name = nil)
+        if name
+          if dynamic_name
+            @facets_by_name[:"#{name}:#{dynamic_name}"]
+          else
+            @facets_by_name[name.to_sym]
+          end
+        end
+      end
+
+      #
+      # Deprecated in favor of optional second argument to #facet
+      #
+      def dynamic_facet(base_name, dynamic_name) #:nodoc:
+        facet(base_name, dynamic_name)
+      end
+
+      def facet_response #:nodoc:
+        @solr_result['facet_counts']
+      end
+
+      #
+      # Decomposes the Solr "Filter Query" (fq) parameter array further into a hash that can be easily
+      # digested when constructing FieldFacet.rows. Specifically, it is used to add a boolean "selected"
+      # attribute on each row so it's easy to pick out which of the facets returned in a result are part
+      # of the originating query. This is useful for doing something like generating "undo" links, or
+      # showing checkbox initial state as checked.
+      #
+      # Filter query values with keys ending in '_im' and '_s' are processed into their constituent parts.
+      #
+      # solr_response_header['params']['fq'] is an array of strings of the form, for example:
+      # fq: ["type:Package",
+      #      "amenities_ids_im:(9 AND 12)",
+      #      "neighborhood_s:(East\ Village OR Chelsea)",
+      #      "capacity_max_is:[30 TO *]"
+      #     ]
+      #
+      # which is converted to the equivalent hash:
+      # fq_response_header: ["type" => "Package",
+      #                      "amenties_ids_im" => ["9", "12"],
+      #                      "neighborhood_s" => ["East Village", "Chelsea"],
+      #                      "capacity_max_is" => "[30 TO *]"
+      #                     ]
+      #
+      def fq_response_header
+        @fq_response_header ||=
+          begin
+            h = Hash.new
+            solr_response_header['params']['fq'].each do |filter_query|
+              field, value = filter_query.split(':')
+              field = field.gsub(/^\{\!tag=.*?\}/, '') # strip exclude tags
+              value = value.gsub(/^\(|\)$|\\/, '') # strips surrounding parens and \,
+              value = value.split(/ AND | OR /) if facet_split[0] =~ /_im$|_s$/
+              h[field] = value
+            end
+            h
+          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:
+        (@data_accessors ||= {})[clazz.name.to_sym] ||=
+          Adapters::DataAccessor.create(clazz)
+      end
+
+      #
+      # Build this search using a DSL block. This method can be called more than
+      # once on an unexecuted search (e.g., Sunspot.new_search) in order to build
+      # a search incrementally.
+      #
+      # === Example
+      #
+      #   search = Sunspot.new_search(Post)
+      #   search.build do
+      #     with(:published_at).less_than Time.now
+      #   end
+      #   search.execute
+      #
+      def build(&block)
+        Util.instance_eval_or_call(dsl, &block)
+        self
+      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
+
+      def inspect #:nodoc:
+        "<Sunspot::Search:#{query.to_params.inspect}>"
+      end
+
+      def add_field_facet(field, options = {}) #:nodoc:
+        name = (options[:name] || field.name)
+        add_facet(name, FieldFacet.new(field, self, options))
+      end
+
+      def add_query_facet(name, options) #:nodoc:
+        add_facet(name, QueryFacet.new(name, self, options))
+      end
+
+      def add_date_facet(field, options) #:nodoc:
+        name = (options[:name] || field.name)
+        add_facet(name, DateFacet.new(field, self, options))
+      end
+
+      private
+
+      def dsl
+        raise NotImplementedError
+      end
+
+      def execute_request(params)
+        raise NotImplementedError
+      end
+
+      def solr_response
+        @solr_response ||= @solr_result['response'] || {}
+      end
+
+      def solr_response_header
+        @solr_response_header ||= @solr_result['responseHeader'] || {}
+      end
+
+      def highlights_for(doc)
+        if @solr_result['highlighting']
+          @solr_result['highlighting'][doc['id']]
+        end
+      end
+
+      def verified_hits
+        @verified_hits ||= paginate_collection(hits.select { |hit| hit.instance })
+      end
+
+      def paginate_collection(collection)
+        PaginatedCollection.new(collection, @query.page, @query.per_page, total)
+      end
+
+      def add_facet(name, facet)
+        @facets << facet
+        @facets_by_name[name.to_sym] = facet
+      end
+
+      # Clear out all the cached ivars so the search can be called again.
+      def reset
+        @results = @hits = @verified_hits = @total = @solr_response = @doc_ids = @solr_response_header = nil
+      end
+    end
+  end
+end