kuahyeow-sunspot 0.9.8 → 0.10.3

data/lib/sunspot/field_factory.rb

@@ -122,5 +122,20 @@ module Sunspot
         [@name, @type]
       end
     end
+
+    #XXX Right now this doubles as a Field and a FieldFactory - good idea?
+    class Coordinates
+      def initialize(name)
+        @data_extractor = DataExtractor::AttributeExtractor.new(name)
+      end
+
+      def populate_document(document, model)
+        if coordinates = @data_extractor.value_for(model)
+          coordinates = Util::Coordinates.new(coordinates)
+          document.add_field(:lat, coordinates.lat)
+          document.add_field(:long, coordinates.lng)
+        end
+      end
+    end
   end
 end

data/lib/sunspot/indexer.rb

@@ -49,10 +49,16 @@ module Sunspot
       @connection.delete_by_query("type:#{escape(clazz.name)}")
     end
 
+    # 
+    # Start batch processing
+    #
     def start_batch
       @batch = []
     end
 
+    #
+    # Write batch out to Solr and clear it
+    #
     def flush_batch
       add_documents(@batch)
       @batch = nil

data/lib/sunspot/instantiated_facet.rb

@@ -4,6 +4,9 @@ module Sunspot
   # primary key stored in facet rows' values. The rows are hydrated lazily, but
   # all rows are hydrated the first time #instance is called on any of the rows.
   #
+  # Instatiated facets are possible for fields which are defined with a
+  # :references option.
+  #
   # The #rows method returns InstantiatedFacetRow objects.
   #
   class InstantiatedFacet < Facet
@@ -15,7 +18,7 @@ module Sunspot
     #
     def populate_instances! #:nodoc:
       ids = rows.map { |row| row.value }
-      reference_class = Sunspot::Util.full_const_get(@field.reference.to_s)
+      reference_class = Sunspot::Util.full_const_get(@facet_data.reference.to_s)
       accessor = Adapters::DataAccessor.create(reference_class)
       instance_map = accessor.load_all(ids).inject({}) do |map, instance|
         map[Adapters::InstanceAdapter.adapt(instance).id] = instance
@@ -26,13 +29,11 @@ module Sunspot
       end
     end
 
-    private
-
     # 
-    # Override the Facet#new_row method to return an InstantiateFacetRow
+    # A collection of InstantiatedFacetRow objects
     #
-    def new_row(pair)
-      InstantiatedFacetRow.new(pair, self)
+    def rows
+      @facet_data.rows { |value, count| InstantiatedFacetRow.new(value, count, self) }
     end
   end
 end

data/lib/sunspot/instantiated_facet_row.rb

@@ -1,7 +1,22 @@
 module Sunspot
+  # 
+  # InstantiatedFacetRow objects represent a single value for an instantiated
+  # facet. As well as the usual FacetRow methods, InstantedFacetRow objects
+  # provide access to the persistent object referenced by the row's value.
+  #
   class InstantiatedFacetRow < FacetRow
-    attr_writer :instance
+    attr_writer :instance #:nodoc:
 
+    def initialize(value, count, facet) #:nodoc:
+      super(value, count)
+      @facet = facet
+    end
+
+    #
+    # Get the persistent object referenced by this row's value. Instances are
+    # batch-lazy-loaded, which means that for a given facet, all of the
+    # instances are loaded the first time any row's instance is requested.
+    #
     def instance
       unless defined?(@instance)
         @facet.populate_instances!

data/lib/sunspot/query.rb

@@ -1,190 +1,5 @@
-%w(base_query scope field_query connective dynamic_query field_facet query_facet
-   query_facet_row pagination restriction sort sort_composite).each do |file|
-  require File.join(File.dirname(__FILE__), 'query', file)
-end
-
+%w(connective boost_query dismax field_facet highlighting local pagination restriction query query_facet query_field_facet query_facet_row scope sort sort_composite text_field_boost).each { |file| require(File.join(File.dirname(__FILE__), 'query', file)) }
 module Sunspot
