kuahyeow-sunspot 0.9.7

data/lib/sunspot/indexer.rb

@@ -0,0 +1,123 @@
+module Sunspot
+  # 
+  # This class presents a service for adding, updating, and removing data
+  # from the Solr index. An Indexer instance is associated with a particular
+  # setup, and thus is capable of indexing instances of a certain class (and its
+  # subclasses).
+  #
+  class Indexer #:nodoc:
+    include RSolr::Char
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    # 
+    # Construct a representation of the model for indexing and send it to the
+    # connection for indexing
+    #
+    # ==== Parameters
+    #
+    # model<Object>:: the model to index
+    #
+    def add(model)
+      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_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(clazz)
+      @connection.delete_by_query("type:#{escape(clazz.name)}")
+    end
+
+    def start_batch
+      @batch = []
+    end
+
+    def flush_batch
+      add_documents(@batch)
+      @batch = nil
+    end
+
+    private
+
+    # 
+    # Convert documents into hash of indexed properties
+    #
+    def prepare(model)
+      document = document_for(model)
+      setup = setup_for(model)
+      if boost = setup.document_boost_for(model)
+        document.attrs[:boost] = boost
+      end
+      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
+
+    # 
+    # All indexed documents index and store the +id+ and +type+ fields.
+    # This method constructs the document hash containing those key-value
+    # pairs.
+    #
+    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
+
+
+    class <<self
+      # 
+      # Delete all documents from the Solr index
+      #
+      # ==== Parameters
+      #
+      # connection<Solr::Connection>::
+      #   connection to which to send the delete request
+      def remove_all(connection)
+        connection.delete_by_query("type:[* TO *]")
+      end
+    end
+  end
+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,94 @@
+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(types, setup)
+        @types, @setup = types, 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
+          if @keywords.match(/\*\Z/)
+            params['q.alt'] = @keywords
+            params.delete(:q)
+          end          
+          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 ||=
+          @types.map { |type| escape(type.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,126 @@
+module Sunspot
+  module Query
+    module Connective #:nodoc:
+      # 
+      # Base class for connectives (conjunctions and disjunctions).
+      #
+      class Abstract < Scope
+        def initialize(setup, negated = false) #:nodoc:
+          @setup, @negated = setup, negated
+          @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:
+          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
+
+        # 
+        # Add a component to the connective. All components must implement the
+        # #to_boolean_phrase method.
+        #
+        def add_component(component) #:nodoc:
+          @components << component
+        end
+
+        def negated?
+          @negated
+        end
+
+        def negate
+          negated = self.class.new(@setup, !negated?)
+          for component in @components
+            negated.add_component(component)
+          end
+          negated
+        end
+      end
+
+      # 
+      # Disjunctions combine their components with an OR operator.
+      #
+      class Disjunction < Abstract
+        class <<self
+          def inverse
+            Conjunction
+          end
+        end
+
+        def to_boolean_phrase
+          if @components.any? { |component| component.negated? }
+            denormalize.to_boolean_phrase
+          else
+            super
+          end
+        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.
+        #
+        def add_conjunction
+          @components << conjunction = Conjunction.new(setup)
+          conjunction
+        end
+
+        def add_disjunction
+          self
+        end
+
+        private
+
+        def connector
+          'OR'
+        end
+
+        def denormalize
+          denormalized = self.class.inverse.new(@setup, !negated?)
+          for component in @components
+            denormalized.add_component(component.negate)
+          end
+          denormalized
+        end
+      end
+
+      # 
+      # Conjunctions combine their components with an AND operator.
+      #
+      class Conjunction < Abstract
+        class <<self
+          def inverse
+            Disjunction
+          end
+        end
+
+        private
+
+        def connector
+          'AND'
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/dynamic_query.rb

@@ -0,0 +1,69 @@
+module Sunspot
+  module Query
+    #
+    # 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
+    # internal state.
+    #++
+    # DynamicQuery instances are publicly generated by the Query#dynamic_query
+    # factory method.
+    # 
+    class DynamicQuery < FieldQuery
+      def initialize(dynamic_field_factory, query) #:nodoc:
+        @dynamic_field_factory, @query = dynamic_field_factory, query
+      end
+      
+      # 
+      # This has the same effect as calling Query#exclude_instance; it is
+      # included for interface completeness.
+      #
+      def exclude_instance(instance)
+        @query.exclude_instance(instance)
+      end
+
+      # 
+      # 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 Sort to the query
+      #
+      def add_sort(sort) #:nodoc:
+        @query.add_sort(sort)
+      end
+
+      # 
+      # Add a component to the query
+      #
+      def add_component(component) #:nodoc:
+        @query.add_component(component)
+      end
+
+      private
+      
+      #
+      # 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
+      
+      # 
+      # So query facets can be added to the query from within dynamic queries
+      #
+      def query_facets
+        @query.query_facets
+      end
+    end
+  end
+end

data/lib/sunspot/query/field_facet.rb

@@ -0,0 +1,149 @@
+require 'set'
+
+module Sunspot
+  module Query
+    #
+    # Encapsulates a query component representing a field facet. Users create
+    # instances using DSL::Query#facet
+    #
+    class FieldFacet #:nodoc:
+      class <<self
+        protected :new
+
+        # 
+        # Return the appropriate FieldFacet instance for the field and options.
+        # If a :time_range option is specified, and the field type is TimeType,
+        # build a DateFieldFacet. Otherwise, build a normal FieldFacet.
+        #
+        # ==== Returns
+        #
+        # FieldFacet:: FieldFacet instance of appropriate class.
+        #
+        def build(field, options)
+          if options.has_key?(:time_range)
+            unless field.type == Type::TimeType
+              raise(
+                ArgumentError,
+                ":time_range key can only be specified for time fields"
+              )
+            end
+            DateFieldFacet.new(field, options)
+          else
+            FieldFacet.new(field, options)
+          end
+        end
+      end
+
+      def initialize(field, options)
+        @field, @options = field, options
+      end
+
+      # ==== Returns
+      #
+      # Hash:: solr-ruby params for this field facet
+      #
+      def to_params
+        params = { :"facet.field" => [@field.indexed_name], :facet => 'true' }
+        params[param_key(:sort)] = 
+          case @options[:sort]
+          when :count then 'true'
+          when :index then 'false'
+          when nil
+          else raise(ArgumentError, 'Allowed facet sort options are :count and :index')
+          end
+        params[param_key(:limit)] = @options[:limit]
+        params[param_key(:mincount)] =
+          if @options[:minimum_count] then @options[:minimum_count]
+          elsif @options[:zeros] then 0
+          else 1
+          end
+        params
+      end
+
+      private
+
+      # 
+      # Given a facet parameter name, return the appropriate Solr parameter for
+      # this facet.
+      #
+      # ==== Returns
+      #
+      # Symbol:: Solr query parameter key
+      #
+      def param_key(name)
+        :"f.#{@field.indexed_name}.facet.#{name}"
+      end
+    end
+
+    class DateFieldFacet < FieldFacet #:nodoc:
+      ALLOWED_OTHER = Set.new(%w(before after between none all))
+
+      # 
+      # Convert the facet to date params.
+      #
+      def to_params
+        super.merge(
+          :"facet.date" => [@field.indexed_name],
+          param_key('date.start') => start_time.utc.xmlschema,
+          param_key('date.end') => end_time.utc.xmlschema,
+          param_key('date.gap') => "+#{interval}SECONDS",
+          param_key('date.other') => others
+        )
+      end
+
+      private
+
+      # 
+      # Start time for facet range
+      #
+      # ==== Returns
+      #
+      # Time:: Start time
+      #
+      def start_time
+        @options[:time_range].first
+      end
+
+      # 
+      # End time for facet range
+      #
+      # ==== Returns
+      #
+      # Time:: End time
+      #
+      def end_time
+        @options[:time_range].last
+      end
+
+      # 
+      # Time interval that each facet row should cover. Default is 1 day.
+      #
+      # ===== Returns
+      #
+      # Integer:: Time interval in seconds
+      #
+      def interval
+        @options[:time_interval] || 86400
+      end
+
+      # 
+      # Other time ranges to create facet rows for. Allowed values are defined
+      # in ALLOWED_OTHER constant.
+      #
+      def others
+        if others = @options[:time_other]
+          Array(others).map do |other|
+            other = other.to_s
+            unless ALLOWED_OTHER.include?(other)
+              raise(
+                ArgumentError,
+                "#{other.inspect} is not a valid argument for :time_other"
+              )
+            end
+            other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/field_query.rb

@@ -0,0 +1,57 @@
+module Sunspot
+  module Query
+    # 
+    # This class acts as a base class for query components that encapsulate
+    # operations on fields. It is subclassed by the Query::Query class and the
+    # Query::DynamicQuery class.
+    #
+    class FieldQuery < Scope
+      # 
+      # Add a field facet. See Sunspot::Facet for more information.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: Name of the field on which to get a facet
+      #
+      # ==== Returns
+      #
+      # FieldFacet:: The field facet object
+      #
+      def add_field_facet(field_name, options = nil)
+        add_component(FieldFacet.build(build_field(field_name), options || {}))
+      end
+
+      # 
+      # Add a query facet.
+      #
+      # ==== Parameters
+      #
+      # name<Symbol>::
+      #   The name associated with the query facet. This is not passed to Solr,
+      #   but allows the user to retrieve the facet result by passing the name
+      #   to the Search#facet method.
+      #
+      # ==== Returns
+      #
+      # QueryFacet:: The query facet object
+      #
+      def add_query_facet(name)
+        add_component(facet = QueryFacet.new(name, setup))
+        query_facets[name.to_sym] = facet
+        facet
+      end
+
+      # 
+      # Set result ordering.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: Name of the field on which to order
+      # direction<Symbol>:: :asc or :desc (default :asc)
+      #
+      def order_by(field_name, direction = nil)
+        add_sort(Sort.new(build_field(field_name), direction))
+      end
+    end
+  end
+end

data/lib/sunspot/query/pagination.rb

@@ -0,0 +1,39 @@
+module Sunspot
+  module Query
+    # 
+    # A query component that holds information about pagination. Unlike other
+    # query components, this one is mutable, because the query itself holds a
+    # reference to it and updates it if pagination is changed.
+    #
+    class Pagination #:nodoc:
+      attr_reader :page, :per_page
+
+      def initialize(configuration, page = nil, per_page = nil)
+        @configuration = configuration
+        self.page, self.per_page = page, per_page
+      end
+
+      def to_params
+        { :start => start, :rows => rows }
+      end
+
+      def page=(page)
+        @page = page || 1
+      end
+
+      def per_page=(per_page)
+        @per_page = per_page || @configuration.pagination.default_per_page
+      end
+
+      private
+
+      def start
+        (@page - 1) * @per_page
+      end
+
+      def rows
+        @per_page
+      end
+    end
+  end
+end