nuatt_sunspot 1.1.0.3

data/lib/sunspot/setup.rb

@@ -0,0 +1,366 @@
+module Sunspot
+  # 
+  # This class encapsulates the search/indexing setup for a given class. Its
+  # contents are built using the Sunspot.setup method.
+  #
+  class Setup #:nodoc:
+    attr_reader :class_object_id
+    def initialize(clazz)
+      @class_object_id = clazz.object_id
+      @class_name = clazz.name
+      @field_factories, @text_field_factories, @dynamic_field_factories,
+        @field_factories_cache, @text_field_factories_cache,
+        @dynamic_field_factories_cache = *Array.new(6) { Hash.new }
+      @stored_field_factories_cache = Hash.new { |h, k| h[k] = [] }
+      @more_like_this_field_factories_cache = Hash.new { |h, k| h[k] = [] }
+      @dsl = DSL::Fields.new(self)
+      add_field_factory(:class, Type::ClassType.instance)
+    end
+
+    def type_names
+      [@class_name]
+    end
+
+    # 
+    # Add field factory for scope/ordering
+    #
+    def add_field_factory(name, type, options = {}, &block)
+      stored, more_like_this = options[:stored], options[:more_like_this]
+      field_factory = FieldFactory::Static.new(name, type, options, &block)
+      @field_factories[field_factory.signature] = field_factory
+      @field_factories_cache[field_factory.name] = field_factory
+      if stored
+        @stored_field_factories_cache[field_factory.name] << field_factory
+      end
+      if more_like_this
+        @more_like_this_field_factories_cache[field_factory.name] << field_factory
+      end
+    end
+
+    # 
+    # Add field_factories for fulltext search
+    #
+    # ==== Parameters
+    #
+    # field_factories<Array>:: Array of Sunspot::Field objects
+    #
+    def add_text_field_factory(name, options = {}, &block)
+      stored, more_like_this = options[:stored], options[:more_like_this]
+      field_factory = FieldFactory::Static.new(name, Type::TextType.instance, options, &block)
+      @text_field_factories[name] = field_factory
+      @text_field_factories_cache[field_factory.name] = field_factory
+      if stored
+        @stored_field_factories_cache[field_factory.name] << field_factory
+      end
+      if more_like_this
+        @more_like_this_field_factories_cache[field_factory.name] << field_factory
+      end
+    end
+
+    #
+    # Add dynamic field_factories
+    #
+    # ==== Parameters
+    # 
+    # field_factories<Array>:: Array of dynamic field objects
+    # 
+    def add_dynamic_field_factory(name, type, options = {}, &block)
+      stored, more_like_this = options[:stored], options[:more_like_this]
+      field_factory = FieldFactory::Dynamic.new(name, type, options, &block)
+      @dynamic_field_factories[field_factory.signature] = field_factory
+      @dynamic_field_factories_cache[field_factory.name] = field_factory
+      if stored
+        @stored_field_factories_cache[field_factory.name] << field_factory
+      end
+      if more_like_this
+        @more_like_this_field_factories_cache[field_factory.name] << field_factory
+      end
+    end
+
+    # 
+    # The coordinates field factory is used for populating the coordinate fields
+    # of documents during index, but does not actually generate fields (since
+    # the field names used in search are static).
+    #
+    def set_coordinates_field(name = nil, &block)
+      @coordinates_field_factory = FieldFactory::Coordinates.new(name, &block)
+    end
+
+    # 
+    # Add a document boost to documents at index time. Document boost can be
+    # static (the same for all documents of this class), or extracted on a per-
+    # document basis using either attribute or block extraction as per usual.
+    #
+    def add_document_boost(attr_name, &block)
+      @document_boost_extractor =
+        if attr_name
+          if attr_name.respond_to?(:to_f)
+            DataExtractor::Constant.new(attr_name)
+          else
+            DataExtractor::AttributeExtractor.new(attr_name)
+          end
+        else
+          DataExtractor::BlockExtractor.new(&block)
+        end
+    end
+
+    # 
+    # Builder method for evaluating the setup DSL
+    #
+    def setup(&block)
+      Util.instance_eval_or_call(@dsl, &block)
+    end
+
+    # 
+    # Return the Field with the given (public-facing) name
+    #
+    def field(field_name)
+      if field_factory = @field_factories_cache[field_name.to_sym]
+        field_factory.build
+      else
+        raise(
+          UnrecognizedFieldError,
+          "No field configured for #{@class_name} with name '#{field_name}'"
+        )
+      end
+    end
+
+    # 
+    # Return one or more text fields with the given public-facing name. This
+    # implementation will always return a single field (in an array), but
+    # CompositeSetup objects might return more than one.
+    #
+    def text_fields(field_name)
+      text_field = 
+        if field_factory = @text_field_factories_cache[field_name.to_sym]
+          field_factory.build
+        else
+          raise(
+            UnrecognizedFieldError,
+            "No text field configured for #{@class_name} with name '#{field_name}'"
+          )
+        end
+      [text_field]
+    end
+
+    #
+    # Return one or more stored fields (can be either attribute or text fields)
+    # for the given name.
+    #
+    def stored_fields(field_name, dynamic_field_name = nil)
+      @stored_field_factories_cache[field_name.to_sym].map do |field_factory|
+        if dynamic_field_name
+          field_factory.build(dynamic_field_name)
+        else
+          field_factory.build
+        end
+      end
+    end
+
+    #
+    # Return one or more more_like_this fields (can be either attribute or text fields)
+    # for the given name.
+    #
+    def more_like_this_fields(field_name)
+      @more_like_this_field_factories_cache[field_name.to_sym].map do |field_factory|
+        field_factory.build
+      end
+    end
+
+    # 
+    # Return the DynamicFieldFactory with the given base name
+    #
+    def dynamic_field_factory(field_name)
+      @dynamic_field_factories_cache[field_name.to_sym] || raise(
+        UnrecognizedFieldError,
+        "No dynamic field configured for #{@class_name} with name '#{field_name}'"
+      )
+    end
+
+    # 
+    # Return all attribute fields
+    #
+    def fields
+      field_factories.map { |field_factory| field_factory.build }
+    end
+
+    # 
+    # Return all text fields
+    #
+    def all_text_fields
+      text_field_factories.map { |text_field_factory| text_field_factory.build }
+    end
+
+    # 
+    # Return all more_like_this fields
+    #
+    def all_more_like_this_fields
+      @more_like_this_field_factories_cache.values.map do |field_factories| 
+        field_factories.map { |field_factory| field_factory.build }
+      end.flatten
+    end
+
+    # 
+    # Get the field_factories associated with this setup as well as all inherited field_factories
+    #
+    # ==== Returns
+    #
+    # Array:: Collection of all field_factories associated with this setup
+    #
+    def field_factories
+      collection_from_inheritable_hash(:field_factories)
+    end
+
+    # 
+    # Get the text field_factories associated with this setup as well as all inherited
+    # text field_factories
+    #
+    # ==== Returns
+    #
+    # Array:: Collection of all text field_factories associated with this setup
+    #
+    def text_field_factories
+      collection_from_inheritable_hash(:text_field_factories)
+    end
+
+    # 
+    # Get all static, dynamic, and text field_factories associated with this setup as
+    # well as all inherited field_factories
+    #
+    # ==== Returns
+    #
+    # Array:: Collection of all text and scope field_factories associated with this setup
+    #
+    def all_field_factories
+      all_field_factories = []
+      all_field_factories.concat(field_factories).concat(text_field_factories).concat(dynamic_field_factories)
+      all_field_factories << @coordinates_field_factory if @coordinates_field_factory
+      all_field_factories
+    end
+
+    # 
+    # Get all dynamic field_factories for this and parent setups
+    # 
+    # ==== Returns
+    #
+    # Array:: Dynamic field_factories
+    #
+    def dynamic_field_factories
+      collection_from_inheritable_hash(:dynamic_field_factories)
+    end
+
+    # 
+    # Return the class associated with this setup.
+    #
+    # ==== Returns
+    #
+    # clazz<Class>:: Class setup is configured for
+    #
+    def clazz
+      Util.full_const_get(@class_name)
+    end
+
+    # 
+    # Get the document boost for a given model
+    #
+    def document_boost_for(model)
+      if @document_boost_extractor
+        @document_boost_extractor.value_for(model)
+      end
+    end
+
+    protected
+
+    # 
+    # Get the nearest inherited setup, if any
+    #
+    # ==== Returns
+    # 
+    # Sunspot::Setup:: Setup for the nearest ancestor of this setup's class
+    #
+    def parent
+      Setup.for(clazz.superclass)
+    end
+
+    def get_inheritable_hash(name)
+      hash = instance_variable_get(:"@#{name}")
+      parent.get_inheritable_hash(name).each_pair do |key, value|
+        hash[key] = value unless hash.has_key?(key)
+      end if parent
+      hash
+    end
+
+    private
+
+    def collection_from_inheritable_hash(name)
+      get_inheritable_hash(name).values
+    end
+
+    class <<self
+      # 
+      # Retrieve or create the Setup instance for the given class, evaluating
+      # the given block to add to the setup's configuration
+      #
+      def setup(clazz, &block) #:nodoc:
+        self.for!(clazz).setup(&block)
+      end
+
+      # 
+      # Retrieve the setup instance for the given class, or for the nearest
+      # ancestor that has a setup, if any.
+      #
+      # ==== Parameters
+      #
+      # clazz<Class>:: Class for which to retrieve a setup
+      #
+      # ==== Returns
+      #
+      # Sunspot::Setup::
+      #   Setup instance associated with the given class or its nearest ancestor
+      #   
+      def for(clazz) #:nodoc:
+        class_name =
+          if clazz.respond_to?(:name)
+            clazz.name
+          else
+            clazz
+          end
+        setups[class_name.to_sym] || self.for(clazz.superclass) if clazz
+      end
+
+      protected
+
+      # 
+      # Retrieve or create a Setup instance for this class
+      #
+      # ==== Parameters
+      #
+      # clazz<Class>:: Class for which to retrieve a setup
+      #
+      # ==== Returns
+      #
+      # Sunspot::Setup:: New or existing setup for this class
+      #
+      def for!(clazz) #:nodoc:
+        setup = setups[clazz.name.to_sym]
+        if setup && setup.class_object_id == clazz.object_id
+          setup
+        else
+          setups[clazz.name.to_sym] = new(clazz)
+        end
+      end
+
+      private
+
+      # Singleton hash of class names to Setup instances
+      #
+      # ==== Returns
+      #
+      # Hash:: Class names keyed to Setup instances
+      #
+      def setups
+        @setups ||= {}
+      end
+    end
+  end
+end

