sunspot_solr 2.0.0.pre.120924 → 2.0.0.pre.120925

data/sunspot/lib/sunspot/dsl/search.rb

@@ -1,30 +0,0 @@
-module Sunspot
-  module DSL
-    # 
-    # This top-level DSL class is the context in which the block passed to
-    # Sunspot.query. See Sunspot::DSL::StandardQuery, Sunspot::DSL::FieldQuery,
-    # and Sunspot::DSL::Scope for the full API presented.
-    #
-    class Search < StandardQuery
-      def initialize(search, setup) #:nodoc:
-        @search = search
-        super(search, search.query, setup)
-      end
-
-      # 
-      # Retrieve the data accessor used to load instances of the given class
-      # out of persistent storage. Data accessors are free to implement any
-      # extra methods that may be useful in this context.
-      #
-      # ==== Example
-      #
-      #   Sunspot.search Post do
-      #     data_acccessor_for(Post).includes = [:blog, :comments]
-      #   end
-      #
-      def data_accessor_for(clazz)
-        @search.data_accessor_for(clazz)
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/dsl/standard_query.rb

@@ -1,122 +0,0 @@
-module Sunspot
-  module DSL #:nodoc:
-    #
-    # This class presents a DSL for constructing queries using the
-    # Sunspot.search method. Methods of this class are available inside the
-    # search block. Much of the DSL's functionality is implemented by this
-    # class's superclasses, Sunspot::DSL::FieldQuery and Sunspot::DSL::Scope
-    #
-    # See Sunspot.search for usage examples
-    #
-    class StandardQuery < FieldQuery
-      include Paginatable, Adjustable
-
-      # Specify a phrase that should be searched as fulltext. Only +text+
-      # fields are searched - see DSL::Fields.text
-      #
-      # Keyword search is executed using Solr's dismax handler, which strikes
-      # a good balance between powerful and foolproof. In particular,
-      # well-matched quotation marks can be used to group phrases, and the
-      # + and - modifiers work as expected. All other special Solr boolean
-      # syntax is escaped, and mismatched quotes are ignored entirely.
-      #
-      # This method can optionally take a block, which is evaluated by the
-      # Fulltext DSL class, and exposes several powerful dismax features.
-      #
-      # ==== Parameters
-      #
-      # keywords<String>:: phrase to perform fulltext search on
-      #
-      # ==== Options
-      #
-      # :fields<Array>::
-      #   List of fields that should be searched for keywords. Defaults to all
-      #   fields configured for the types under search.
-      # :highlight<Boolean,Array>::
-      #   If true, perform keyword highlighting on all searched fields. If an
-      #   array of field names, perform highlighting on the specified fields.
-      #   Note that for highlighting to work, the desired fields have to be set
-      #   up with :stored => true.
-      #   This can also be called from within the fulltext block.
-      # :minimum_match<Integer>::
-      #   The minimum number of search terms that a result must match. By
-      #   default, all search terms must match; if the number of search terms
-      #   is less than this number, the default behavior applies.
-      # :tie<Float>::
-      #   A tiebreaker coefficient for scores derived from subqueries that are
-      #   lower-scoring than the maximum score subquery. Typically a near-zero
-      #   value is useful. See
-      #   http://wiki.apache.org/solr/DisMaxRequestHandler#tie_.28Tie_breaker.29
-      #   for more information.
-      # :query_phrase_slop<Integer>::
-      #   The number of words that can appear between the words in a
-      #   user-entered phrase (i.e., keywords in quotes) and still match. For
-      #   instance, in a search for "\"great pizza\"" with a phrase slop of 1,
-      #   "great pizza" and "great big pizza" will match, but "great monster of
-      #   a pizza" will not. Default behavior is a query phrase slop of zero.
-      #
-      def fulltext(keywords, options = {}, &block)
-        if keywords && !(keywords.to_s =~ /^\s*$/)
-          fulltext_query = @query.add_fulltext(keywords)
-          if field_names = options.delete(:fields)
-            Util.Array(field_names).each do |field_name|
-              @setup.text_fields(field_name).each do |field|
-                fulltext_query.add_fulltext_field(field, field.default_boost)
-              end
-            end
-          end
-          if minimum_match = options.delete(:minimum_match)
-            fulltext_query.minimum_match = minimum_match.to_i
-          end
-          if tie = options.delete(:tie)
-            fulltext_query.tie = tie.to_f
-          end
-          if query_phrase_slop = options.delete(:query_phrase_slop)
-            fulltext_query.query_phrase_slop = query_phrase_slop.to_i
-          end
-          if highlight_field_names = options.delete(:highlight)
-            if highlight_field_names == true
-              fulltext_query.add_highlight
-            else
-              highlight_fields = []
-              Util.Array(highlight_field_names).each do |field_name|
-                highlight_fields.concat(@setup.text_fields(field_name))
-              end
-              fulltext_query.add_highlight(highlight_fields)
-            end
-          end
-          if block && fulltext_query
-            fulltext_dsl = Fulltext.new(fulltext_query, @setup)
-            Util.instance_eval_or_call(
-              fulltext_dsl,
-              &block
-            )
-          end
-          if !field_names && (!fulltext_dsl || !fulltext_dsl.fields_added?)
-            @setup.all_text_fields.each do |field|
-              unless fulltext_query.has_fulltext_field?(field)
-                unless fulltext_dsl && fulltext_dsl.exclude_fields.include?(field.name)
-                  fulltext_query.add_fulltext_field(field, field.default_boost)
-                end
-              end
-            end
-          end
-        end
-      end
-      alias_method :keywords, :fulltext
-
-      def with(*args)
-        case args.first
-        when String, Symbol
-          if args.length == 1 # NONE
-            field = @setup.field(args[0].to_sym)
-            return DSL::RestrictionWithNear.new(field, @scope, @query, false)
-          end
-        end
-
-        # else
-        super
-      end
-    end
-  end
-end

