outoftime-sunspot 0.8.9 → 0.9.0

data/lib/sunspot/field_factory.rb

@@ -0,0 +1,126 @@
+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 RSolr 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 == 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 RSolr document for indexing.
+      #
+      def populate_document(document, model) #:nodoc:
+        unless (value = @data_extractor.value_for(model)).nil?
+          for scalar_value in Array(@field.to_indexed(value))
+            document.add_field(
+              @field.indexed_name.to_sym,
+              scalar_value, @field.attributes
+            )
+          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)
+            for scalar_value in Array(field_instance.to_indexed(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

data/lib/sunspot/indexer.rb

@@ -6,8 +6,10 @@ module Sunspot
   # subclasses).
   #
   class Indexer #:nodoc:
-    def initialize(connection, setup)
-      @connection, @setup = connection, setup
+    include RSolr::Char
+
+    def initialize(connection)
+      @connection = connection
     end
 
     # 
@@ -19,34 +21,62 @@ module Sunspot
     # model<Object>:: the model to index
     #
     def add(model)
-      @connection.add(Array(model).map { |m| prepare(m) })
+      documents = Array(model).map { |m| prepare(m) }
+      if @batch.nil?
+        add_documents(documents)
+      else
+        @batch.concat(documents)
+      end
     end
 
     # 
     # Remove the given model from the Solr index
     #
     def remove(model)
-      @connection.delete(Adapters::InstanceAdapter.adapt(model).index_id)
+      @connection.delete_by_id(Adapters::InstanceAdapter.adapt(model).index_id)
+    end
+
+    def remove_by_id(class_name, id)
+      @connection.delete_by_id(
+        Adapters::InstanceAdapter.index_id_for(class_name, id)
+      )
     end
 
     # 
     # Delete all documents of the class indexed by this indexer from Solr.
     #
-    def remove_all
-      @connection.delete_by_query("type:#{Solr::Util.query_parser_escape(@setup.clazz.name)}")
+    def remove_all(clazz)
+      @connection.delete_by_query("type:#{escape(clazz.name)}")
+    end
+
+    def start_batch
+      @batch = []
+    end
+
+    def flush_batch
+      add_documents(@batch)
+      @batch = nil
     end
 
-    protected
+    private
 
     # 
     # Convert documents into hash of indexed properties
     #
     def prepare(model)
-      hash = static_hash_for(model)
-      for field in @setup.all_fields
-        hash.merge!(field.pairs_for(model))
+      document = document_for(model)
+      setup = setup_for(model)
+      if boost = setup.document_boost_for(model)
+        document.attrs[:boost] = boost
       end
-      hash
+      for field_factory in setup.all_field_factories
+        field_factory.populate_document(document, model)
+      end
+      document
+    end
+
+    def add_documents(documents)
+      @connection.add(documents)
     end
 
     # 
@@ -54,9 +84,26 @@ module Sunspot
     # This method constructs the document hash containing those key-value
     # pairs.
     #
-    def static_hash_for(model)
-      { :id => Adapters::InstanceAdapter.adapt(model).index_id,
-        :type => Util.superclasses_for(model.class).map { |clazz| clazz.name }}
+    def document_for(model)
+      RSolr::Message::Document.new(
+        :id => Adapters::InstanceAdapter.adapt(model).index_id,
+        :type => Util.superclasses_for(model.class).map { |clazz| clazz.name }
+      )
+    end
+
+    # 
+    # Get the Setup object for the given object's class.
+    #
+    # ==== Parameters
+    #
+    # object<Object>:: The object whose setup is to be retrieved
+    #
+    # ==== Returns
+    #
+    # Sunspot::Setup:: The setup for the object's class
+    #
+    def setup_for(object)
+      Setup.for(object.class) || raise(NoSetupError, "Sunspot is not configured for #{object.class.inspect}")
     end
 
 

data/lib/sunspot/instantiated_facet.rb

@@ -0,0 +1,38 @@
+module Sunspot
+  #
+  # InstantiatedFacet instances allow access to a model instance based on a
+  # 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.
+  #
+  # The #rows method returns InstantiatedFacetRow objects.
+  #
+  class InstantiatedFacet < Facet
+    # 
+    # Hydrate all rows for the facet. For data accessors that can efficiently
+    # batch load, this is more efficient than individually lazy-loading
+    # instances for each row, but allows us to still stay lazy and not do work
+    # in the persistent store if the instances are not needed.
+    #
+    def populate_instances! #:nodoc:
+      ids = rows.map { |row| row.value }
+      reference_class = Sunspot::Util.full_const_get(@field.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
+        map
+      end
+      for row in rows
+        row.instance = instance_map[row.value]
+      end
+    end
+
+    private
+
+    # 
+    # Override the Facet#new_row method to return an InstantiateFacetRow
+    #
+    def new_row(pair)
+      InstantiatedFacetRow.new(pair, self)
+    end
+  end
+end

data/lib/sunspot/instantiated_facet_row.rb

@@ -0,0 +1,12 @@
+module Sunspot
+  class InstantiatedFacetRow < FacetRow
+    attr_writer :instance
+
+    def instance
+      unless defined?(@instance)
+        @facet.populate_instances!
+      end
+      @instance
+    end
+  end
+end

data/lib/sunspot/query/base_query.rb

@@ -0,0 +1,90 @@
+module Sunspot
+  module Query
+    #
+    # Encapsulates information common to all queries - in particular, keywords
+    # and types.
+    #
+    class BaseQuery #:nodoc:
+      include RSolr::Char
+
+      attr_writer :keywords
+
+      def initialize(setup)
+        @setup = setup
+      end
+
+      # 
+      # Generate params for the base query. If keywords are specified, build
+      # params for a dismax query, request all stored fields plus the score,
+      # and put the types in a filter query. If keywords are not specified,
+      # put the types query in the q parameter.
+      #
+      def to_params
+        params = {}
+        if @keywords
+          params[:q] = @keywords
+          params[:fl] = '* score'
+          params[:fq] = types_phrase
+          params[:qf] = text_field_names.join(' ')
+          params[:defType] = 'dismax'
+        else
+          params[:q] = types_phrase
+        end
+        params
+      end
+
+      # 
+      # Set keyword options
+      #
+      def keyword_options=(options)
+        if options
+          @text_field_names = options.delete(:fields)
+        end
+      end
+
+      private
+
+      # 
+      # Boolean phrase that restricts results to objects of the type(s) under
+      # query. If this is an open query (no types specified) then it sends a
+      # no-op phrase because Solr requires that the :q parameter not be empty.
+      #
+      # ==== Returns
+      #
+      # String:: Boolean phrase for type restriction
+      #
+      def types_phrase
+        if escaped_types.length == 1 then "type:#{escaped_types.first}"
+        else "type:(#{escaped_types * ' OR '})"
+        end
+      end
+
+      #
+      # Wraps each type in quotes to escape names of the form Namespace::Class
+      #
+      def escaped_types
+        @escaped_types ||=
+          @setup.type_names.map { |name| escape(name)}
+      end
+
+      # 
+      # Returns the names of text fields that should be queried in a keyword
+      # search. If specific fields are requested, use those; otherwise use the
+      # union of all fields configured for the types under search.
+      #
+      def text_field_names
+        text_fields =
+          if @text_field_names
+            Array(@text_field_names).map do |field_name|
+              @setup.text_field(field_name.to_sym)
+            end
+          else
+            @setup.text_fields
+          end
+        text_fields.map do |text_field|
+          text_field.indexed_name
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/connective.rb

@@ -0,0 +1,77 @@
+module Sunspot
+  module Query
+    module Connective #:nodoc:
+      # 
+      # Base class for connectives (conjunctions and disjunctions).
+      #
+      class Abstract < Scope
+        def initialize(setup) #:nodoc:
+          @setup = setup
+          @components = []
+        end
+
+        # 
+        # Connective as solr params.
+        #
+        def to_params #:nodoc:
+          { :fq => to_boolean_phrase }
+        end
+
+        # 
+        # Express the connective as a Lucene boolean phrase.
+        #
+        def to_boolean_phrase #:nodoc:
+          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
+        end
+
+        # 
+        # Add a component to the connective. All components must implement the
+        # #to_boolean_phrase method.
+        #
+        def add_component(component) #:nodoc:
+          @components << component
+        end
+      end
+
+      # 
+      # Disjunctions combine their components with an OR operator.
+      #
+      class Disjunction < Abstract
+        # 
+        # 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.
+        #
+        def add_conjunction
+          @components << conjunction = Conjunction.new(setup)
+          conjunction
+        end
+
+        private
+
+        def connector
+          'OR'
+        end
+      end
+
+      # 
+      # Conjunctions combine their components with an AND operator.
+      #
+      class Conjunction < Abstract
+        private
+
+        def connector
+          'AND'
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/dynamic_query.rb

@@ -1,9 +1,9 @@
 module Sunspot
-  class Query
+  module Query
     #
-    # A dynamic query is a proxy object that implements a subset of the API of
-    # the Query class, but wraps a dynamic field definition and thus applies the
-    # query components using dynamic field instances.
+    # A dynamic query is a proxy object that implements the API of the FieldQuery
+    # class, but wraps a dynamic field factory and thus applies the query
+    # components using dynamic field instances.
     #--
     # Dynamic queries do not hold their own state, but rather proxy to the query
     # that generated them, adding components directly to the owning query's
@@ -12,74 +12,57 @@ module Sunspot
     # DynamicQuery instances are publicly generated by the Query#dynamic_query
     # factory method.
     # 
-    class DynamicQuery
-      def initialize(dynamic_field, query) #:nodoc:
-        @dynamic_field, @query = dynamic_field, query
+    class DynamicQuery < FieldQuery
+      def initialize(dynamic_field_factory, query) #:nodoc:
+        @dynamic_field_factory, @query = dynamic_field_factory, query
       end
-
+      
       # 
-      # Add a restriction based on the dynamic field definition and dynamic name
-      # given.
-      #
-      # ==== Parameters
+      # This has the same effect as calling Query#exclude_instance; it is
+      # included for interface completeness.
       #
-      # dynamic_name<Symbol>::
-      #   Dynamic name to apply to the field in the restriction.
-      # restriction_type<Symbol,Class>::
-      #   Type of restriction to apply (e.g. Sunspot::Query::Restriction::EqualTo), or
-      #   symbol shorthand (e.g. :equal_to)
-      # value::
-      #   Value to apply to the restriction.
-      # negated::
-      #   Whether to negate the restriction (prefer #add_negated_restriction)
-      # 
-      def add_restriction(dynamic_name, restriction_type, value, negated = false)
-        if restriction_type.is_a?(Symbol)
-          restriction_type = Restriction[restriction_type]
-        end
-        @query.add_component(restriction_type.new(@dynamic_field.build(dynamic_name), value, negated))
+      def exclude_instance(instance)
+        @query.exclude_instance(instance)
       end
 
       # 
-      # Add a negated restriction based on the dynamic field definition and
-      # dynamic name given.
-      # 
-      # ==== Parameters
-      # 
-      # dynamic_name<Symbol>::
-      #   Dynamic name to apply to the field in the restriction.
-      # restriction_type<Symbol,Class>::
-      #   Type of restriction to apply (e.g. Sunspot::Query::Restriction::EqualTo), or
-      #   symbol shorthand (e.g. :equal_to)
-      # value::
-      #   Value to apply to the restriction.
-      # 
-      def add_negated_restriction(dynamic_name, restriction_type, value)
-        add_restriction(dynamic_name, restriction_type, value, true)
+      # This has the same effect as calling Query#exclude_instance; it is
+      # included for interface completeness.
+      #
+      def dynamic_query(field_name)
+        @query.dynamic_query(field_name)
       end
 
       # 
-      # Add a field facet based on the dynamic field definition and dynamic name
-      # given.
+      # Add a Sort to the query
       #
-      # ==== Parameters
-      #
-      # dynamic_name<Symbol>:: Dynamic name to facet on
-      # 
-      def add_field_facet(dynamic_name)
-        @query.add_component(FieldFacet.new(@dynamic_field.build(dynamic_name)))
+      def add_sort(sort) #:nodoc:
+        @query.add_sort(sort)
       end
 
       # 
-      # Order by the given dynamic field.
+      # Add a component to the query
       #
-      # ==== Parameters
+      def add_component(component) #:nodoc:
+        @query.add_component(component)
+      end
+
+      private
+      
       #
-      # dynamic_name<Symbol>:: Dynamic name of ordering field
-      # direction<Symbol>:: Direction in which to order (:asc, :desc)
+      # DynamicFieldFactory implements the part of the Setup interface that we
+      # need, so methods in DynamicQuery's superclasses can rely on it without
+      # knowing what it is.
+      #
+      def setup
+        @dynamic_field_factory
+      end
+      
       # 
-      def order_by(dynamic_name, direction)
-        @query.add_component(Sort.new(@dynamic_field.build(dynamic_name), direction))
+      # So query facets can be added to the query from within dynamic queries
+      #
+      def query_facets
+        @query.query_facets
       end
     end
   end