nxa-sunspot 0.10.7

data/lib/sunspot/setup.rb

@@ -0,0 +1,323 @@
+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:
+    def initialize(clazz)
+      @clazz = clazz
+      @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] = [] }
+      @dsl = DSL::Fields.new(self)
+      add_field_factory(:class, Type::ClassType)
+    end
+
+    def type_names
+      [@class_name]
+    end
+
+    # 
+    # Add field factory for scope/ordering
+    #
+    def add_field_factory(name, type, options = {}, &block)
+      stored = options[:stored]
+      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
+    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 = options[:stored]
+      field_factory = FieldFactory::Static.new(name, Type::TextType, 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
+    end
+
+    #
+    # Add dynamic field_factories
+    #
+    # ==== Parameters
+    # 
+    # field_factories<Array>:: Array of dynamic field objects
+    # 
+    def add_dynamic_field_factory(name, type, options = {}, &block)
+      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
+    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)
+      @dsl.instance_eval(&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 #{@clazz.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 #{@clazz.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)
+      @stored_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 #{@clazz.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
+
+    # 
+    # 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:
+        setups[clazz.name.to_sym] ||= new(clazz)
+      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,204 @@
+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
+    # 
+    # 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.
+    #
+    module TextType
+      class <<self
+        def indexed_name(name) #:nodoc:
+        "#{name}_text"
+        end
+
+        def to_indexed(value) #:nodoc:
+          value.to_s if value
+        end
+
+        def cast(text)
+          text
+        end
+      end
+    end
+
+    # 
+    # The String type represents string data.
+    #
+    module StringType
+      class <<self
+        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
+    end
+
+    # 
+    # The Integer type represents integers.
+    #
+    module IntegerType
+      class <<self
+        def indexed_name(name) #:nodoc:
+        "#{name}_i"
+        end
+
+        def to_indexed(value) #:nodoc:
+          value.to_i.to_s if value
+        end
+
+        def cast(string) #:nodoc:
+          string.to_i
+        end
+      end
+    end
+
+    # 
+    # The Float type represents floating-point numbers.
+    #
+    module FloatType
+      class <<self
+        def indexed_name(name) #:nodoc:
+        "#{name}_f"
+        end
+
+        def to_indexed(value) #:nodoc:
+          value.to_f.to_s if value
+        end
+
+        def cast(string) #:nodoc:
+          string.to_f
+        end
+      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.
+    #
+    module TimeType
+
+      class <<self
+        def indexed_name(name) #:nodoc:
+        "#{name}_d"
+        end
+
+        def to_indexed(value) #:nodoc:
+          if value
+            time =
+              if value.respond_to?(:utc)
+                value
+              else
+                Time.parse(value.to_s)
+              end
+            time.utc.xmlschema
+          end
+        end
+
+        def cast(string) #:nodoc:
+          Time.xmlschema(string)
+        end
+      end
+    end
+
+    # 
+    # 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.
+    #
+    module DateType
+      class <<self
+        def indexed_name(name) #:nodoc:
+          "#{name}_d"
+        end
+
+        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
+            time.utc.xmlschema
+          end
+        end
+
+        def cast(string) #:nodoc:
+          time = Time.xmlschema(string)
+          Date.civil(time.year, time.mon, time.mday)
+        end
+      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.
+    #
+    module BooleanType
+      class <<self
+        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
+    end
+
+    module ClassType
+      class <<self
+        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
+    end
+  end
+end