formtastic 2.1.0 → 4.0.0

data/lib/formtastic/form_builder.rb

@@ -1,9 +1,18 @@
 module Formtastic
   class FormBuilder < ActionView::Helpers::FormBuilder
 
-    def self.configure(name, value = nil)
+    # Defines a new configurable option
+    # @param [Symbol] name the configuration name
+    # @param [Object] default the configuration default value
+    # @private
+    #
+    # @!macro [new] configure
+    #   @!scope class
+    #   @!attribute [rw] $1
+    #   @api public
+    def self.configure(name, default = nil)
       class_attribute(name)
-      self.send(:"#{name}=", value)
+      self.send(:"#{name}=", default)
     end
 
     configure :custom_namespace
@@ -12,13 +21,12 @@ module Formtastic
     configure :default_text_area_width
     configure :all_fields_required_by_default, true
     configure :include_blank_for_select_by_default, true
-    configure :required_string, proc { Formtastic::Util.html_safe(%{<abbr title="#{Formtastic::I18n.t(:required)}">*</abbr>}) }
+    configure :required_string, proc { %{<abbr title="#{Formtastic::I18n.t(:required)}">*</abbr>}.html_safe }
     configure :optional_string, ''
     configure :inline_errors, :sentence
     configure :label_str_method, :humanize
     configure :collection_label_methods, %w[to_label display_name full_name name title username login value to_s]
     configure :collection_value_methods, %w[id to_s]
-    configure :custom_inline_order, {}
     configure :file_methods, [ :file?, :public_filename, :filename ]
     configure :file_metadata_suffixes, ['content_type', 'file_name', 'file_size']
     configure :priority_countries, ["Australia", "Canada", "United Kingdom", "United States"]
@@ -32,6 +40,15 @@ module Formtastic
     configure :default_hint_class, 'inline-hints'
     configure :use_required_attribute, false
     configure :perform_browser_validations, false
+    # Check {Formtastic::InputClassFinder} to see how are inputs resolved.
+    configure :input_namespaces, [::Object, ::Formtastic::Inputs]
+    configure :input_class_finder, Formtastic::InputClassFinder
+    # Check {Formtastic::ActionClassFinder} to see how are inputs resolved.
+    configure :action_namespaces, [::Object, ::Formtastic::Actions]
+    configure :action_class_finder, Formtastic::ActionClassFinder
+
+    configure :skipped_columns, [:created_at, :updated_at, :created_on, :updated_on, :lock_version, :version]
+    configure :priority_time_zones, []
 
     attr_reader :template
 
@@ -41,15 +58,14 @@ module Formtastic
 
     include Formtastic::Helpers::InputHelper
     include Formtastic::Helpers::InputsHelper
-    include Formtastic::Helpers::ButtonsHelper
     include Formtastic::Helpers::ActionHelper
     include Formtastic::Helpers::ActionsHelper
     include Formtastic::Helpers::ErrorsHelper
-    
-    # This is a wrapper around Rails' `ActionView::Helpers::FormBuilder#fields_for`, originally 
+
+    # This is a wrapper around Rails' `ActionView::Helpers::FormBuilder#fields_for`, originally
     # provided to ensure that the `:builder` from `semantic_form_for` was passed down into
-    # the nested `fields_for`. Rails 3 no longer requires us to do this, so this method is
-    # provided purely for backwards compatibility and DSL consistency.
+    # the nested `fields_for`. Our supported versions of Rails no longer require us to do this,
+    # so this method is provided purely for backwards compatibility and DSL consistency.
     #
     # When constructing a `fields_for` form fragment *outside* of `semantic_form_for`, please use
     # `Formtastic::Helpers::FormHelper#semantic_fields_for`.
@@ -75,14 +91,17 @@ module Formtastic
     #
     # @todo is there a way to test the params structure of the Rails helper we wrap to ensure forward compatibility?
     def semantic_fields_for(record_or_name_or_array, *args, &block)