-  module Query #:nodoc:
-    # 
-    # This class encapsulates a query that is to be sent to Solr. The query is
-    # constructed in the block passed to the Sunspot.search method, using the
-    # Sunspot::DSL::Query interface. It can also be accessed directly by calling
-    # #query on a Search object (presumably a not-yet-run one created using
-    # Sunspot#new_search), which might be more suitable than the DSL when an
-    # intermediate object has responsibility for building the query dynamically.
-    #--
-    # Instances of Query, as well as all of the components it contains, respond to
-    # the #to_params method, which returns a hash of parameters in the format
-    # recognized by the solr-ruby API.
-    #
-    class Query < FieldQuery
-      attr_reader :query_facets #:nodoc:
-
-      def initialize(types, setup, configuration) #:nodoc:
-        @setup = setup
-        @components = []
-        @query_facets = {}
-        @components << @base_query = BaseQuery.new(types, setup)
-        @components << @pagination = Pagination.new(configuration)
-        @components << @sort = SortComposite.new
-      end
-
-      # 
-      # Set the keywords for this query. Keywords are parsed with Solr's dismax
-      # handler.
-      #
-      def keywords=(keywords)
-        set_keywords(keywords)
-      end
-
-      # 
-      # Add a component to the query. Used by objects that proxy to the query
-      # object.
-      # 
-      # ==== Parameters
-      # 
-      # component<~to_params>:: Query component to add.
-      # 
-      def add_component(component) #:nodoc:
-        @components << component
-      end
-
-      #
-      # Sets @start and @rows instance variables using pagination semantics
-      #
-      # ==== Parameters
-      #
-      # page<Integer>:: Page on which to start
-      # per_page<Integer>::
-      #   How many rows to display per page. Default taken from
-      #   Sunspot.config.pagination.default_per_page
-      #
-      def paginate(page, per_page = nil)
-        @pagination.page, @pagination.per_page = page, per_page
-      end
-
-      # 
-      # Add random ordering to the search. This can be added after other
-      # field-based sorts if desired.
-      #
-      def order_by_random
-        add_sort(Sort.new(RandomField.new))
-      end
-
-      # 
-      # Representation of this query as solr-ruby parameters. Constructs the hash
-      # by deep-merging scope and facet parameters, adding in various other
-      # parameters from instance data.
-      #
-      # Note that solr-ruby takes the :q parameter as a separate argument; for
-      # the sake of consistency, the Query object ignores this fact (the Search
-      # object extracts it back out).
-      #
-      # ==== Returns
-      #
-      # Hash:: Representation of query in solr-ruby form
-      #
-      def to_params #:nodoc:
-        params = {}
-        query_components = []
-        for component in @components
-          Util.deep_merge!(params, component.to_params)
-        end
-        params
-      end
-
-      # 
-      # Page that this query will return (used by Sunspot::Search to expose
-      # pagination)
-      #
-      # ==== Returns
-      #
-      # Integer:: Page number
-      #
-      def page #:nodoc:
-        @pagination.page
-      end
-
-      #
-      # Number of rows per page that this query will return (used by
-      # Sunspot::Search to expose pagination)
-      #
-      # ==== Returns
-      #
-      # Integer:: Rows per page
-      #
-      def per_page #:nodoc:
-        @pagination.per_page
-      end
-
-      # 
-      # Get the query facet with the given name. Used by the Search object to
-      # match query facet results with the requested query facets.
-      #
-      def query_facet(name) #:nodoc:
-        @query_facets[name.to_sym]
-      end
-
-      # 
-      # Add a Sort object into this query's sort composite.
-      #
-      def add_sort(sort) #:nodoc:
-        @sort << sort
-      end
-
-      # 
-      # Set the keywords for this query, along with keyword options. See
-      # Query::BaseQuery for information on what the options do.
-      #
-      def set_keywords(keywords, options = {}) #:nodoc:
-        @base_query.keywords = keywords
-        @base_query.keyword_options = options
-      end
-
-      # 
-      # Pass in search options as a hash. This is not the preferred way of
-      # building a Sunspot search, but it is made available as experience shows
-      # Ruby developers like to pass in hashes. Probably nice for quick one-offs
-      # on the console, anyway.
-      #
-      # ==== Options (+options+)
-      #
-      # :keywords:: Keyword string for fulltext search
-      # :conditions::
-      #   Hash of key-value pairs, where keys are field names, and values are one
-      #   of scalar, Array, or Range. Scalars are evaluated as EqualTo
-      #   restrictions; Arrays are AnyOf restrictions, and Ranges are Between
-      #   restrictions.
-      # :order::
-      #   Order the search results. Either a string or array of strings of the
-      #   form "field_name direction"
-      # :page::
-      #   Page to use for pagination
-      # :per_page::
-      #   Number of results to show per page
-      #
-      def options=(options) #:nodoc:
-        if options.has_key?(:keywords)
-          self.keywords = options[:keywords]
-        end
-        if options.has_key?(:conditions)
-          options[:conditions].each_pair do |field_name, value|
-            begin
-              add_shorthand_restriction(field_name, value)
-            rescue UnrecognizedFieldError
-              # ignore fields we don't recognize
-            end
-          end
-        end
-        if options.has_key?(:order)
-          for order in Array(options[:order])
-            order_by(*order.split(' '))
-          end
-        end
-        if options.has_key?(:page)
-          paginate(options[:page], options[:per_page])
-        end
-      end
-    end
+  module Query #:nodoc:all
   end
 end