data/lib/sunspot/text_field_setup.rb

@@ -0,0 +1,29 @@
+module Sunspot
+  # 
+  # A TextFieldSetup encapsulates a regular (or composite) setup, and exposes
+  # the #field() method returning text fields instead of attribute fields.
+  #
+  class TextFieldSetup #:nodoc:
+    def initialize(setup)
+      @setup = setup
+    end
+
+    # 
+    # Return a text field with the given name. Duck-type compatible with
+    # Setup and CompositeSetup, but return text fields instead.
+    #
+    def field(name)
+      fields = @setup.text_fields(name)
+      if fields
+        if fields.length == 1
+          fields.first
+        else
+          raise(
+            Sunspot::UnrecognizedFieldError,
+            "The text field with name #{name} has incompatible configurations for the classes #{@setup.type_names.join(', ')}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/type.rb

@@ -0,0 +1,340 @@
+module Sunspot
+  # 
+  # This module contains singleton objects that represent the types that can be
+  # indexed and searched using Sunspot. Plugin developers should be able to
+  # add new constants to the Type module; as long as they implement the
+  # appropriate methods, Sunspot should be able to integrate them (note that
+  # this capability is untested at the moment). The required methods are:
+  #
+  # +indexed_name+::
+  #   Convert a given field name into its form as stored in Solr. This
+  #   generally means adding a suffix to match a Solr dynamicField definition.
+  # +to_indexed+::
+  #   Convert a value of this type into the appropriate Solr string
+  #   representation.
+  # +cast+::
+  #   Convert a Solr string representation of a value into the appropriate
+  #   Ruby type.
+  #
+  module Type
+    class <<self
+      def register(sunspot_type, *classes)
+        classes.each do |clazz|
+          ruby_type_map[clazz.name.to_sym] = sunspot_type.instance
+        end
+      end
+
+      def for_class(clazz)
+        if clazz
+          ruby_type_map[clazz.name.to_sym] || for_class(clazz.superclass)
+        end
+      end
+
+      def for(object)
+        for_class(object.class)
+      end
+
+      def to_indexed(object)
+        if type = self.for(object)
+          type.to_indexed(object)
+        else
+          object.to_s
+        end
+      end
+
+      def to_literal(object)
+        if type = self.for(object)
+          type.to_literal(object)
+        else
+          raise ArgumentError, "Can't use #{object.inspect} as Solr literal: #{object.class} has no registered Solr type"
+        end
+      end
+
+      private
+
+      def ruby_type_map
+        @ruby_type_map ||= {}
+      end
+    end
+
+    class AbstractType #:nodoc:
+      class <<self
+        def instance
+          @instance ||= new
+        end
+        private :new
+      end
+
+      def accepts_dynamic?
+        true
+      end
+
+      def accepts_more_like_this?
+        false
+      end
+
+      def to_literal(object)
+        raise(
+          ArgumentError,
+          "#{self.class.name} cannot be used as a Solr literal"
+        )
+      end
+    end
+
+    # 
+    # Text is a special type that stores data for fulltext search. Unlike other
+    # types, Text fields are tokenized and are made available to the keyword
+    # search phrase. Text fields cannot be faceted, ordered upon, or used in
+    # restrictions. Similarly, text fields are the only fields that are made
+    # available to keyword search.
+    #
+    class TextType < AbstractType
+      def indexed_name(name) #:nodoc:
+        "#{name}_text"
+      end
+
+      def to_indexed(value) #:nodoc:
+        value.to_s if value
+      end
+
+      def cast(text)
+        text
+      end
+
+      def accepts_dynamic?
+        false
+      end
+
+      def accepts_more_like_this?
+        true
+      end
+    end
+
+    # 
+    # The String type represents string data.
+    #
+    class StringType < AbstractType
+      def indexed_name(name) #:nodoc:
+        "#{name}_s"
+      end
+
+      def to_indexed(value) #:nodoc:
+        value.to_s if value
+      end
+
+      def cast(string) #:nodoc:
+        string
+      end
+    end
+    register(StringType, String)
+
+    # 
+    # The Integer type represents integers.
+    #
+    class IntegerType < AbstractType
+      def indexed_name(name) #:nodoc:
+        "#{name}_i"
+      end
+
+      def to_indexed(value) #:nodoc:
+        value.to_i.to_s if value
+      end
+
+      def to_literal(value)
+        to_indexed(value)
+      end
+
+      def cast(string) #:nodoc:
+        string.to_i
+      end
+    end
+    register(IntegerType, Integer)
+
+    # 
+    # The Long type indexes Ruby Fixnum and Bignum numbers into Java Longs
+    #
+    class LongType < IntegerType
+      def indexed_name(name) #:nodoc:
+        "#{name}_l"
+      end
+    end
+
+    # 
+    # The Float type represents floating-point numbers.
+    #
+    class FloatType < AbstractType
+      def indexed_name(name) #:nodoc:
+        "#{name}_f"
+      end
+
+      def to_indexed(value) #:nodoc:
+        value.to_f.to_s if value
+      end
+
+      def to_literal(value)
+        to_indexed(value)
+      end
+
+      def cast(string) #:nodoc:
+        string.to_f
+      end
+    end
+    register(FloatType, Float)
+
+    # 
+    # The Double type indexes Ruby Floats (which are in fact doubles) into Java
+    # Double fields
+    #
+    class DoubleType < FloatType
+      def indexed_name(name)
+        "#{name}_e"
+      end
+    end
+
+    # 
+    # The time type represents times. Note that times are always converted to
+    # UTC before indexing, and facets of Time fields always return times in UTC.
+    #
+    class TimeType < AbstractType
+      XMLSCHEMA = "%Y-%m-%dT%H:%M:%SZ"
+
+      def indexed_name(name) #:nodoc:
+        "#{name}_d"
+      end
+
+      def to_indexed(value) #:nodoc:
+        if value
+          value_to_utc_time(value).strftime(XMLSCHEMA)
+        end
+      end
+
+      def to_literal(value)
+        to_indexed(value)
+      end
+
+      def cast(string) #:nodoc:
+        begin
+          Time.xmlschema(string)
+        rescue ArgumentError
+          DateTime.strptime(string, XMLSCHEMA)
+        end
+      end
+
+      private
+
+      def value_to_utc_time(value)
+        if value.respond_to?(:utc)
+          value.utc
+        elsif value.respond_to?(:new_offset)
+          value.new_offset
+        else
+          begin
+            Time.parse(value.to_s).utc
+          rescue ArgumentError
+            DateTime.parse(value.to_s).new_offset
+          end
+        end
+      end
+    end
+    register TimeType, Time, DateTime
+
+    # 
+    # The DateType encapsulates dates (without time information). Internally,
+    # Solr does not have a date-only type, so this type indexes data using
+    # Solr's DateField type (which is actually date/time), midnight UTC of the
+    # indexed date.
+    #
+    class DateType < TimeType
+      def to_indexed(value) #:nodoc:
+        if value
+          time = 
+            if %w(year mon mday).all? { |method| value.respond_to?(method) }
+              Time.utc(value.year, value.mon, value.mday)
+            else
+              date = Date.parse(value.to_s)
+              Time.utc(date.year, date.mon, date.mday)
+            end
+          super(time)
+        end
+      end
+
+      def cast(string) #:nodoc:
+        time = super
+        Date.civil(time.year, time.mon, time.mday)
+      end
+    end
+    register DateType, Date
+
+    # 
+    # Store integers in a TrieField, which makes range queries much faster.
+    #
+    class TrieIntegerType < IntegerType
+      def indexed_name(name)
+        "#{super}t"
+      end
+    end
+
+    # 
+    # Store floats in a TrieField, which makes range queries much faster.
+    #
+    class TrieFloatType < FloatType
+      def indexed_name(name)
+        "#{super}t"
+      end
+    end
+
+    # 
+    # Index times using a TrieField. Internally, trie times are indexed as
+    # Unix timestamps in a trie integer field, as TrieField does not support
+    # datetime types natively. This distinction should have no effect from the
+    # standpoint of the library's API.
+    #
+    class TrieTimeType < TimeType
+      def indexed_name(name)
+        "#{super}t"
+      end
+    end
+
+
+    # 
+    # The boolean type represents true/false values. Note that +nil+ will not be
+    # indexed at all; only +false+ will be indexed with a false value.
+    #
+    class BooleanType < AbstractType
+      def indexed_name(name) #:nodoc:
+        "#{name}_b"
+      end
+
+      def to_indexed(value) #:nodoc:
+        unless value.nil?
+          value ? 'true' : 'false'
+        end
+      end
+
+      def cast(string) #:nodoc:
+        case string
+        when 'true'
+          true
+        when 'false'
+          false
+        end
+      end
+    end
+    register BooleanType, TrueClass, FalseClass
+
+    class ClassType < AbstractType
+      def indexed_name(name) #:nodoc:
+        'class_name'
+      end
+
+      def to_indexed(value) #:nodoc:
+        value.name
+      end
+
+      def cast(string) #:nodoc:
+        Sunspot::Util.full_const_get(string)
+      end
+    end
+    register ClassType, Class
+  end
+end