benjaminkrause-sunspot 0.9.7

data/lib/sunspot/type.rb

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

data/lib/sunspot/util.rb

@@ -0,0 +1,190 @@
+module Sunspot
+  # 
+  # The Sunspot::Util module provides utility methods used elsewhere in the
+  # library.
+  #
+  module Util #:nodoc:
+    class <<self
+      # 
+      # Get all of the superclasses for a given class, including the class
+      # itself.
+      # 
+      # ==== Parameters
+      #
+      # clazz<Class>:: class for which to get superclasses
+      #
+      # ==== Returns
+      #
+      # Array:: Collection containing class and its superclasses
+      #
+      def superclasses_for(clazz)
+        superclasses = [clazz]
+        superclasses << (clazz = clazz.superclass) while clazz.superclass != Object
+        superclasses
+      end
+
+      # 
+      # Convert a string to snake case
+      #
+      # ==== Parameters
+      #
+      # string<String>:: String to convert to snake case
+      #
+      # ==== Returns
+      #
+      # String:: String in snake case
+      #
+      def snake_case(string)
+        string.scan(/(^|[A-Z])([^A-Z]+)/).map! { |word| word.join.downcase }.join('_')
+      end
+
+      # 
+      # Convert a string to camel case
+      #
+      # ==== Parameters
+      #
+      # string<String>:: String to convert to camel case
+      #
+      # ==== Returns
+      #
+      # String:: String in camel case
+      #
+      def camel_case(string)
+        string.split('_').map! { |word| word.capitalize }.join
+      end
+
+      # 
+      # Get a constant from a fully qualified name
+      #
+      # ==== Parameters
+      #
+      # string<String>:: The fully qualified name of a constant
+      #
+      # ==== Returns
+      #
+      # Object:: Value of constant named
+      #
+      def full_const_get(string)
+        string.split('::').inject(Object) do |context, const_name|
+          context.const_get(const_name)
+        end
+      end
+
+      # 
+      # Evaluate the given proc in the context of the given object if the
+      # block's arity is non-positive, or by passing the given object as an
+      # argument if it is negative.
+      # 
+      # ==== Parameters
+      # 
+      # object<Object>:: Object to pass to the proc
+      #
+      def instance_eval_or_call(object, &block)
+        if block.arity > 0
+          block.call(object)
+        else
+          object.instance_eval(&block)
+        end
+      end
+
+      # 
+      # Perform a deep merge of hashes, returning the result as a new hash.
+      # See #deep_merge_into for rules used to merge the hashes
+      #
+      # ==== Parameters
+      #
+      # left<Hash>:: Hash to merge
+      # right<Hash>:: The other hash to merge
+      #
+      # ==== Returns
+      #
+      # Hash:: New hash containing the given hashes deep-merged.
+      #
+      def deep_merge(left, right)
+        deep_merge_into({}, left, right)
+      end
+
+      # 
+      # Perform a deep merge of the right hash into the left hash
+      #
+      # ==== Parameters
+      #
+      # left:: Hash to receive merge
+      # right:: Hash to merge into left
+      #
+      # ==== Returns
+      #
+      # Hash:: left
+      #
+      def deep_merge!(left, right)
+        deep_merge_into(left, left, right)
+      end
+
+      private
+
+      # 
+      # Deep merge two hashes into a third hash, using rules that produce nice
+      # merged parameter hashes. The rules are as follows, for a given key:
+      #
+      # * If only one hash has a value, or if both hashes have the same value,
+      #   just use the value.
+      # * If either of the values is not a hash, create arrays out of both
+      #   values and concatenate them.
+      # * Otherwise, deep merge the two values (which are both hashes)
+      #
+      # ==== Parameters
+      #
+      # destination<Hash>:: Hash into which to perform the merge
+      # left<Hash>:: One hash to merge
+      # right<Hash>:: The other hash to merge
+      #
+      # ==== Returns
+      #
+      # Hash:: destination
+      #
+      def deep_merge_into(destination, left, right)
+        left.each_pair do |name, left_value|
+          right_value = right[name]
+          destination[name] =
+            if right_value.nil? || left_value == right_value
+              left_value
+            elsif !left_value.respond_to?(:each_pair) || !right_value.respond_to?(:each_pair)
+              Array(left_value) + Array(right_value)
+            else
+              merged_value = {}
+              deep_merge_into(merged_value, left_value, right_value)
+            end
+        end
+        left_keys = Set.new(left.keys)
+        destination.merge!(right.reject { |k, v| left_keys.include?(k) })
+        destination
+      end
+    end
+
+    class Coordinates #:nodoc:
+      def initialize(coords)
+        @coords = coords
+      end
+
+      def lat
+        if @coords.respond_to?(:[])
+          @coords[0]
+        else
+          @coords.lat
+        end.to_f
+      end
+
+      def lng
+        if @coords.respond_to?(:[])
+          @coords[1]
+        elsif @coords.respond_to?(:lng)
+          @coords.lng
+        elsif @coords.respond_to?(:lon)
+          @coords.lon
+        elsif @coords.respond_to?(:long)
+          @coords.long
+        end.to_f
+      end
+    end
+  end
+end