ruben-sunspot 1.1.0

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,302 @@
+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.request("/#{request_handler}", params)
+        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 ||= maybe_will_paginate(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), distance_for(doc), self)
+                end
+              end
+              maybe_will_paginate(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
+  
+      # 
+      # 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 highlights_for(doc)
+        if @solr_result['highlighting']
+          @solr_result['highlighting'][doc['id']]
+        end
+      end
+  
+      def distance_for(doc)
+        if @solr_result['distances']
+          @solr_result['distances'][doc['id']]
+        end
+      end
+  
+      def verified_hits
+        @verified_hits ||= maybe_will_paginate(hits.select { |hit| hit.instance })
+      end
+  
+      def maybe_will_paginate(collection)
+        if defined?(WillPaginate::Collection)
+          WillPaginate::Collection.create(@query.page, @query.per_page, total) do |pager|
+            pager.replace(collection)
+          end
+        else
+          collection
+        end
+      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 = nil
+      end
+    end
+  end
+end