benjaminkrause-sunspot 0.9.7

data/lib/sunspot/facet_data.rb

@@ -0,0 +1,152 @@
+require 'enumerator'
+
+module Sunspot
+  # 
+  # The FacetData classes encapsulate various sources of facet data (field
+  # facet, # date facet, query facet), presenting a polymorphic API to the Facet
+  # class.
+  #
+  module FacetData #:nodoc:all
+    # 
+    # Base class for facet data.
+    #
+    class Abstract
+      attr_reader :field #:nodoc:
+
+      def reference
+        @field.reference if @field
+      end
+
+      def cast(value)
+        if @field
+          @field.cast(value)
+        else
+          value
+        end
+      end
+
+      def row_value(value)
+        cast(value)
+      end
+    end
+
+    # 
+    # FieldFacetData encapsulates the data returned by field facets
+    #
+    class FieldFacetData < Abstract
+      def initialize(facet_values, field)
+        @facet_values, @field = facet_values, field
+      end
+
+      # The name of the field that contains this facet's values
+      #
+      # ==== Returns
+      #
+      # Symbol:: The field name
+      # 
+      def name
+        @field.name
+      end
+
+      # The rows returned for this facet.
+      #
+      # ==== Returns
+      #
+      # Array:: Collection of FacetRow objects, in the order returned by Solr
+      # 
+      def rows
+        @rows ||=
+          begin
+            rows = []
+            @facet_values.each_slice(2) do |value, count|
+              rows << yield(row_value(value), count)
+            end
+            rows
+          end
+      end
+    end
+
+    class DateFacetData < FieldFacetData
+      def initialize(facet_values, field)
+        @gap = facet_values.delete('gap')[/\+(\d+)SECONDS/,1].to_i
+        %w(start end).each { |key| facet_values.delete(key) }
+        super(facet_values.to_a.flatten, field)
+      end
+
+      #
+      # Get the rows of this date facet, which are instances of DateFacetRow.
+      # The rows will always be sorted in chronological order.
+      #
+      #--
+      #
+      # The date facet info comes back from Solr as a hash, so we need to sort
+      # it manually. FIXME this currently assumes we want to do a "lexical"
+      # sort, but we should support count sort as well, even if it's not a
+      # common use case.
+      #
+      def rows(&block)
+        super(&block).sort { |a, b| a.value.first <=> b.value.first }
+      end
+
+      private
+
+      def row_value(value)
+        cast(value)..(cast(value) + @gap)
+      end
+    end
+
+    # 
+    # QueryFacetData encapsulates the data returned by a query facet.
+    #
+    class QueryFacetData < Abstract
+      def initialize(outgoing_query_facet, row_data) #:nodoc:
+        @outgoing_query_facet, @row_data = outgoing_query_facet, row_data
+        @field = @outgoing_query_facet.field
+      end
+
+      def name
+        outgoing_query_facet.name
+      end
+
+      # 
+      # Get the rows associated with this query facet. Returned rows are always
+      # ordered by count.
+      #
+      # ==== Returns
+      #
+      # Array:: Collection of QueryFacetRow objects, ordered by count
+      #
+      def rows
+        @rows ||=
+          begin
+            rows = []
+            options = @outgoing_query_facet.options
+            minimum_count =
+              if options[:zeros] then 0
+              elsif options[:minimum_count] then options[:minimum_count]
+              else 1
+              end
+            for outgoing_row in  @outgoing_query_facet.rows
+              row_query = outgoing_row.to_boolean_phrase
+              if @row_data.has_key?(row_query)
+                row = yield(outgoing_row.label, @row_data[row_query])
+                rows << row if row.count >= minimum_count
+              end
+            end
+            if options[:sort] == :index || !options[:limit] && options[:sort] != :count
+              if rows.all? { |row| row.value.respond_to?(:<=>) }
+                rows.sort! { |x, y| x.value <=> y.value }
+              end
+            else
+              rows.sort! { |x, y| y.count <=> x.count }
+            end
+            if limit = options[:limit]
+              rows[0, limit]
+            else
+              rows
+            end
+          end
+      end
+    end
+  end
+end

data/lib/sunspot/facet_row.rb

@@ -0,0 +1,12 @@
+module Sunspot
+  #
+  # This class encapsulates a facet row (value) for a facet.
+  #
+  class FacetRow
+    attr_reader :value, :count
+
+    def initialize(value, count) #:nodoc:
+      @value, @count = value, count
+    end
+  end
+end

data/lib/sunspot/field.rb

@@ -0,0 +1,148 @@
+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 :attributes
+
+    # 
+    #
+    def initialize(name, type, options = {}) #:nodoc
+      @name, @type = name.to_sym, type
+      @stored = !!options.delete(:stored)
+      @attributes = {}
+    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
+
+    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 :boost
+
+    def initialize(name, options = {})
+      super(name, Type::TextType, options)
+      @multiple = true
+      if boost = options.delete(:boost)
+        @attributes[:boost] = boost
+      end
+      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}"
+    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}"
+    end
+  end
+end

data/lib/sunspot/field_factory.rb

@@ -0,0 +1,141 @@
+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
+
+    #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

@@ -0,0 +1,129 @@
+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
+
+    # 
+    # Start batch processing
+    #
+    def start_batch
+      @batch = []
+    end
+
+    #
+    # Write batch out to Solr and clear it
+    #
+    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,45 @@
+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(@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
+        map
+      end
+      for row in rows
+        row.instance = instance_map[row.value]
+      end
+    end
+
+    # 
+    # A collection of InstantiatedFacetRow objects
+    #
+    def rows
+      @facet_data.rows { |value, count| InstantiatedFacetRow.new(value, count, self) }
+    end
+
+    private
+
+    # 
+    # Override the Facet#new_row method to return an InstantiatedFacetRow
+    #
+    def new_row(pair)
+      InstantiatedFacetRow.new(pair, self)
+    end
+  end
+end

data/lib/sunspot/instantiated_facet_row.rb

@@ -0,0 +1,27 @@
+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 #: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!
+      end
+      @instance
+    end
+  end
+end

data/lib/sunspot/query/base_query.rb

@@ -0,0 +1,55 @@
+module Sunspot
+  module Query
+    #
+    # Encapsulates information common to all queries - in particular, types.
+    # Subclassed by FulltextBaseQuery, which puts the types in a filter query
+    # and sets up dismax search.
+    #
+    class BaseQuery #:nodoc:
+      include RSolr::Char
+
+      attr_reader :types
+      attr_writer :keywords
+      attr_writer :phrase_fields
+
+      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
+        { :q => types_phrase }
+      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
+    end
+  end
+end