formtastic 3.0.0 → 3.1.0.rc1

data/lib/formtastic/helpers/input_helper.rb

@@ -36,6 +36,9 @@ module Formtastic
     # @see Formtastic::Helpers::InputsHelper#inputs
     # @see Formtastic::Helpers::FormHelper#semantic_form_for
     module InputHelper
+      INPUT_CLASS_DEPRECATION = 'configure Formtastic::FormBuilder.input_class_finder instead'.freeze
+      private_constant(:INPUT_CLASS_DEPRECATION)
+
       include Formtastic::Helpers::Reflection
       include Formtastic::Helpers::FileColumnDetection
 
@@ -86,26 +89,26 @@ module Formtastic
       #
       # Available input styles:
       #
-      # * `: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})
+      # * `: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
@@ -233,7 +236,7 @@ module Formtastic
       # @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 if method.is_a?(String)
+        method = method.to_sym
         options = options.dup # Allow options to be shared without being tainted by Formtastic
         options[:as] ||= default_input_type(method, options)
 
@@ -299,15 +302,21 @@ module Formtastic
 
       # 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)
+        if @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
+        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
+      # .input_namespaces +FormBuilder+ 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
@@ -319,8 +328,22 @@ module Formtastic
       #
       # @example When a top-level class is found
       #   input_class(:string) #=> StringInput
-      #   input_class(:awesome) #=> AwesomeInput      
+      #   input_class(:awesome) #=> AwesomeInput
+
+      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
+
+      # @api private
+      # @deprecated Use {#namespaced_input_class} instead.
       def input_class(as)
+        return namespaced_input_class(as) if input_class_finder
+
+        input_class_deprecation_warning(__method__)
+
         @input_classes_cache ||= {}
         @input_classes_cache[as] ||= begin
           config = Rails.application.config
@@ -328,7 +351,9 @@ module Formtastic
           use_const_defined ? input_class_with_const_defined(as) : input_class_by_trying(as)
         end
       end
-      
+
+      # @api private
+      # @deprecated Use {InputClassFinder#find} instead.
       # prevent exceptions in production environment for better performance
       def input_class_with_const_defined(as)
         input_class_name = custom_input_class_name(as)
@@ -336,12 +361,14 @@ module Formtastic
         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 
+          standard_input_class_name(as).constantize
         else
           raise Formtastic::UnknownInputError, "Unable to find input class #{input_class_name}"
         end
       end
-      
+
+      # @api private
+      # @deprecated Use {InputClassFinder#find} instead.
       # use auto-loading in development environment
       def input_class_by_trying(as)
         begin
@@ -353,16 +380,29 @@ module Formtastic
         raise Formtastic::UnknownInputError, "Unable to find input class for #{as}"
       end
 
+      # @api private
+      # @deprecated Use {InputClassFinder#class_name} instead.
       # :as => :string # => StringInput
       def custom_input_class_name(as)
+        input_class_deprecation_warning(__method__)
         "#{as.to_s.camelize}Input"
       end
 
+      # @api private
+      # @deprecated Use {InputClassFinder#class_name} instead.
       # :as => :string # => Formtastic::Inputs::StringInput
       def standard_input_class_name(as)
+        input_class_deprecation_warning(__method__)
         "Formtastic::Inputs::#{as.to_s.camelize}Input"
       end
 
+      private
+
+      def input_class_deprecation_warning(method)
+        @input_class_deprecation_warned ||=
+            Formtastic.deprecation.deprecation_warning(method, INPUT_CLASS_DEPRECATION, caller(2))
+      end
+
     end
   end
 end

data/lib/formtastic/html_attributes.rb

@@ -1,6 +1,17 @@
 module Formtastic
   # @private
   module HtmlAttributes
+    # Returns a namespace passed by option or inherited from parent builders / class configuration
+    def dom_id_namespace
+      namespace = options[:custom_namespace]
+      parent = options[:parent_builder]
+
+      case
+        when namespace then namespace
+        when parent && parent != self then parent.dom_id_namespace
+        else custom_namespace
+      end
+    end
 
     protected
 
@@ -18,4 +29,4 @@ module Formtastic
     end
 
   end
-end
+end

data/lib/formtastic/input_class_finder.rb