-      # Add a :parent_builder to the args so that nested translations can be possible in Rails 3
-      options = args.extract_options!
-      options[:parent_builder] ||= self
-      
-      # Wrap the Rails helper
-      fields_for(record_or_name_or_array, *(args << options), &block)
+      fields_for(record_or_name_or_array, *args, &block)
     end
-    
+
+    def initialize(object_name, object, template, options)
+      super
+
+      if respond_to?('multipart=') && options.is_a?(Hash) && options[:html]
+        self.multipart = options[:html][:multipart]
+      end
+    end
+
   end
 
 end

data/lib/formtastic/helpers/action_helper.rb

@@ -2,7 +2,6 @@
 module Formtastic
   module Helpers
     module ActionHelper
-      
       # Renders an action for the form (such as a subit/reset button, or a cancel link).
       #
       # Each action is wrapped in an `<li class="action">` tag with other classes added based on the
@@ -12,6 +11,22 @@ module Formtastic
       # The textual value of the label can be changed from the default through the `:label`
       # argument or through i18n.
       #
+      # If using i18n, you'll need to provide the following translations:
+      #
+      #   en:
+      #     formtastic:
+      #       actions:
+      #         create: "Create new %{model}"
+      #         update: "Save %{model}"
+      #         cancel: "Cancel"
+      #         reset: "Reset form"
+      #         submit: "Submit"
+      #
+      # For forms with an object present, the `update` key will be used if calling `persisted?` on
+      # the object returns true (saving changes to a record), otherwise the `create` key will be
+      # used. The `submit` key is used as a fallback when there is no object or we cannot determine
+      # if `create` or `update` is appropriate.
+      #
       # @example Basic usage
       #   # form
       #   <%= semantic_form_for @post do |f| %>
@@ -64,46 +79,37 @@ module Formtastic
         options = options.dup # Allow options to be shared without being tainted by Formtastic
         options[:as] ||= default_action_type(method, options)
 
-        klass = action_class(options[:as])
+        klass = namespaced_action_class(options[:as])
 
         klass.new(self, template, @object, @object_name, method, options).to_html
       end
 
       protected
 
-      def default_action_type(method, options = {}) #:nodoc:
+      def default_action_type(method, options = {}) # @private
         case method
           when :submit then :input
-          when :reset then :input
+          when :reset  then :input
           when :cancel then :link
+          else method
         end
       end
 
-      def action_class(as)
-        @input_classes_cache ||= {}
-        @input_classes_cache[as] ||= begin
-          begin
-            begin
-              custom_action_class_name(as).constantize
-            rescue NameError
-              standard_action_class_name(as).constantize
-            end
-          rescue NameError
-            raise Formtastic::UnknownActionError
-          end
-        end
-      end
-
-      # :as => :button # => ButtonAction
-      def custom_action_class_name(as)
-        "#{as.to_s.camelize}Action"
-      end
-
-      # :as => :button # => Formtastic::Actions::ButtonAction
-      def standard_action_class_name(as)
-        "Formtastic::Actions::#{as.to_s.camelize}Action"
+      # Takes the `:as` option and attempts to return the corresponding action
+      # class. In the case of `:as => :awesome` it will first attempt to find a
+      # top level `AwesomeAction` class (to allow the application to subclass
+      # and modify to suit), falling back to `Formtastic::Actions::AwesomeAction`.
+      #
+      # Custom action namespaces to look into can be configured via the
+      # {Formtastic::FormBuilder.action_namespaces} configuration setting.
+      # @see Helpers::InputHelper#namespaced_input_class
+      # @see Formtastic::ActionClassFinder
+      def namespaced_action_class(as)
+        @action_class_finder ||= action_class_finder.new(self)
+        @action_class_finder.find(as)
+      rescue Formtastic::ActionClassFinder::NotFoundError => e
+        raise Formtastic::UnknownActionError, "Unable to find action #{e.message}"
       end
-
     end
   end
 end

data/lib/formtastic/helpers/enum.rb