data/sunspot/lib/sunspot/field.rb

@@ -1,193 +0,0 @@
-module Sunspot
-  class Field #:nodoc:
-    attr_accessor :name # The public-facing name of the field
-    attr_accessor :type # The Type of the field
-    attr_accessor :reference # Model class that the value of this field refers to
-    attr_reader :boost
-    attr_reader :indexed_name # Name with which this field is indexed internally. Based on public name and type or the +:as+ option.
-
-    #
-    #
-    def initialize(name, type, options = {}) #:nodoc
-      @name, @type = name.to_sym, type
-      @stored = !!options.delete(:stored)
-      @more_like_this = !!options.delete(:more_like_this)
-      set_indexed_name(options)
-      raise ArgumentError, "Field of type #{type} cannot be used for more_like_this" unless type.accepts_more_like_this? or !@more_like_this
-    end
-
-    # Convert a value to its representation for Solr indexing. This delegates
-    # to the #to_indexed method on the field's type.
-    #
-    # ==== Parameters
-    #
-    # value<Object>:: Value to convert to Solr representation
-    #
-    # ==== Returns
-    #
-    # String:: Solr representation of the object
-    #
-    # ==== Raises
-    #
-    # ArgumentError::
-    #   the value is an array, but this field does not allow multiple values
-    #
-    def to_indexed(value)
-      if value.is_a? Array
-        if @multiple
-          value.map { |val| to_indexed(val) }
-        else
-          raise ArgumentError, "#{name} is not a multiple-value field, so it cannot index values #{value.inspect}"
-        end
-      else
-        @type.to_indexed(value)
-      end
-    end
-
-    # Cast the value into the appropriate Ruby class for the field's type
-    #
-    # ==== Parameters
-    #
-    # value<String>:: Solr's representation of the value
-    #
-    # ==== Returns
-    #
-    # Object:: The cast value
-    #
-    def cast(value)
-      @type.cast(value)
-    end
-
-    #
-    # Whether this field accepts multiple values.
-    #
-    # ==== Returns
-    #
-    # Boolean:: True if this field accepts multiple values.
-    #
-    def multiple?
-      !!@multiple
-    end
-
-    #
-    # Whether this field can be used for more_like_this queries.
-    # If true, the field is configured to store termVectors.
-    #
-    # ==== Returns
-    #
-    # Boolean:: True if this field can be used for more_like_this queries.
-    #
-    def more_like_this?
-      !!@more_like_this
-    end
-
-    def hash
-      indexed_name.hash
-    end
-
-    def eql?(field)
-      indexed_name == field.indexed_name
-    end
-    alias_method :==, :eql?
-
-    private
-
-    #
-    # Determine the indexed name. If the :as option is given use that, otherwise
-    # create the value based on the indexed_name of the type with additional
-    # suffixes for multiple, stored, and more_like_this.
-    #
-    # ==== Returns
-    #
-    # String: The field's indexed name
-    #
-    def set_indexed_name(options)
-      @indexed_name =
-        if options[:as]
-          options.delete(:as).to_s
-        else
-          "#{@type.indexed_name(@name).to_s}#{'m' if @multiple }#{'s' if @stored}#{'v' if more_like_this?}"
-        end
-    end
-
-  end
-
-  #
-  # FulltextField instances represent fields that are indexed as fulltext.
-  # These fields are tokenized in the index, and can have boost applied to
-  # them. They also always allow multiple values (since the only downside of
-  # allowing multiple values is that it prevents the field from being sortable,
-  # and sorting on tokenized fields is nonsensical anyway, there is no reason
-  # to do otherwise). FulltextField instances always have the type TextType.
-  #
-  class FulltextField < Field #:nodoc:
-    attr_reader :default_boost
-
-    def initialize(name, options = {})
-      super(name, Type::TextType.instance, options)
-      @multiple = true
-      @boost = options.delete(:boost)
-      @default_boost = options.delete(:default_boost)
-      raise ArgumentError, "Unknown field option #{options.keys.first.inspect} provided for field #{name.inspect}" unless options.empty?
-    end
-
-    def indexed_name
-      "#{super}"
-    end
-  end
-
-  #
-  # AttributeField instances encapsulate non-tokenized attribute data.
-  # AttributeFields can have any type except TextType, and can also have
-  # a reference (for instantiated facets), optionally allow multiple values
-  # (false by default), and can store their values (false by default). All
-  # scoping, sorting, and faceting is done with attribute fields.
-  #
-  class AttributeField < Field #:nodoc:
-    def initialize(name, type, options = {})
-      @multiple = !!options.delete(:multiple)
-      super(name, type, options)
-      @reference =
-        if (reference = options.delete(:references)).respond_to?(:name)
-          reference.name
-        elsif reference.respond_to?(:to_sym)
-          reference.to_sym
-        end
-      raise ArgumentError, "Unknown field option #{options.keys.first.inspect} provided for field #{name.inspect}" unless options.empty?
-    end
-
-  end
-
-  class TypeField #:nodoc:
-    class <<self
-      def instance
-        @instance ||= new
-      end
-    end
-
-    def indexed_name
-      'type'
-    end
-
-    def to_indexed(clazz)
-      clazz.name
-    end
-  end
-
-  class IdField #:nodoc:
-    class <<self
-      def instance
-        @instance ||= new
-      end
-    end
-
-    def indexed_name
-      'id'
-    end
-
-    def to_indexed(id)
-      id.to_s
-    end
-  end
-end
-

