ruben-sunspot 1.1.0

data/lib/sunspot/dsl/scope.rb

@@ -0,0 +1,229 @@
+module Sunspot
+  module DSL #:nodoc:
+    # 
+    # This DSL presents methods for constructing restrictions and other query
+    # elements that are specific to fields. As well as being a superclass of
+    # Sunspot::DSL::Query, which presents the main query block, this DSL class
+    # is also used directly inside the #dynamic() block, which only allows
+    # operations on specific fields.
+    #
+    class Scope
+      NONE = Object.new
+
+      def initialize(scope, setup) #:nodoc:
+        @scope, @setup = scope, setup
+      end
+
+      # 
+      # Build a positive restriction. With one argument, this method returns
+      # another DSL object which presents methods for attaching various
+      # restriction types. With two arguments, this creates a shorthand
+      # restriction: if the second argument is a scalar, an equality restriction
+      # is created; if it is a Range, a between restriction will be created; and
+      # if it is an Array, an any_of restriction will be created.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: Name of the field on which to place the restriction
+      # value<Object,Range,Array>::
+      #   If passed, creates an equality, range, or any-of restriction based on
+      #   the type of value passed.
+      #
+      # ==== Returns
+      #
+      # Sunspot::DSL::Query::Restriction::
+      #   Restriction DSL object (if only one argument is passed)
+      #
+      # ==== Examples
+      #
+      # An equality restriction:
+      #
+      #   Sunspot.search do
+      #     with(:blog_id, 1)
+      #   end
+      #
+      # Restrict by range:
+      #
+      #   Sunspot.search do
+      #     with(:average_rating, 3.0..5.0)
+      #   end
+      #
+      # Restrict by a set of allowed values:
+      #
+      #   Sunspot.search do
+      #     with(:category_ids, [1, 5, 9])
+      #   end
+      # 
+      # Other restriction types:
+      #
+      #   Sunspot.search(Post) do
+      #     with(:average_rating).greater_than(3.0)
+      #   end
+      #
+      def with(field_name, value = NONE)
+        if value == NONE
+          DSL::Restriction.new(@setup.field(field_name.to_sym), @scope, false)
+        else
+          @scope.add_shorthand_restriction(@setup.field(field_name), value)
+        end
+      end
+
+      # 
+      # Build a negative restriction (exclusion). This method can take three
+      # forms: equality exclusion, exclusion by another restriction, or identity
+      # exclusion. The first two forms work the same way as the #with method;
+      # the third excludes a specific instance from the search results.
+      #
+      # ==== Parameters (exclusion by field value)
+      #
+      # field_name<Symbol>:: Name of the field on which to place the exclusion
+      # value<Symbol>::
+      #   If passed, creates an equality exclusion with this value
+      #
+      # ==== Parameters (exclusion by identity)
+      #
+      # args<Object>...::
+      #   One or more instances that should be excluded from the results
+      #
+      # ==== Examples
+      #
+      # An equality exclusion:
+      #
+      #   Sunspot.search(Post) do
+      #     without(:blog_id, 1)
+      #   end
+      # 
+      # Other restriction types:
+      #
+      #   Sunspot.search(Post) do
+      #     without(:average_rating).greater_than(3.0)
+      #   end
+      #
+      # Exclusion by identity:
+      #
+      #   Sunspot.search(Post) do
+      #     without(some_post_instance)
+      #   end
+      #
+      def without(*args)
+        case args.first
+        when String, Symbol
+          field_name = args[0]
+          value = args.length > 1 ? args[1] : NONE
+          if value == NONE
+            DSL::Restriction.new(@setup.field(field_name.to_sym), @scope, true)
+          else
+            @scope.add_negated_shorthand_restriction(@setup.field(field_name.to_sym), value)
+          end
+        else
+          instances = args
+          instances.flatten.each do |instance|
+            @scope.add_negated_restriction(
+              IdField.instance,
+              Sunspot::Query::Restriction::EqualTo,
+              Sunspot::Adapters::InstanceAdapter.adapt(instance).index_id
+            )
+          end
+        end
+      end
+
+      # 
+      # Create a disjunction, scoping the results to documents that match any
+      # of the enclosed restrictions.
+      #
+      # ==== Example
+      #
+      #   Sunspot.search(Post) do
+      #     any_of do
+      #       with(:expired_at).greater_than Time.now
+      #       with :expired_at, nil
+      #     end
+      #   end
+      #
+      # This will return all documents who either have an expiration time in the
+      # future, or who do not have any expiration time at all.
+      #
+      def any_of(&block)
+        disjunction = @scope.add_disjunction
+        Util.instance_eval_or_call(Scope.new(disjunction, @setup), &block)
+        disjunction
+      end
+
+      # 
+      # Create a conjunction, scoping the results to documents that match all of
+      # the enclosed restrictions. When called from the top level of a search
+      # block, this has no effect, but can be useful for grouping a conjunction
+      # inside a disjunction.
+      #
+      # ==== Example
+      #
+      #   Sunspot.search(Post) do
+      #     any_of do
+      #       with(:blog_id, 1)
+      #       all_of do
+      #         with(:blog_id, 2)
+      #         with(:category_ids, 3)
+      #       end
+      #     end
+      #   end
+      #
+      def all_of(&block)
+        conjunction = @scope.add_conjunction
+        Util.instance_eval_or_call(Scope.new(conjunction, @setup), &block)
+        conjunction
+      end
+
+      #
+      # Apply restrictions, facets, and ordering to dynamic field instances.
+      # The block API is implemented by Sunspot::DSL::FieldQuery, which is a
+      # superclass of the Query DSL (thus providing a subset of the API, in
+      # particular only methods that refer to particular fields).
+      # 
+      # ==== Parameters
+      # 
+      # base_name<Symbol>:: The base name for the dynamic field definition
+      #
+      # ==== Example
+      #
+      #   Sunspot.search Post do
+      #     dynamic :custom do
+      #       with :cuisine, 'Pizza'
+      #       facet :atmosphere
+      #       order_by :chef_name
+      #     end
+      #   end
+      #
+      def dynamic(base_name, &block)
+        Sunspot::Util.instance_eval_or_call(
+          Scope.new(@scope, @setup.dynamic_field_factory(base_name)),
+          &block
+        )
+      end
+
+      # 
+      # Apply scope-type restrictions on fulltext fields. In certain situations,
+      # it may be desirable to place logical restrictions on text fields.
+      # Remember that text fields are tokenized; your mileage may very.
+      #
+      # The block works exactly like a normal scope, except that the field names
+      # refer to text fields instead of attribute fields.
+      # 
+      # === Example
+      #
+      #   Sunspot.search(Post) do
+      #     text_fields do
+      #       with :body, nil
+      #     end
+      #   end
+      #
+      # This will return all documents that do not have a body.
+      #
+      def text_fields(&block)
+        Sunspot::Util.instance_eval_or_call(
+          Scope.new(@scope, TextFieldSetup.new(@setup)),
+          &block
+        )
+      end
+    end
+  end
+end