@@ -0,0 +1,13 @@
+module Formtastic
+  module Helpers
+    # @private
+    module Enum
+      # Returns the enum (if defined) for the given method
+      def enum_for(method) # @private
+        if @object.respond_to?(:defined_enums)
+          @object.defined_enums[method.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/formtastic/helpers/errors_helper.rb

@@ -52,7 +52,7 @@ module Formtastic
         return nil if full_errors.blank?
         html_options[:class] ||= "errors"
         template.content_tag(:ul, html_options) do
-          Formtastic::Util.html_safe(full_errors.map { |error| template.content_tag(:li, Formtastic::Util.html_safe(error)) }.join)
+          full_errors.map { |error| template.content_tag(:li, error) }.join.html_safe
         end
       end
       
@@ -78,4 +78,4 @@ module Formtastic
       end
     end
   end
-end
+end

data/lib/formtastic/helpers/fieldset_wrapper.rb

@@ -21,8 +21,8 @@ module Formtastic
       #   f.inputs "My little legend", :title, :body, :author   # Explicit legend string => "My little legend"
       #   f.inputs :my_little_legend, :title, :body, :author    # Localized (118n) legend with I18n key => I18n.t(:my_little_legend, ...)
       #   f.inputs :title, :body, :author                       # First argument is a column => (no legend)
-      def field_set_and_list_wrapping(*args, &block) #:nodoc:
-        contents = args.last.is_a?(::Hash) ? '' : args.pop.flatten
+      def field_set_and_list_wrapping(*args, &block) # @private
+        contents = args[-1].is_a?(::Hash) ? '' : args.pop.flatten
         html_options = args.extract_options!
 
         if block_given?
@@ -33,12 +33,15 @@ module Formtastic
           end
         end
 
+        # Work-around for empty contents block
+        contents ||= ""
+
         # Ruby 1.9: String#to_s behavior changed, need to make an explicit join.
         contents = contents.join if contents.respond_to?(:join)
 
         legend = field_set_legend(html_options)
         fieldset = template.content_tag(:fieldset,
-          Formtastic::Util.html_safe(legend) << template.content_tag(:ol, Formtastic::Util.html_safe(contents)),
+          legend.html_safe << template.content_tag(:ol, contents.html_safe),
           html_options.except(:builder, :parent, :name)
         )
 
@@ -47,32 +50,33 @@ module Formtastic
 
       def field_set_legend(html_options)
         legend  = (html_options[:name] || '').to_s
-        legend %= parent_child_index(html_options[:parent]) if html_options[:parent]
-        legend  = template.content_tag(:legend, template.content_tag(:span, Formtastic::Util.html_safe(legend))) unless legend.blank?
+       	# only applying if String includes '%i' avoids argument error when $DEBUG is true
+        legend %= parent_child_index(html_options[:parent]) if html_options[:parent] && legend.include?('%i')
+        legend  = template.content_tag(:legend, template.content_tag(:span, legend.html_safe)) unless legend.blank?
         legend
       end
 
       # Gets the nested_child_index value from the parent builder. It returns a hash with each
       # association that the parent builds.
-      def parent_child_index(parent) #:nodoc:
+      def parent_child_index(parent) # @private
         # Could be {"post[authors_attributes]"=>0} or { :authors => 0 }
         duck = parent[:builder].instance_variable_get('@nested_child_index')
-        
+
         # Could be symbol for the association, or a model (or an array of either, I think? TODO)
         child = parent[:for]
         # Pull a sybol or model out of Array (TODO: check if there's an Array)
         child = child.first if child.respond_to?(:first)
         # If it's an object, get a symbol from the class name
         child = child.class.name.underscore.to_sym unless child.is_a?(Symbol)
-        
+
         key = "#{parent[:builder].object_name}[#{child}_attributes]"
 
-        # TODO: One of the tests produces a scenario where duck is "0" and the test looks for a "1" 
+        # TODO: One of the tests produces a scenario where duck is "0" and the test looks for a "1"
         # in the legend, so if we have a number, return it with a +1 until we can verify this scenario.
-        return duck + 1 if duck.is_a?(Fixnum)
-        
+        return duck + 1 if duck.is_a?(Integer)
+
         # First try to extract key from duck Hash, then try child
-        i = (duck[key] || duck[child]).to_i + 1
+        (duck[key] || duck[child]).to_i + 1
       end
 
     end

data/lib/formtastic/helpers/form_helper.rb

@@ -58,6 +58,17 @@ module Formtastic
       @@default_form_class = 'formtastic'
       mattr_accessor :default_form_class
 
+      # Allows to set a custom proc to handle the class infered from the model's name. By default it
+      # will infer the name from the class name (eg. Post will be "post").
+      @@default_form_model_class_proc = proc { |model_class_name| model_class_name }
+      mattr_accessor :default_form_model_class_proc
+
+      # Allows to set a custom field_error_proc wrapper. By default this wrapper
+      # is disabled since `formtastic` already adds an error class to the LI tag
+      # containing the input. Change this from `config/initializers/formtastic.rb`.
+      @@formtastic_field_error_proc = proc { |html_tag, instance_tag| html_tag }
+      mattr_accessor :formtastic_field_error_proc
+
       # Wrapper around Rails' own `form_for` helper to set the `:builder` option to
       # `Formtastic::FormBuilder` and to set some class names on the `<form>` tag such as
       # `formtastic` and the downcased and underscored model name (eg `post`).
@@ -144,18 +155,20 @@ module Formtastic
         options[:builder] ||= @@builder
         options[:html] ||= {}
         options[:html][:novalidate] = !@@builder.perform_browser_validations unless options[:html].key?(:novalidate)
-        @@builder.custom_namespace = options.delete(:namespace).to_s
+        options[:custom_namespace] = options.delete(:namespace)
 
         singularizer = defined?(ActiveModel::Naming.singular) ? ActiveModel::Naming.method(:singular) : ActionController::RecordIdentifier.method(:singular_class_name)
 
         class_names = options[:html][:class] ? options[:html][:class].split(" ") : []
         class_names << @@default_form_class
-        class_names << case record_or_name_or_array
+        model_class_name = case record_or_name_or_array
           when String, Symbol then record_or_name_or_array.to_s                                  # :post => "post"
-          when Array then options[:as] || singularizer.call(record_or_name_or_array.last.class)  # [@post, @comment] # => "comment"
+          when Array then options[:as] || singularizer.call(record_or_name_or_array[-1].class)  # [@post, @comment] # => "comment"
           else options[:as] || singularizer.call(record_or_name_or_array.class)                  # @post => "post"
         end
-        options[:html][:class] = class_names.join(" ")
+        class_names << @@default_form_model_class_proc.call(model_class_name)
+
+        options[:html][:class] = class_names.compact.join(" ")
 
         with_custom_field_error_proc do
           self.form_for(record_or_name_or_array, *(args << options), &proc)
@@ -169,7 +182,7 @@ module Formtastic
       def semantic_fields_for(record_name, record_object = nil, options = {}, &block)
         options, record_object = record_object, nil if record_object.is_a?(Hash) && record_object.extractable_options?
         options[:builder] ||= @@builder
-        @@builder.custom_namespace = options.delete(:namespace).to_s # TODO needed?
+        options[:custom_namespace] = options.delete(:namespace)
 
         with_custom_field_error_proc do
           self.fields_for(record_name, record_object, options, &block)
@@ -178,23 +191,13 @@ module Formtastic
 
       protected
 
-      # Override the default ActiveRecordHelper behaviour of wrapping the input.
-      # This gets taken care of semantically by adding an error class to the LI tag
-      # containing the input.
-      # @private
-      FIELD_ERROR_PROC = proc do |html_tag, instance_tag|
-        html_tag
-      end
-
       def with_custom_field_error_proc(&block)
         default_field_error_proc = ::ActionView::Base.field_error_proc
-        ::ActionView::Base.field_error_proc = FIELD_ERROR_PROC
+        ::ActionView::Base.field_error_proc = @@formtastic_field_error_proc
         yield
       ensure
         ::ActionView::Base.field_error_proc = default_field_error_proc
       end
-
-
     end
   end
 end

data/lib/formtastic/helpers/input_helper.rb

@@ -37,6 +37,7 @@ module Formtastic
     # @see Formtastic::Helpers::FormHelper#semantic_form_for
     module InputHelper
       include Formtastic::Helpers::Reflection
+      include Formtastic::Helpers::Enum
       include Formtastic::Helpers::FileColumnDetection
 
       # Returns a chunk of HTML markup for a given `method` on the form object, wrapped in
@@ -86,25 +87,26 @@ module Formtastic
       #
       # Available input styles:
       #
-      # * `:boolean`      (see {Inputs::BooleanInput})
-      # * `:check_boxes`  (see {Inputs::CheckBoxesInput})
-      # * `:country`      (see {Inputs::CountryInput})
-      # * `:datetime`     (see {Inputs::DatetimeInput})
-      # * `:date`         (see {Inputs::DateInput})
-      # * `:email`        (see {Inputs::EmailInput})
-      # * `:file`         (see {Inputs::FileInput})
-      # * `:hidden`       (see {Inputs::HiddenInput})
-      # * `:number`       (see {Inputs::NumberInput})
-      # * `:password`     (see {Inputs::PasswordInput})
-      # * `:phone`        (see {Inputs::PhoneInput})
-      # * `:radio`        (see {Inputs::RadioInput})
-      # * `:search`       (see {Inputs::SearchInput})
-      # * `:select`       (see {Inputs::SelectInput})
-      # * `:string`       (see {Inputs::StringInput})
-      # * `:text`         (see {Inputs::TextInput})
-      # * `:time_zone`    (see {Inputs::TimeZoneInput})
-      # * `:time`         (see {Inputs::TimeInput})
-      # * `:url`          (see {Inputs::UrlInput})
+      # * `:boolean`          (see {Inputs::BooleanInput})
+      # * `:check_boxes`      (see {Inputs::CheckBoxesInput})
+      # * `:color`            (see {Inputs::ColorInput})
+      # * `:country`          (see {Inputs::CountryInput})
+      # * `:datetime_select`  (see {Inputs::DatetimeSelectInput})
+      # * `:date_select`      (see {Inputs::DateSelectInput})
+      # * `:email`            (see {Inputs::EmailInput})
+      # * `:file`             (see {Inputs::FileInput})
+      # * `:hidden`           (see {Inputs::HiddenInput})
+      # * `:number`           (see {Inputs::NumberInput})
+      # * `:password`         (see {Inputs::PasswordInput})
+      # * `:phone`            (see {Inputs::PhoneInput})
+      # * `:radio`            (see {Inputs::RadioInput})
+      # * `:search`           (see {Inputs::SearchInput})
+      # * `:select`           (see {Inputs::SelectInput})
+      # * `:string`           (see {Inputs::StringInput})
+      # * `:text`             (see {Inputs::TextInput})
+      # * `:time_zone`        (see {Inputs::TimeZoneInput})
+      # * `:time_select`      (see {Inputs::TimeSelectInput})
+      # * `:url`              (see {Inputs::UrlInput})
       #
       # Calling `:as => :string` (for example) will call `#to_html` on a new instance of
       # `Formtastic::Inputs::StringInput`. Before this, Formtastic will try to instantiate a top-level
@@ -130,6 +132,7 @@ module Formtastic
       #
       # @option options :input_html [Hash]
       #   Override or add to the HTML attributes to be passed down to the `<input>` tag
+      #   (If you use attr_readonly method in your model, formtastic will automatically set those attributes's input readonly)
       #
       # @option options :wrapper_html [Hash]
       #   Override or add to the HTML attributes to be passed down to the wrapping `<li>` tag
@@ -137,40 +140,16 @@ module Formtastic
       # @option options :collection [Array<ActiveModel, String, Symbol>, Hash{String => String, Boolean}, OrderedHash{String => String, Boolean}]
       #   Override collection of objects in the association (`:select`, `:radio` & `:check_boxes` inputs only)
       #
-      # @option options :member_label [Symbol, Proc, Method]
-      #   Override the method called on each object in the `:collection` for use as the `<label>` content (`:check_boxes` & `:radio` inputs) or `<option>` content (`:select` inputs)
-      #
-      # @option options :member_value [Symbol, Proc, Method]
-      #   Override the method called on each object in the `:collection` for use as the `value` attribute in the `<input>` (`:check_boxes` & `:radio` inputs) or `<option>` (`:select` inputs)
-      #
-      # @option options :hint_class [String]
-      #   Override the `class` attribute applied to the `<p>` tag used when a `:hint` is rendered for an input
-      #
-      # @option options :error_class [String]
-      #   Override the `class` attribute applied to the `<p>` or `<ol>` tag used when inline errors are rendered for an input
-      #
       # @option options :multiple [Boolean]
       #   Specify if the `:select` input should allow multiple selections or not (defaults to `belongs_to` associations, and `true` for `has_many` and `has_and_belongs_to_many` associations)
       #
-      # @option options :group_by [Symbol]
-      #   TODO will probably be deprecated
-      #
-      # @option options :find_options [Symbol]
-      #   TODO will probably be deprecated
-      #
-      # @option options :group_label [Symbol]
-      #   TODO will probably be deprecated
-      #
       # @option options :include_blank [Boolean]
       #   Specify if a `:select` input should include a blank option or not (defaults to `include_blank_for_select_by_default` configuration)
       #
       # @option options :prompt [String]
       #   Specify the text in the first ('blank') `:select` input `<option>` to prompt a user to make a selection (implicitly sets `:include_blank` to `true`)
       #
-      # @todo Can we kill `:hint_class` & `:error_class`? What's the use case for input-by-input? Shift to config or burn!
-      # @todo Can we kill `:group_by` & `:group_label`? Should be done with :collection => grouped_options_for_select(...)
-      # @todo Can we kill `:find_options`? Should be done with MyModel.some_scope.where(...).order(...).whatever_scope
-      # @todo Can we kill `:label`, `:hint` & `:prompt`? All strings could be shifted to i18n!
+      # @todo Can we deprecate & kill `:label`, `:hint` & `:prompt`? All strings could be shifted to i18n!
       #
       # @example Accept all default options
       #   <%= f.input :title %>
@@ -247,13 +226,15 @@ module Formtastic
       #          first_name: "Joe"
       #          last_name: "Smith"
       #
+      # @see #namespaced_input_class
       # @todo Many many more examples. Some of the detail probably needs to be pushed out to the relevant methods too.
       # @todo More i18n examples.
       def input(method, options = {})
+        method = method.to_sym
         options = options.dup # Allow options to be shared without being tainted by Formtastic
         options[:as] ||= default_input_type(method, options)
 
-        klass = input_class(options[:as])
+        klass = namespaced_input_class(options[:as])
 
         klass.new(self, template, @object, @object_name, method, options).to_html
       end
@@ -270,14 +251,15 @@ module Formtastic
       #
       # If there is no column for the method (eg "virtual columns" with an attr_accessor), the
       # default is a :string, a similar behaviour to Rails' scaffolding.
-      def default_input_type(method, options = {}) #:nodoc:
+      def default_input_type(method, options = {}) # @private
         if @object
           return :select  if reflection_for(method)
 
           return :file    if is_file?(method, options)
         end
 
-        if column = column_for(method)
+        column = column_for(method)
+        if column && column.type
           # Special cases where the column type doesn't map to an input method.
           case column.type
           when :string
@@ -288,13 +270,23 @@ module Formtastic
             return :url       if method.to_s =~ /^url$|^website$|_url$/
             return :phone     if method.to_s =~ /(phone|fax)/
             return :search    if method.to_s =~ /^search$/
+            return :color     if method.to_s =~ /color/
           when :integer
             return :select    if reflection_for(method)
+            return :select    if enum_for(method)
             return :number
           when :float, :decimal
             return :number
-          when :timestamp
-            return :datetime
+          when :datetime, :timestamp
+            return :datetime_select
+          when :time
+            return :time_select
+          when :date
+            return :date_select
+          when :hstore, :json, :jsonb
+            return :text
+          when :citext, :inet
+            return :string
           end
 
           # Try look for hints in options hash. Quite common senario: Enum keys stored as string in the database.
@@ -309,16 +301,30 @@ module Formtastic
       end
 
       # Get a column object for a specified attribute method - if possible.
-      def column_for(method) #:nodoc:
-        @object.column_for_attribute(method) if @object.respond_to?(:column_for_attribute)
+      # @return [ActiveModel::Type::Value, #type] in case of rails 5 attributes api
+      # @return [ActiveRecord::ConnectionAdapters::Column] in case of rails 4
+      def column_for(method) # @private
+        case
+          when @object.class.respond_to?(:type_for_attribute)
+            @object.class.type_for_attribute(method.to_s)
+          when @object.class.respond_to?(:column_for_attribute)
+            @object.class.column_for_attribute(method)
+          when @object.respond_to?(:column_for_attribute)
+            # Remove deprecation wrapper & review after Rails 5.0 ships
+            ActiveSupport::Deprecation.silence do
+              @object.column_for_attribute(method)
+            end
+          else nil
+        end
       end
 
-      # Takes the `:as` option and attempts to return the corresponding input class. In the case of
-      # `:as => :string` it will first attempt to find a top level `StringInput` class (to allow the
-      # application to subclass and modify to suit), falling back to `Formtastic::Inputs::StringInput`.
+      # Takes the `:as` option and attempts to return the corresponding input
+      # class. In the case of `:as => :awesome` it will first attempt to find a
+      # top level `AwesomeInput` class (to allow the application to subclass
+      # and modify to suit), falling back to `Formtastic::Inputs::AwesomeInput`.
       #
-      # This also means that the application can define it's own custom inputs in the top level
-      # namespace (eg `DatepickerInput`).
+      # Custom input namespaces to look into can be configured via the
+      # {Formtastic::FormBuilder.input_namespaces} configuration setting.
       #
       # @param [Symbol] as A symbol representing the type of input to render
       # @raise [Formtastic::UnknownInputError] An appropriate input class could not be found
@@ -330,48 +336,14 @@ module Formtastic
       #
       # @example When a top-level class is found
       #   input_class(:string) #=> StringInput
-      #   input_class(:awesome) #=> AwesomeInput      
-      def input_class(as)
-        @input_classes_cache ||= {}
-        @input_classes_cache[as] ||= begin
-          Rails.application.config.cache_classes ? input_class_with_const_defined(as) : input_class_by_trying(as)
-        end
-      end
-      
-      # prevent exceptions in production environment for better performance
-      def input_class_with_const_defined(as)
-        input_class_name = custom_input_class_name(as)
-
-        if ::Object.const_defined?(input_class_name)
-          input_class_name.constantize
-        elsif Formtastic::Inputs.const_defined?(input_class_name)
-          standard_input_class_name(as).constantize 
-        else
-          raise Formtastic::UnknownInputError
-        end
-      end
-      
-      # use auto-loading in development environment
-      def input_class_by_trying(as)
-        begin
-          custom_input_class_name(as).constantize
-        rescue NameError
-          standard_input_class_name(as).constantize
-        end
-      rescue NameError
-        raise Formtastic::UnknownInputError
+      #   input_class(:awesome) #=> AwesomeInput
+      # @see NamespacedClassFinder#find
+      def namespaced_input_class(as)
+        @input_class_finder ||= input_class_finder.new(self)
+        @input_class_finder.find(as)
+      rescue Formtastic::InputClassFinder::NotFoundError
+        raise Formtastic::UnknownInputError, "Unable to find input #{$!.message}"
       end
-
-      # :as => :string # => StringInput
-      def custom_input_class_name(as)
-        "#{as.to_s.camelize}Input"
-      end
-
-      # :as => :string # => Formtastic::Inputs::StringInput
-      def standard_input_class_name(as)
-        "Formtastic::Inputs::#{as.to_s.camelize}Input"
-      end
-
     end
   end
 end