@@ -0,0 +1,18 @@
+module Formtastic
+
+  # Uses the Formtastic::NamespacedClassFinder to look up input class names.
+  #
+  # See Formtastic::Helpers::InputHelper#namespaced_input_class for details.
+  #
+  class InputClassFinder < NamespacedClassFinder
+    def initialize(builder)
+      super builder.input_namespaces
+    end
+
+    private
+
+    def class_name(as)
+      "#{super}Input"
+    end
+  end
+end

data/lib/formtastic/inputs.rb

@@ -8,6 +8,7 @@ module Formtastic
     autoload :CheckBoxesInput
     autoload :ColorInput
     autoload :CountryInput
+    autoload :DatalistInput
     autoload :DateInput
     autoload :DatePickerInput
     autoload :DatetimePickerInput

data/lib/formtastic/inputs/base.rb

@@ -1,9 +1,9 @@
 module Formtastic
   module Inputs
     module Base
-      
+
       attr_accessor :builder, :template, :object, :object_name, :method, :options
-      
+
       def initialize(builder, template, object, object_name, method, options)
         @builder = builder
         @template = template
@@ -12,29 +12,29 @@ module Formtastic
         @method = method
         @options = options.dup
       end
-      
+
       # Usefull for deprecating options.
       def warn_and_correct_option!(old_option_name, new_option_name)
         if options.key?(old_option_name)
-          ::ActiveSupport::Deprecation.warn("The :#{old_option_name} option is deprecated in favour of :#{new_option_name} and will be removed from Formtastic in the next version")
+          ::ActiveSupport::Deprecation.warn("The :#{old_option_name} option is deprecated in favour of :#{new_option_name} and will be removed from Formtastic in the next version", caller(6))
           options[new_option_name] = options.delete(old_option_name)
         end
       end
-      
+
       # Usefull for deprecating options.
       def warn_deprecated_option!(old_option_name, instructions)
         if options.key?(old_option_name)
-          ::ActiveSupport::Deprecation.warn("The :#{old_option_name} option is deprecated in favour of `#{instructions}` and will be removed in the next version")
+          ::ActiveSupport::Deprecation.warn("The :#{old_option_name} option is deprecated in favour of `#{instructions}` and will be removed in the next version", caller(6))
         end
       end
-      
+
       # Usefull for raising an error on previously supported option.
       def removed_option!(old_option_name)
         raise ArgumentError, ":#{old_option_name} is no longer available" if options.key?(old_option_name)
       end
-      
+
       extend ActiveSupport::Autoload
-      
+
       autoload :DatetimePickerish
       autoload :Associations
       autoload :Collections
@@ -53,7 +53,7 @@ module Formtastic
       autoload :Timeish
       autoload :Validations
       autoload :Wrapping
-      
+
       include Html
       include Options
       include Database
@@ -65,8 +65,7 @@ module Formtastic
       include Associations
       include Labelling
       include Wrapping
-      
+
     end
   end
 end
-  

data/lib/formtastic/inputs/base/choices.rb