data/sunspot/lib/sunspot/field_factory.rb

@@ -1,129 +0,0 @@
-module Sunspot
-  # 
-  # The FieldFactory module contains classes for generating fields. FieldFactory
-  # implementation classes should implement a #build method, although the arity
-  # of the method depends on the type of factory. They also must implement a
-  # #populate_document method, which extracts field data from a given model and
-  # adds it into the Solr document for indexing.
-  #
-  module FieldFactory #:nodoc:all
-    # 
-    # Base class for field factories.
-    #
-    class Abstract
-      attr_reader :name
-
-      def initialize(name, options = {}, &block)
-        @name = name.to_sym
-        @data_extractor =
-          if block
-            DataExtractor::BlockExtractor.new(&block)
-          else
-            DataExtractor::AttributeExtractor.new(options.delete(:using) || name)
-          end
-      end
-    end
-
-    # 
-    # A StaticFieldFactory generates normal static fields. Each factory instance
-    # contains an eager-initialized field instance, which is returned by the
-    # #build method.
-    #
-    class Static < Abstract
-      def initialize(name, type, options = {}, &block)
-        super(name, options, &block)
-        unless name.to_s =~ /^\w+$/
-          raise ArgumentError, "Invalid field name #{name}: only letters, numbers, and underscores are allowed."
-        end
-        @field =
-          if type.is_a?(Type::TextType)
-            FulltextField.new(name, options)
-          else
-            AttributeField.new(name, type, options)
-          end
-      end
-
-      # 
-      # Return the field instance built by this factory
-      #
-      def build
-        @field
-      end
-
-      # 
-      # Extract the encapsulated field's data from the given model and add it
-      # into the Solr document for indexing.
-      #
-      def populate_document(document, model) #:nodoc:
-        unless (value = @data_extractor.value_for(model)).nil?
-          Util.Array(@field.to_indexed(value)).each do |scalar_value|
-            options = {}
-            options[:boost] = @field.boost if @field.boost
-            document.add_field(
-              @field.indexed_name.to_sym,
-              scalar_value,
-              options
-            )
-          end
-        end
-      end
-
-      # 
-      # A unique signature identifying this field by name and type.
-      #
-      def signature
-        [@field.name, @field.type]
-      end
-    end
-
-    # 
-    # DynamicFieldFactories create dynamic field instances based on dynamic
-    # configuration.
-    #
-    class Dynamic < Abstract
-      attr_accessor :name, :type
-
-      def initialize(name, type, options = {}, &block)
-        super(name, options, &block)
-        @type, @options = type, options
-      end
-
-      #
-      # Build a field based on the dynamic name given.
-      #
-      def build(dynamic_name)
-        AttributeField.new("#{@name}:#{dynamic_name}", @type, @options.dup)
-      end
-      # 
-      # This alias allows a DynamicFieldFactory to be used in place of a Setup
-      # or CompositeSetup instance by query components.
-      #
-      alias_method :field, :build
-
-      # 
-      # Generate dynamic fields based on hash returned by data accessor and
-      # add the field data to the document.
-      #
-      def populate_document(document, model)
-        if values = @data_extractor.value_for(model)
-          values.each_pair do |dynamic_name, value|
-            field_instance = build(dynamic_name)
-            Util.Array(field_instance.to_indexed(value)).each do |scalar_value|
-              document.add_field(
-                field_instance.indexed_name.to_sym,
-                scalar_value
-              )
-            end
-          end
-        end
-      end
-
-      # 
-      # Unique signature identifying this dynamic field based on name and type
-      #
-      def signature
-        [@name, @type]
-      end
-    end
-  end
-end