data/lib/sunspot/dsl/search.rb

@@ -0,0 +1,30 @@
+module Sunspot
+  module DSL
+    # 
+    # This top-level DSL class is the context in which the block passed to
+    # Sunspot.query. See Sunspot::DSL::Query, 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/lib/sunspot/dsl/standard_query.rb

@@ -0,0 +1,125 @@
+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.
+      #   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
+
+      #
+      # Scope the search by geographical distance from a given point.
+      # +coordinates+ should either respond to #first and #last (e.g. a
+      # two-element array), or to #lat and one of #lng, #lon, or #long.
+      # +options+ should be one or both of the following:
+      #
+      # :distance:: The maximum distance in miles from which results can come
+      # :sort::
+      #   Whether to sort by distance from these coordinates. If other sorts are
+      #   specified, they take precedence over distance sort.
+      #
+      def near(coordinates, options)
+        if options.respond_to?(:to_f)
+          options = { :distance => options }
+        end
+        @query.add_location_restriction(coordinates, options)
+      end
+    end
+  end
+end

data/lib/sunspot/field.rb

@@ -0,0 +1,192 @@
+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
+
+    # 
+    #
+    def initialize(name, type, options = {}) #:nodoc
+      @name, @type = name.to_sym, type
+      @stored = !!options.delete(:stored)
+      @more_like_this = !!options.delete(:more_like_this)
+      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
+
+    # 
+    # Name with which this field is indexed internally. Based on public name and
+    # type.
+    #
+    # ==== Returns
+    #
+    # String:: Internal name of the field
+    #
+    def indexed_name
+      @type.indexed_name(@name)
+    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?
+  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}#{'s' if @stored}#{'v' if more_like_this?}"
+    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 = {})
+      super(name, type, options)
+      @multiple = !!options.delete(:multiple)
+      @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
+
+    # The name of the field as it is indexed in Solr. The indexed name
+    # contains a suffix that contains information about the type as well as
+    # whether the field allows multiple values for a document.
+    #
+    # ==== Returns
+    #
+    # String:: The field's indexed name
+    #
+    def indexed_name
+      "#{super}#{'m' if @multiple}#{'s' if @stored}#{'v' if more_like_this?}"
+    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