@@ -73,7 +73,7 @@ module Formtastic
 
         def choice_input_dom_id(choice)
           [
-            builder.custom_namespace,
+            builder.dom_id_namespace,
             sanitized_object_name,
             builder.options[:index],
             association_primary_key || method,

data/lib/formtastic/inputs/base/collections.rb

@@ -48,7 +48,7 @@ module Formtastic
 
         def collection
           # Return if we have a plain string
-          return raw_collection if raw_collection.instance_of?(String) || raw_collection.instance_of?(ActiveSupport::SafeBuffer)
+          return raw_collection if raw_collection.is_a?(String)
 
           # Return if we have an Array of strings, fixnums or arrays
           return raw_collection if (raw_collection.instance_of?(Array) || raw_collection.instance_of?(Range)) &&

data/lib/formtastic/inputs/base/html.rb

@@ -28,9 +28,9 @@ module Formtastic
         
         def dom_id
           [
-            builder.custom_namespace, 
-            sanitized_object_name, 
-            dom_index, 
+            builder.dom_id_namespace,
+            sanitized_object_name,
+            dom_index,
             association_primary_key || sanitized_method_name
           ].reject { |x| x.blank? }.join('_')
         end

data/lib/formtastic/inputs/datalist_input.rb

@@ -0,0 +1,41 @@
+module Formtastic
+  module Inputs
+    # Outputs a label and a text field, along with a datalist tag
+    # datalist tag provides a list of options which drives a simple autocomplete
+    # on the text field. This is a HTML5 feature, more info can be found at
+    # {https://developer.mozilla.org/en/docs/Web/HTML/Element/datalist <datalist> at MDN}
+    # This input accepts a :collection option which takes data in all the usual formats accepted by
+    # {http://apidock.com/rails/ActionView/Helpers/FormOptionsHelper/options_for_select options_for_select}
+    #
+    # @example Input is used as follows
+    #   f.input :fav_book, :as => :datalist, :collection => Book.pluck(:name)
+    #
+    class DatalistInput
+      include Base
+      include Base::Stringish
+      include Base::Collections
+
+      def to_html
+        @name = input_html_options[:id].gsub(/_id$/, "")
+        input_wrapping do
+          label_html <<
+          builder.text_field(method, input_html_options) << # standard input
+          data_list_html # append new datalist element
+        end
+      end
+
+      def input_html_options
+        super.merge(:list => html_id_of_datalist)
+      end
+
+      def html_id_of_datalist
+        "#{@name}_datalist"
+      end
+
+      def data_list_html
+        html = builder.template.options_for_select(collection)
+        builder.template.content_tag(:datalist,html, { :id => html_id_of_datalist }, false)
+      end
+    end
+  end
+end

data/lib/formtastic/inputs/file_input.rb

@@ -20,7 +20,7 @@ module Formtastic
     #   <form...>
     #     <fieldset>
     #       <ol>
-    #         <li class="email">
+    #         <li class="file">
     #           <label for="user_avatar">Avatar</label>
     #           <input type="file" id="user_avatar" name="user[avatar]">
     #         </li>
@@ -29,7 +29,7 @@ module Formtastic
     #   </form>
     #
     # @see Formtastic::Helpers::InputsHelper#input InputsHelper#input for full documentation of all possible options.
-    class FileInput 
+    class FileInput
       include Base
       def to_html
         input_wrapping do

data/lib/formtastic/namespaced_class_finder.rb

@@ -0,0 +1,89 @@
+module Formtastic
+  # This class implements class resolution in a namespace chain. It
+  # is used both by Formtastic::Helpers::InputHelper and
+  # Formtastic::Helpers::ActionHelper to look up action and input classes.
+  #
+  # ==== Example
+  # You can implement own class finder that for example prefixes the class name or uses custom module.
+  #
+  #   class MyInputClassFinder < Formtastic::NamespacedClassFinder
+  #     def initialize(builder)
+  #       super [MyNamespace, Object] # first lookup in MyNamespace then the globals
+  #     end
+  #
+  #     private
+  #
+  #     def class_name(as)
+  #       "My#{super}Input" # for example MyStringInput
+  #     end
+  #   end
+  #
+  # And then set Formtastic::FormBuilder.input_class_finder with that class.
+  #
+
+  class NamespacedClassFinder
+    attr_reader :namespaces #:nodoc:
+
+    # @private
+    class NotFoundError < NameError
+    end
+
+    def initialize(namespaces) #:nodoc:
+      @namespaces = namespaces.flatten
+      @cache = {}
+    end
+
+    # Looks up the given reference in the configured namespaces.
+    #
+    # Two finder methods are provided, one for development tries to
+    # reference the constant directly, triggering Rails' autoloading
+    # const_missing machinery; the second one instead for production
+    # checks with .const_defined before referencing the constant.
+    #
+    def find(as)
+      @cache[as] ||= resolve(as)
+    end
+
+    def resolve(as)
+      class_name = class_name(as)
+
+      finder(class_name) or raise NotFoundError, "class #{class_name}"
+    end
+
+    private
+
+    def class_name(as)
+      as.to_s.camelize
+    end
+
+    if defined?(Rails) && ::Rails.application && ::Rails.application.config.cache_classes
+      def finder(class_name) # :nodoc:
+        find_with_const_defined(class_name)
+      end
+    else
+      def finder(class_name) # :nodoc:
+        find_by_trying(class_name)
+      end
+    end
+
+    # Looks up the given class name in the configured namespaces in order,
+    # returning the first one that has the class name constant defined.
+    def find_with_const_defined(class_name)
+      @namespaces.find do |namespace|
+        if namespace.const_defined?(class_name)
+          break namespace.const_get(class_name)
+        end
+      end
+    end
+
+    # Use auto-loading in development environment
+    def find_by_trying(class_name)
+      @namespaces.find do |namespace|
+        begin
+          break namespace.const_get(class_name)
+        rescue NameError
+        end
+      end
+    end
+  end
+end