formtastic 3.0.0 → 5.0.0

data/lib/formtastic/form_builder.rb

@@ -1,9 +1,19 @@
+# frozen_string_literal: true
 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,7 +22,7 @@ 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
@@ -31,6 +41,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
 
@@ -43,11 +62,11 @@ module Formtastic
     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`.
@@ -73,29 +92,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, block=nil)
-      # rails 3 supported passing in the block parameter to FormBuilder
-      # rails 4.0 deprecated the block parameter and does nothing with it
-      # rails 4.1 removes the parameter completely
-      if Util.rails3? || Util.rails4_0?
-        super
-      else # Must be rails4_1 or greater
-        super object_name, object, template, options
-      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

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 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
@@ -23,9 +23,9 @@ module Formtastic
       #         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` ey will be 
-      # used. The `submit` key is used as a fallback when there is no object or we cannot determine 
+      # 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
@@ -80,46 +80,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/actions_helper.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Formtastic
   module Helpers
     # ActionsHelper encapsulates the responsibilties of the {#actions} DSL for acting on 

data/lib/formtastic/helpers/enum.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+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

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Formtastic
   module Helpers
     module ErrorsHelper
@@ -52,7 +53,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 +79,4 @@ module Formtastic
       end
     end
   end
-end
+end

data/lib/formtastic/helpers/fieldset_wrapper.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Formtastic
   module Helpers
     # @private
@@ -21,8 +22,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 +34,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,30 +51,31 @@ 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
         (duck[key] || duck[child]).to_i + 1
       end

data/lib/formtastic/helpers/file_column_detection.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Formtastic
   module Helpers
     # @private

data/lib/formtastic/helpers/form_helper.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Formtastic
   module Helpers
 
@@ -155,7 +156,7 @@ 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)
 
@@ -163,7 +164,7 @@ module Formtastic
         class_names << @@default_form_class
         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
         class_names << @@default_form_model_class_proc.call(model_class_name)
@@ -182,7 +183,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)

data/lib/formtastic/helpers/input_helper.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 module Formtastic
   module Helpers
 
@@ -37,6 +38,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,26 +88,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
@@ -131,6 +133,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
@@ -138,12 +141,6 @@ 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 :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)
       #
@@ -230,14 +227,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 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)
 
-        klass = input_class(options[:as])
+        klass = namespaced_input_class(options[:as])
 
         klass.new(self, template, @object, @object_name, method, options).to_html
       end
@@ -254,14 +252,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
@@ -275,6 +274,7 @@ module Formtastic
             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
@@ -284,6 +284,10 @@ module Formtastic
             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.
@@ -298,16 +302,27 @@ 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)
+            @object.column_for_attribute(method)
+          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
@@ -319,50 +334,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
-          config = Rails.application.config
-          use_const_defined = config.respond_to?(:eager_load) ? config.eager_load : config.cache_classes
-          use_const_defined ? 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, "Unable to find input class #{input_class_name}"
-        end
+      #   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
-      
-      # 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, "Unable to find input class for #{as}"
-      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