sunspot_rails 2.0.0.pre.120924 → 2.0.0.pre.120925

data/sunspot/lib/sunspot/query/scope.rb

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

data/sunspot/lib/sunspot/query/sort.rb

@@ -1,109 +0,0 @@
-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
-
-      #
-      # A GeodistSort sorts by distance from a given point.
-      #
-      class GeodistSort < FieldSort
-        def initialize(field, lat, lon, direction)
-          @lat, @lon = lat, lon
-          super(field, direction)
-        end
-
-        def to_param
-          "geodist(#{@field.indexed_name.to_sym},#{@lat},#{@lon}) #{direction_for_solr}"
-        end
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/query/sort_composite.rb

@@ -1,34 +0,0 @@
-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(prefix = "")
-        unless @sorts.empty?
-          key = "#{prefix}sort".to_sym
-          { key => @sorts.map { |sort| sort.to_param } * ', ' }
-        else
-          {}
-        end
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/query/standard_query.rb

@@ -1,16 +0,0 @@
-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/sunspot/lib/sunspot/query/text_field_boost.rb

@@ -1,17 +0,0 @@
-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/sunspot/lib/sunspot/schema.rb

@@ -1,151 +0,0 @@
-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/sunspot/lib/sunspot/search.rb

@@ -1,9 +0,0 @@
-%w(abstract_search standard_search more_like_this_search query_facet field_facet
-   date_facet range_facet facet_row hit highlight field_group group hit_enumerable).each do |file|
-  require File.join(File.dirname(__FILE__), 'search', file)
-end
-
-module Sunspot
-  module Search
-  end
-end

data/sunspot/lib/sunspot/search/abstract_search.rb

@@ -1,286 +0,0 @@
-require 'sunspot/search/paginated_collection'
-require 'sunspot/search/hit_enumerable'
-
-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, :groups
-      attr_reader :query #:nodoc:
-      attr_accessor :request_handler
-
-      include HitEnumerable
-  
-      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 = {}
-
-        @groups_by_name = {}
-        @groups = []
-      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}", :data => 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 ||= 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]
-          super
-        else
-          @hits ||= paginate_collection(super)
-        end
-      end
-      alias_method :raw_results, :hits
-
-      # 
-      # The total number of documents matching the query parameters
-      #
-      # ==== Returns
-      #
-      # Integer:: Total matching documents
-      #
-      def total
-        @total ||= solr_response['numFound'] || 0
-      end
-  
-      # 
-      # The time elapsed to generate the Solr response
-      #
-      # ==== Returns
-      #
-      # Integer:: Query runtime in milliseconds
-      #
-      def query_time
-        @query_time ||= solr_response_header['QTime']
-      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
-
-      def group(name)
-        if name
-          @groups_by_name[name.to_sym]
-        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
-
-      def group_response #:nodoc:
-        @solr_result['grouped']
-      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
-  
-  
-      def inspect #:nodoc:
-        "<Sunspot::Search:#{query.to_params.inspect}>"
-      end
-
-      def add_field_group(field) #:nodoc:
-        add_group(field.name, FieldGroup.new(field, self))
-      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
-
-      def add_range_facet(field, options) #:nodoc:
-        name = (options[:name] || field.name)
-        add_facet(name, RangeFacet.new(field, self, options))
-      end
-
-      def highlights_for(doc) #:nodoc:
-        if @solr_result['highlighting']
-          @solr_result['highlighting'][doc['id']]
-        end
-      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 solr_docs
-        solr_response['docs']
-      end
-  
-      def verified_hits
-        @verified_hits ||= paginate_collection(super)
-      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
-
-      def add_group(name, group)
-        @groups << group
-        @groups_by_name[name.to_sym] = group
-      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