sunspot_rails 2.0.0.pre.120720 → 2.0.0.pre.120924

data/sunspot/lib/sunspot/type.rb

@@ -0,0 +1,393 @@
+require 'singleton'
+begin
+  require 'geohash'
+rescue LoadError => e
+  require 'pr_geohash'
+end
+
+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:
+      include Singleton
+
+      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
+        when true, false
+          string
+        end
+      end
+    end
+    register BooleanType, TrueClass, FalseClass
+
+    # 
+    # The Location type encodes geographical coordinates as a GeoHash.
+    # The data for this type must respond to the `lat` and `lng` methods; you
+    # can use Sunspot::Util::Coordinates as a wrapper if your source data does
+    # not follow this API.
+    #
+    # Location fields are most usefully searched using the
+    # Sunspot::DSL::RestrictionWithType#near method; see that method for more
+    # information on geographical search.
+    #
+    # ==== Example
+    #
+    #   Sunspot.setup(Post) do
+    #     location :coordinates do
+    #       Sunspot::Util::Coordinates.new(coordinates[0], coordinates[1])
+    #     end
+    #   end
+    #
+    class LocationType < AbstractType
+      def indexed_name(name)
+        "#{name}_s"
+      end
+
+      def to_indexed(value)
+        GeoHash.encode(value.lat.to_f, value.lng.to_f, 12)
+      end
+    end
+
+    # 
+    # The Latlon type encodes geographical coordinates in the native
+    # Solr LatLonType.
+    #
+    # The data for this type must respond to the `lat` and `lng` methods; you
+    # can use Sunspot::Util::Coordinates as a wrapper if your source data does
+    # not follow this API.
+    #
+    # Location fields can be used with the geospatial DSL. See the
+    # Geospatial section of the README for examples.
+    #
+    class LatlonType < AbstractType
+      def indexed_name(name)
+        "#{name}_ll"
+      end
+
+      def to_indexed(value)
+        "#{value.lat.to_f},#{value.lng.to_f}"
+      end
+    end
+
+    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

data/sunspot/lib/sunspot/util.rb

@@ -0,0 +1,252 @@
+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_defined?(const_name) ? context.const_get(const_name) : context.const_missing(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
+          ContextBoundDelegate.instance_eval_with_context(object, &block)
+        end
+      end
+
+      def extract_options_from(args)
+        if args.last.is_a?(Hash)
+          args.pop
+        else
+          {}
+        end
+      end
+
+      #
+      # Ruby's treatment of Strings as Enumerables is heavily annoying. As far
+      # as I know the behavior of Kernel.Array() is otherwise fine.
+      #
+      def Array(object)
+        case object
+        when String, Hash
+          [object]
+        else
+          super
+        end
+      end
+
+      # 
+      # When generating boosts, Solr requires that the values be in standard
+      # (not scientific) notation. We would like to ensure a minimum number of
+      # significant digits (i.e., digits that are not prefix zeros) for small
+      # float values.
+      #
+      def format_float(f, digits)
+        if f < 1
+          sprintf('%.*f', digits - Math.log10(f), f)
+        else
+          f.to_s
+        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] if right
+          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
+
+    Coordinates = Struct.new(:lat, :lng)
+
+    class ContextBoundDelegate
+      class <<self
+        def instance_eval_with_context(receiver, &block)
+          calling_context = eval('self', block.binding)
+          if parent_calling_context = calling_context.instance_eval{@__calling_context__}
+            calling_context = parent_calling_context
+          end
+          new(receiver, calling_context).instance_eval(&block)
+        end
+        private :new
+      end
+
+      BASIC_METHODS = Set[:==, :equal?, :"!", :"!=", :instance_eval,
+                          :object_id, :__send__, :__id__]
+
+      instance_methods.each do |method|
+        unless BASIC_METHODS.include?(method.to_sym)
+          undef_method(method)
+        end
+      end
+
+      def initialize(receiver, calling_context)
+        @__receiver__, @__calling_context__ = receiver, calling_context
+      end
+
+      def id
+        @__calling_context__.__send__(:id)
+      end
+
+      # Special case due to `Kernel#sub`'s existence
+      def sub(*args, &block)
+        __proxy_method__(:sub, *args, &block)
+      end
+
+      def method_missing(method, *args, &block)
+        __proxy_method__(method, *args, &block)
+      end
+
+      def __proxy_method__(method, *args, &block)
+        begin
+          @__receiver__.__send__(method.to_sym, *args, &block)
+        rescue ::NoMethodError => e
+          begin
+            @__calling_context__.__send__(method.to_sym, *args, &block)
+          rescue ::NoMethodError
+            raise(e)
+          end
+        end
+      end
+    end
+  end
+end