data/lib/sunspot/query/boost_query.rb

@@ -0,0 +1,20 @@
+module Sunspot
+  module Query
+    # 
+    # Representation of a BoostQuery, which allows the searcher to specify a
+    # scope for which matching documents should have an extra boost. This is
+    # essentially a conjunction, with an extra instance variable containing
+    # the boost that should be applied.
+    #
+    class BoostQuery < Connective::Conjunction #:nodoc:
+      def initialize(boost)
+        super(false)
+        @boost = boost
+      end
+
+      def to_boolean_phrase
+        "#{super}^#{@boost}"
+      end
+    end
+  end
+end

data/lib/sunspot/query/connective.rb

@@ -1,55 +1,110 @@
 module Sunspot
   module Query
-    module Connective #:nodoc:
+    module Connective #:nodoc:all
       # 
       # Base class for connectives (conjunctions and disjunctions).
       #
-      class Abstract < Scope
-        def initialize(setup, negated = false) #:nodoc:
-          @setup, @negated = setup, negated
+      class Abstract
+        def initialize(negated = false) #:nodoc:
+          @negated = negated
           @components = []
         end
 
         # 
-        # Connective as solr params.
+        # Add a restriction to the connective.
         #
-        def to_params #:nodoc:
-          { :fq => to_boolean_phrase }
+        def add_restriction(field, restriction_type, value, negated = false)
+          @components << restriction_type.new(field, value, negated)
         end
 
         # 
-        # Express the connective as a Lucene boolean phrase.
+        # Add a shorthand restriction; the restriction type is determined by
+        # the value.
         #
-        def to_boolean_phrase #:nodoc:
-          phrase = if @components.length == 1
-            @components.first.to_boolean_phrase
-          else
-            component_phrases = @components.map do |component|
-              component.to_boolean_phrase
+        def add_shorthand_restriction(field, value, negated = false)
+          restriction_type =
+            case value
+            when Array then Restriction::AnyOf
+            when Range then Restriction::Between
+            else Restriction::EqualTo
             end
