simplify logic

Author: p

lib/mongoid/fields.rb

@@ -739,17 +739,17 @@ def remove_defaults(name)
 
       def field_for(name, options)
         opts = options.merge(klass: self)
-        opts[:type] = field_type_klass_for(name, options[:type])
+        if type = options[:type]
+          type = Fields::FieldTypes.get(type)
+          unless type
+            raise Mongoid::Errors::InvalidFieldType.new(self.name, field, type)
+          end
+          opts[:type] = type
+        end
         return Fields::Localized.new(name, opts) if options[:localize]
         return Fields::ForeignKey.new(name, opts) if options[:identity]
         Fields::Standard.new(name, opts)
       end
-
-      def field_type_klass_for(field, type)
-        klass = Fields::FieldTypes.get(type)
-        return klass if klass
-        raise Mongoid::Errors::InvalidFieldType.new(self.name, field, type)
-      end
     end
   end
 end

lib/mongoid/fields/field_types.rb

@@ -37,28 +37,45 @@ module FieldTypes
 
       class << self
 
-        # Gets a field class given its mapping identifier.
+        # Resolves the user-provided field type to the field type class.
         #
         # @example
         #   Mongoid::FieldTypes.get(:point)
         #
-        # @param [ Symbol | String | Class | nil ] type the identifier of the defined
-        #   type, or a class to pass-through, or nil.
-        # @return [ Class | nil ] The mapped type class, or nil.
-        def get(type)
-          mapping[type] || handle_unmapped_type(type)
+        # @param [ Class | Symbol | String | Class ] field_type The field
+        #   type class or its string or symbol alias.
+        #
+        # @return [ Class | nil ] The underlying field type class, or nil if
+        #   string or symbol was passed and it is not mapped to any class.
+        def get(field_type)
+          case field_type
+          when Class
+            type
+          when Symbol, String
+            mapping[field_type]
+          else
+            raise Mongoid::Errors::InvalidFieldType.new(self.name, field, field_type)
+          end
         end
 
         # Defines a field type mapping, for later use in field :type option.
         #
         # @example
         #   Mongoid::FieldTypes.define(:point, Point)
         #
-        # @param [ Symbol ] type the symbol identifier of the defined type
+        # @param [ Symbol | String ] field_type_alias the string or symbol
+        #   alias of the defined type. The alias will be accessible as a string
+        #   or a symbol regardless of the type passed to this method.
         # @param [ Class ] klass the class of the defined type, which must
         #   include mongoize, demongoize, and evolve methods.
-        def define(type, klass)
-          mapping[type] = klass
+        def define_alias(field_type_alias, klass)
+          unless field_type_alias.is_a?(String) || field_type_alias.is_a?(Symbol)
+            raise Mongoid::Errors::InvalidFieldTypeAliasName.new(field_type_alias)
+          end
+          unless klass.is_a?(Class)
+            raise Mongoid::Errors::InvalidFieldTypeAliasValue.new(field_type_alias, klass)
+          end
+          mapping[field_type_alias] = klass
         end
 
         delegate :delete, to: :mapping
@@ -69,25 +86,6 @@ def define(type, klass)
         def mapping
           @mapping ||= DEFAULT_ALIASES.dup
         end
-
-        private
-
-        # Handles fallback for case where mapping does not contain the
-        # requested type.
-        #
-        # @param [ Symbol | String | Class | nil ] type the identifier of the defined
-        #   type, or a class, or nil.
-        # @return [ Class | nil ] The class to use as a fallback, or nil.
-        def handle_unmapped_type(type)
-          return Object if type.nil?
-
-          if type.is_a?(Module)
-            return Mongoid::Boolean if type.to_s == 'Boolean'
-            return type
-          end
-
-          nil
-        end
       end
     end
   end