-            "(#{component_phrases.join(" #{connector} ")})"
-          end
-          if negated?
-            "-#{phrase}"
-          else
-            phrase
-          end
+          add_restriction(field, restriction_type, value, negated)
+        end
+
+        # 
+        # Add a negated restriction. The added restriction will match all
+        # documents who do not match the terms of the restriction.
+        #
+        def add_negated_restriction(field, restriction_type, value)
+          add_restriction(field, restriction_type, value, true)
+        end
+
+        # 
+        # Add a negated shorthand restriction (see add_shorthand_restriction)
+        #
+        def add_negated_shorthand_restriction(field, value)
+          add_shorthand_restriction(field, value, true)
+        end
+
+        # 
+        # Add a new conjunction and return it.
+        #
+        def add_conjunction
+          add_component(Conjunction.new)
+        end
+
+        # 
+        # Add a new disjunction and return it.
+        #
+        def add_disjunction
+          add_component(Disjunction.new)
         end
 
         # 
-        # Add a component to the connective. All components must implement the
-        # #to_boolean_phrase method.
+        # Add an arbitrary component to the conjunction, and return it.
+        # The component must respond to #to_boolean_phrase
         #
-        def add_component(component) #:nodoc:
+        def add_component(component)
           @components << component
+          component
         end
 
+        # 
+        # Express the connective as a Lucene boolean phrase.
+        #
+        def to_boolean_phrase #:nodoc:
+          unless @components.empty?
+            phrase =
+              if @components.length == 1
+                @components.first.to_boolean_phrase
+              else
+                component_phrases = @components.map do |component|
+                  component.to_boolean_phrase
+                end
+                "(#{component_phrases.join(" #{connector} ")})"
+              end
+            if negated?
+              "-#{phrase}"
+            else
+              phrase
+            end
+          end
+        end
+
+        # 
+        # Connectives can be negated during the process of denormalization that
+        # is performed when a disjunction contains a negated component. This
+        # method conforms to the duck type for all boolean query components.
+        #
         def negated?
           @negated
         end
 
+        # 
+        # Returns a new connective that's a negated version of this one.
+        #
         def negate
-          negated = self.class.new(@setup, !negated?)
+          negated = self.class.new(!negated?)
           for component in @components
             negated.add_component(component)
           end
@@ -67,6 +122,9 @@ module Sunspot
           end
         end
 
+        # 
+        # Express this disjunction as a Lucene boolean phrase
+        #
         def to_boolean_phrase
           if @components.any? { |component| component.negated? }
             denormalize.to_boolean_phrase
@@ -76,16 +134,8 @@ module Sunspot
         end
 
         # 
-        # Add a conjunction to the disjunction. This overrides the method in
-        # the Scope class since scopes are implicitly conjunctive and thus
-        # can return themselves as a conjunction. Inside a disjunction, however,
-        # a conjunction must explicitly be created.
+        # No-op - this is already a disjunction
         #
-        def add_conjunction
-          @components << conjunction = Conjunction.new(setup)
-          conjunction
-        end
-
         def add_disjunction
           self
         end
@@ -96,8 +146,17 @@ module Sunspot
           'OR'
         end
 
+        # 
+        # If a disjunction contains negated components, it must be
+        # "denormalized", because the Lucene parser interprets any negated
+        # boolean phrase using AND semantics (this isn't a bug, it's just a
+        # subtlety of how Lucene parses queries). So, per DeMorgan's law we
+        # create a negated conjunction and add to it all of our components,
+        # negated themselves, which creates a query whose Lucene semantics are
+        # in line with our intentions.
+        #
         def denormalize
-          denormalized = self.class.inverse.new(@setup, !negated?)
+          denormalized = self.class.inverse.new(!negated?)
           for component in @components
             denormalized.add_component(component.negate)
           end
@@ -115,6 +174,10 @@ module Sunspot
           end
         end
 
+        def add_conjunction
+          self
+        end
+
         private
 
         def connector