simple_form 3.0.1 → 3.1.0.rc1

data/lib/generators/simple_form/templates/config/initializers/simple_form_bootstrap.rb

@@ -1,45 +1,106 @@
 # Use this setup block to configure all options available in SimpleForm.
 SimpleForm.setup do |config|
-  config.wrappers :bootstrap, tag: 'div', class: 'control-group', error_class: 'error' do |b|
+  config.button_class = 'btn btn-default'
+  config.boolean_label_class = nil
+
+  config.wrappers :vertical_form, tag: 'div', class: 'form-group', error_class: 'has-error' do |b|
     b.use :html5
     b.use :placeholder
-    b.use :label
-    b.wrapper tag: 'div', class: 'controls' do |ba|
+    b.use :label, class: 'control-label'
+
+    b.wrapper tag: 'div' do |ba|
+      ba.use :input, class: 'form-control'
+      ba.use :error, wrap_with: { tag: 'span', class: 'help-block' }
+      ba.use :hint,  wrap_with: { tag: 'p', class: 'help-block' }
+    end
+  end
+
+  config.wrappers :vertical_file_input, tag: 'div', class: 'form-group', error_class: 'has-error' do |b|
+    b.use :html5
+    b.use :placeholder
+    b.use :label, class: 'control-label'
+
+    b.wrapper tag: 'div' do |ba|
       ba.use :input
-      ba.use :error, wrap_with: { tag: 'span', class: 'help-inline' }
+      ba.use :error, wrap_with: { tag: 'span', class: 'help-block' }
       ba.use :hint,  wrap_with: { tag: 'p', class: 'help-block' }
     end
   end
 
-  config.wrappers :prepend, tag: 'div', class: "control-group", error_class: 'error' do |b|
+  config.wrappers :vertical_boolean, tag: 'div', class: 'form-group', error_class: 'has-error' do |b|
     b.use :html5
     b.use :placeholder
-    b.use :label
-    b.wrapper tag: 'div', class: 'controls' do |input|
-      input.wrapper tag: 'div', class: 'input-prepend' do |prepend|
-        prepend.use :input
-      end
-      input.use :hint,  wrap_with: { tag: 'span', class: 'help-block' }
-      input.use :error, wrap_with: { tag: 'span', class: 'help-inline' }
+
+    b.wrapper tag: 'div', class: 'checkbox' do |ba|
+      ba.use :label_input
+    end
+
+    b.use :error, wrap_with: { tag: 'span', class: 'help-block' }
+    b.use :hint,  wrap_with: { tag: 'p', class: 'help-block' }
+  end
+
+  config.wrappers :vertical_radio_and_checkboxes, tag: 'div', class: 'form-group', error_class: 'has-error' do |b|
+    b.use :html5
+    b.use :placeholder
+    b.use :label_input
+    b.use :error, wrap_with: { tag: 'span', class: 'help-block' }
+    b.use :hint,  wrap_with: { tag: 'p', class: 'help-block' }
+  end
+
+  config.wrappers :horizontal_form, tag: 'div', class: 'form-group', error_class: 'has-error' do |b|
+    b.use :html5
+    b.use :placeholder
+    b.use :label, class: 'col-sm-3 control-label'
+
+    b.wrapper tag: 'div', class: 'col-sm-9' do |ba|
+      ba.use :input, class: 'form-control'
+      ba.use :error, wrap_with: { tag: 'span', class: 'help-block' }
+      ba.use :hint,  wrap_with: { tag: 'p', class: 'help-block' }
     end
   end
 
-  config.wrappers :append, tag: 'div', class: "control-group", error_class: 'error' do |b|
+  config.wrappers :horizontal_file_input, tag: 'div', class: 'form-group', error_class: 'has-error' do |b|
     b.use :html5
     b.use :placeholder
-    b.use :label
-    b.wrapper tag: 'div', class: 'controls' do |input|
-      input.wrapper tag: 'div', class: 'input-append' do |append|
-        append.use :input
+    b.use :label, class: 'col-sm-3 control-label'
+
+    b.wrapper tag: 'div', class: 'col-sm-9' do |ba|
+      ba.use :input
+      ba.use :error, wrap_with: { tag: 'span', class: 'help-block' }
+      ba.use :hint,  wrap_with: { tag: 'p', class: 'help-block' }
+    end
+  end
+
+  config.wrappers :horizontal_boolean, tag: 'div', class: 'form-group', error_class: 'has-error' do |b|
+    b.use :html5
+    b.use :placeholder
+
+    b.wrapper tag: 'div', class: 'col-sm-offset-3 col-sm-9' do |wr|
+      wr.wrapper tag: 'div', class: 'checkbox' do |ba|
+        ba.use :label_input, class: 'col-sm-9'
       end
-      input.use :hint,  wrap_with: { tag: 'span', class: 'help-block' }
-      input.use :error, wrap_with: { tag: 'span', class: 'help-inline' }
+
+      wr.use :error, wrap_with: { tag: 'span', class: 'help-block' }
+      wr.use :hint,  wrap_with: { tag: 'p', class: 'help-block' }
+    end
+  end
+
+  config.wrappers :horizontal_radio_and_checkboxes, tag: 'div', class: 'form-group', error_class: 'has-error' do |b|
+    b.use :html5
+    b.use :placeholder
+
+    b.use :label, class: 'col-sm-3 control-label'
+
+    b.wrapper tag: 'div', class: 'col-sm-9' do |ba|
+      ba.use :input
+      ba.use :error, wrap_with: { tag: 'span', class: 'help-block' }
+      ba.use :hint,  wrap_with: { tag: 'p', class: 'help-block' }
     end
   end
 
-  # Wrappers for forms and inputs using the Twitter Bootstrap toolkit.
-  # Check the Bootstrap docs (http://twitter.github.com/bootstrap)
+  # Wrappers for forms and inputs using the Bootstrap toolkit.
+  # Check the Bootstrap docs (http://getbootstrap.com)
   # to learn about the different styles for forms and inputs,
   # buttons and other elements.
-  config.default_wrapper = :bootstrap
+  config.default_wrapper = :vertical_form
 end

data/lib/generators/simple_form/templates/config/initializers/simple_form_foundation.rb

@@ -8,7 +8,7 @@ SimpleForm.setup do |config|
     b.optional :min_max
     b.optional :readonly
     b.use :label_input
-    b.use :error, wrap_with: { tag: :small }
+    b.use :error, wrap_with: { tag: :small, class: :error }
 
     # Uncomment the following line to enable hints. The line is commented out by default since Foundation
     # does't provide styles for hints. You will need to provide your own CSS styles for hints.

data/lib/generators/simple_form/templates/config/locales/simple_form.en.yml

@@ -10,7 +10,7 @@ en:
       # html: '<abbr title="required">*</abbr>'
     error_notification:
       default_message: "Please review the problems below:"
-    # Labels and hints examples
+    # Examples
     # labels:
     #   defaults:
     #     password: 'Password'
@@ -23,4 +23,9 @@ en:
     #   defaults:
     #     username: 'User name to sign in.'
     #     password: 'No special characters, please.'
-
+    # include_blanks:
+    #   defaults:
+    #     age: 'Rather not say'
+    # prompts:
+    #   defaults:
+    #     age: 'Select your age'

data/lib/simple_form/action_view_extensions/form_helper.rb

@@ -10,7 +10,7 @@ module SimpleForm
     #
     module FormHelper
 
-      def simple_form_for(record, options={}, &block)
+      def simple_form_for(record, options = {}, &block)
         options[:builder] ||= SimpleForm::FormBuilder
         options[:html] ||= {}
         unless options[:html].key?(:novalidate)

data/lib/simple_form/components/errors.rb

@@ -1,10 +1,14 @@
 module SimpleForm
   module Components
     module Errors
-      def error
+      def error(wrapper_options = nil)
         error_text if has_errors?
       end
 
+      def full_error(wrapper_options = nil)
+        full_error_text if options[:error] != false && has_errors?
+      end
+
       def has_errors?
         object && object.respond_to?(:errors) && errors.present?
       end
@@ -12,7 +16,15 @@ module SimpleForm
       protected
 
       def error_text
-        "#{html_escape(options[:error_prefix])} #{errors.send(error_method)}".lstrip.html_safe
+        text = has_custom_error? ? options[:error] : errors.send(error_method)
+
+        "#{html_escape(options[:error_prefix])} #{text}".lstrip.html_safe
+      end
+
+      def full_error_text
+        text = has_custom_error? ? options[:error] : full_errors.send(error_method)
+
+        text.html_safe
       end
 
       def error_method
@@ -23,13 +35,29 @@ module SimpleForm
         @errors ||= (errors_on_attribute + errors_on_association).compact
       end
 
+      def full_errors
+        @full_errors ||= (full_errors_on_attribute + full_errors_on_association).compact
+      end
+
       def errors_on_attribute
         object.errors[attribute_name]
       end
 
+      def full_errors_on_attribute
+        object.errors.full_messages_for(attribute_name)
+      end
+
       def errors_on_association
         reflection ? object.errors[reflection.name] : []
       end
+
+      def full_errors_on_association
+        reflection ? object.full_messages_for(reflection.name) : []
+      end
+
+      def has_custom_error?
+        options[:error].is_a?(String)
+      end
     end
   end
 end

data/lib/simple_form/components/hints.rb

@@ -2,14 +2,14 @@ module SimpleForm
   module Components
     # Needs to be enabled in order to do automatic lookups.
     module Hints
-      def hint
+      def hint(wrapper_options = nil)
         @hint ||= begin
           hint = options[:hint]
 
           if hint.is_a?(String)
             html_escape(hint)
           else
-            content = translate(:hints)
+            content = translate_from_namespace(:hints)
             content.html_safe if content
           end
         end

data/lib/simple_form/components/html5.rb

@@ -5,7 +5,7 @@ module SimpleForm
         @html5 = false
       end
 
-      def html5
+      def html5(wrapper_options = nil)
         @html5 = true
         if has_required?
           input_html_options[:required] = true

data/lib/simple_form/components/label_input.rb

@@ -7,8 +7,26 @@ module SimpleForm
         include SimpleForm::Components::Labels
       end
 
-      def label_input
-        options[:label] == false ? input : (label + input)
+      def label_input(wrapper_options = nil)
+        if options[:label] == false
+          deprecated_component(:input, wrapper_options)
+        else
+          deprecated_component(:label, wrapper_options) + deprecated_component(:input, wrapper_options)
+        end
+      end
+
+      private
+
+      def deprecated_component(namespace, wrapper_options)
+        method = method(namespace)
+
+        if method.arity == 0
+          ActiveSupport::Deprecation.warn(SimpleForm::CUSTOM_INPUT_DEPRECATION_WARN % { name: namespace })
+
+          method.call
+        else
+          method.call(wrapper_options)
+        end
       end
     end
   end

data/lib/simple_form/components/labels.rb

@@ -21,16 +21,19 @@ module SimpleForm
         end
       end
 
-      def label
+      def label(wrapper_options = nil)
+        label_options = merge_wrapper_options(label_html_options, wrapper_options)
+
         if generate_label_for_attribute?
-          @builder.label(label_target, label_text, label_html_options)
+          @builder.label(label_target, label_text, label_options)
         else
-          template.label_tag(nil, label_text, label_html_options)
+          template.label_tag(nil, label_text, label_options)
         end
       end
 
       def label_text
-        SimpleForm.label_text.call(html_escape(raw_label_text), required_label_text).strip.html_safe
+        label_text = options[:label_text] || SimpleForm.label_text
+        label_text.call(html_escape(raw_label_text), required_label_text, options[:label].present?).strip.html_safe
       end
 
       def label_target
@@ -46,6 +49,7 @@ module SimpleForm
         if options.key?(:input_html) && options[:input_html].key?(:id)
           label_options[:for] = options[:input_html][:id]
         end
+
         label_options
       end
 
@@ -62,7 +66,7 @@ module SimpleForm
 
       # First check labels translation and then human attribute name.
       def label_translation #:nodoc:
-        if SimpleForm.translate_labels && (translated_label = translate(:labels))
+        if SimpleForm.translate_labels && (translated_label = translate_from_namespace(:labels))
           translated_label
         elsif object.class.respond_to?(:human_attribute_name)
           object.class.human_attribute_name(reflection_or_attribute_name.to_s)

data/lib/simple_form/components/maxlength.rb

@@ -2,7 +2,7 @@ module SimpleForm
   module Components
     # Needs to be enabled in order to do automatic lookups.
     module Maxlength
-      def maxlength
+      def maxlength(wrapper_options = nil)
         input_html_options[:maxlength] ||= maximum_length_from_validation || limit
         nil
       end

data/lib/simple_form/components/min_max.rb

@@ -1,7 +1,7 @@
 module SimpleForm
   module Components
     module MinMax
-      def min_max
+      def min_max(wrapper_options = nil)
         if numeric_validator = find_numericality_validator
           validator_options = numeric_validator.options
           input_html_options[:min] ||= minimum_value(validator_options)

data/lib/simple_form/components/pattern.rb

@@ -2,7 +2,7 @@ module SimpleForm
   module Components
     # Needs to be enabled in order to do automatic lookups.
     module Pattern
-      def pattern
+      def pattern(wrapper_options = nil)
         input_html_options[:pattern] ||= pattern_source
         nil
       end

data/lib/simple_form/components/placeholders.rb

@@ -2,14 +2,14 @@ module SimpleForm
   module Components
     # Needs to be enabled in order to do automatic lookups.
     module Placeholders
-      def placeholder
+      def placeholder(wrapper_options = nil)
         input_html_options[:placeholder] ||= placeholder_text
         nil
       end
 
       def placeholder_text
         placeholder = options[:placeholder]
-        placeholder.is_a?(String) ? placeholder : translate(:placeholders)
+        placeholder.is_a?(String) ? placeholder : translate_from_namespace(:placeholders)
       end
     end
   end

data/lib/simple_form/components/readonly.rb

@@ -2,7 +2,7 @@ module SimpleForm
   module Components
     # Needs to be enabled in order to do automatic lookups.
     module Readonly
-      def readonly
+      def readonly(wrapper_options = nil)
         if readonly_attribute? && !has_readonly?
           input_html_options[:readonly] ||= true
           input_html_classes << :readonly

data/lib/simple_form/form_builder.rb

@@ -8,8 +8,8 @@ module SimpleForm
 
     # When action is create or update, we still should use new and edit
     ACTIONS = {
-      create: :new,
-      update: :edit
+      'create' => 'new',
+      'update' => 'edit'
     }
 
     ATTRIBUTE_COMPONENTS = [:html5, :min_max, :maxlength, :placeholder, :pattern, :readonly]
@@ -106,18 +106,13 @@ module SimpleForm
     # Some inputs, as :time_zone and :country accepts a :priority option. If none is
     # given SimpleForm.time_zone_priority and SimpleForm.country_priority are used respectively.
     #
-    def input(attribute_name, options={}, &block)
+    def input(attribute_name, options = {}, &block)
       options = @defaults.deep_dup.deep_merge(options) if @defaults
-      input = find_input(attribute_name, options, &block)
 
-      chosen =
-        if name = options[:wrapper] || find_wrapper_mapping(input.input_type)
-          name.respond_to?(:render) ? name : SimpleForm.wrapper(name)
-        else
-          wrapper
-        end
+      input   = find_input(attribute_name, options, &block)
+      wrapper = find_wrapper(input.input_type, options)
 
-      chosen.render input
+      wrapper.render input
     end
     alias :attribute :input
 
@@ -135,12 +130,17 @@ module SimpleForm
     #     <input class="string required" id="user_name" maxlength="100"
     #        name="user[name]" type="text" value="Carlos" />
     #
-    def input_field(attribute_name, options={})
+    def input_field(attribute_name, options = {})
       options = options.dup
-      options[:input_html] = options.except(:as, :collection, :label_method, :value_method, *ATTRIBUTE_COMPONENTS)
+      options[:input_html] = options.except(:as, :boolean_style, :collection, :label_method, :value_method, *ATTRIBUTE_COMPONENTS)
       options = @defaults.deep_dup.deep_merge(options) if @defaults
 
-      SimpleForm::Wrappers::Root.new(ATTRIBUTE_COMPONENTS + [:input], wrapper: false).render find_input(attribute_name, options)
+      input      = find_input(attribute_name, options)
+      wrapper    = find_wrapper(input.input_type, options)
+      components = (wrapper.components.map(&:namespace) & ATTRIBUTE_COMPONENTS) + [:input]
+      components = components.map { |component| SimpleForm::Wrappers::Leaf.new(component) }
+
+      SimpleForm::Wrappers::Root.new(components, wrapper.options.merge(wrapper: false)).render input
     end
 
     # Helper for dealing with association selects/radios, generating the
@@ -171,7 +171,7 @@ module SimpleForm
     #
     # Please note that the association helper is currently only tested with Active Record. Depending on the ORM you are using your mileage may vary.
     #
-    def association(association, options={}, &block)
+    def association(association, options = {}, &block)
       options = options.dup
 
       return simple_fields_for(*[association,
@@ -183,31 +183,9 @@ module SimpleForm
       raise "Association #{association.inspect} not found" unless reflection
 
       options[:as] ||= :select
-      options[:collection] ||= options.fetch(:collection) {
-        conditions = reflection.options[:conditions]
-        conditions = conditions.call if conditions.respond_to?(:call)
-        reflection.klass.where(conditions).order(reflection.options[:order])
-      }
-
-      attribute = case reflection.macro
-        when :belongs_to
-          (reflection.respond_to?(:options) && reflection.options[:foreign_key]) || :"#{reflection.name}_id"
-        when :has_one
-          raise ArgumentError, ":has_one associations are not supported by f.association"
-        else
-          if options[:as] == :select
-            html_options = options[:input_html] ||= {}
-            html_options[:multiple] = true unless html_options.key?(:multiple)
-          end
-
-          # Force the association to be preloaded for performance.
-          if options[:preload] != false && object.respond_to?(association)
-            target = object.send(association)
-            target.to_a if target.respond_to?(:to_a)
-          end
-
-          :"#{reflection.name.to_s.singularize}_ids"
-      end
+      options[:collection] ||= fetch_association_collection(reflection, options)
+
+      attribute = build_association_attribute(reflection, association, options)
 
       input(attribute, options.merge(reflection: reflection))
     end
@@ -242,7 +220,7 @@ module SimpleForm
     #    f.error :name
     #    f.error :name, id: "cool_error"
     #
-    def error(attribute_name, options={})
+    def error(attribute_name, options = {})
       options = options.dup
 
       options[:error_html] = options.except(:error_tag, :error_prefix, :error_method)
@@ -259,7 +237,7 @@ module SimpleForm
     #
     #    f.full_error :token #=> <span class="error">Token is invalid</span>
     #
-    def full_error(attribute_name, options={})
+    def full_error(attribute_name, options = {})
       options = options.dup
 
       options[:error_prefix] ||= if object.class.respond_to?(:human_attribute_name)
@@ -281,7 +259,7 @@ module SimpleForm
     #    f.hint :name, id: "cool_hint"
     #    f.hint "Don't forget to accept this"
     #
-    def hint(attribute_name, options={})
+    def hint(attribute_name, options = {})
       options = options.dup
 
       options[:hint_html] = options.except(:hint_tag, :hint)
@@ -332,7 +310,7 @@ module SimpleForm
     #    f.error_notification message: 'Something went wrong'
     #    f.error_notification id: 'user_error_message', class: 'form_error'
     #
-    def error_notification(options={})
+    def error_notification(options = {})
       SimpleForm::ErrorNotification.new(self, options).render
     end
 
@@ -464,15 +442,56 @@ module SimpleForm
       @lookup_action ||= begin
         action = template.controller && template.controller.action_name
         return unless action
-        action = action.to_sym
+        action = action.to_s
         ACTIONS[action] || action
       end
     end
 
     private
 
+    def fetch_association_collection(reflection, options)
+      options.fetch(:collection) do
+        relation = reflection.klass.all
+
+        if reflection.respond_to?(:scope) && reflection.scope
+          relation = reflection.klass.instance_exec(&reflection.scope)
+        else
+          order = reflection.options[:order]
+          conditions = reflection.options[:conditions]
+          conditions = object.instance_exec(&conditions) if conditions.respond_to?(:call)
+
+          relation = relation.where(conditions)
+          relation = relation.order(order) if relation.respond_to?(:order)
+        end
+
+        relation
+      end
+    end
+
+    def build_association_attribute(reflection, association, options)
+      case reflection.macro
+      when :belongs_to
+        (reflection.respond_to?(:options) && reflection.options[:foreign_key]) || :"#{reflection.name}_id"
+      when :has_one
+        raise ArgumentError, ":has_one associations are not supported by f.association"
+      else
+        if options[:as] == :select
+          html_options = options[:input_html] ||= {}
+          html_options[:multiple] = true unless html_options.key?(:multiple)
+        end
+
+        # Force the association to be preloaded for performance.
+        if options[:preload] != false && object.respond_to?(association)
+          target = object.send(association)
+          target.to_a if target.respond_to?(:to_a)
+        end
+
+        :"#{reflection.name.to_s.singularize}_ids"
+      end
+    end
+
     # Find an input based on the attribute name.
-    def find_input(attribute_name, options={}, &block) #:nodoc:
+    def find_input(attribute_name, options = {}, &block)
       column     = find_attribute_column(attribute_name)
       input_type = default_input_type(attribute_name, column, options)
 
@@ -486,7 +505,7 @@ module SimpleForm
     # Attempt to guess the better input type given the defined options. By
     # default alwayls fallback to the user :as option, or to a :select when a
     # collection is given.
-    def default_input_type(attribute_name, column, options) #:nodoc:
+    def default_input_type(attribute_name, column, options)
       return options[:as].to_sym if options[:as]
       return :select             if options[:collection]
       custom_type = find_custom_type(attribute_name.to_s) and return custom_type
@@ -511,24 +530,24 @@ module SimpleForm
       end
     end
 
-    def find_custom_type(attribute_name) #:nodoc:
+    def find_custom_type(attribute_name)
       SimpleForm.input_mappings.find { |match, type|
         attribute_name =~ match
       }.try(:last) if SimpleForm.input_mappings
     end
 
-    def file_method?(attribute_name) #:nodoc:
+    def file_method?(attribute_name)
       file = @object.send(attribute_name) if @object.respond_to?(attribute_name)
       file && SimpleForm.file_methods.any? { |m| file.respond_to?(m) }
     end
 
-    def find_attribute_column(attribute_name) #:nodoc:
+    def find_attribute_column(attribute_name)
       if @object.respond_to?(:column_for_attribute)
         @object.column_for_attribute(attribute_name)
       end
     end
 
-    def find_association_reflection(association) #:nodoc:
+    def find_association_reflection(association)
       if @object.class.respond_to?(:reflect_on_association)
         @object.class.reflect_on_association(association)
       end
@@ -541,7 +560,7 @@ module SimpleForm
     #    b) Or use the found mapping
     # 2) If not, fallbacks to #{input_type}Input
     # 3) If not, fallbacks to SimpleForm::Inputs::#{input_type}Input
-    def find_mapping(input_type) #:nodoc:
+    def find_mapping(input_type)
       discovery_cache[input_type] ||=
         if mapping = self.class.mappings[input_type]
           mapping_override(mapping) || mapping
@@ -552,13 +571,29 @@ module SimpleForm
         end
     end
 
-    def find_wrapper_mapping(input_type) #:nodoc:
-      SimpleForm.wrapper_mappings && SimpleForm.wrapper_mappings[input_type]
+    # Attempts to find a wrapper mapping. It follows the following rules:
+    #
+    # 1) It tries to find a wrapper for the current form
+    # 2) If not, it tries to find a config
+    def find_wrapper_mapping(input_type)
+      if options[:wrapper_mappings] && options[:wrapper_mappings][input_type]
+        options[:wrapper_mappings][input_type]
+      else
+        SimpleForm.wrapper_mappings && SimpleForm.wrapper_mappings[input_type]
+      end
+    end
+
+    def find_wrapper(input_type, options)
+      if name = options[:wrapper] || find_wrapper_mapping(input_type)
+        name.respond_to?(:render) ? name : SimpleForm.wrapper(name)
+      else
+        wrapper
+      end
     end
 
     # If cache_discovery is enabled, use the class level cache that persists
     # between requests, otherwise use the instance one.
-    def discovery_cache #:nodoc:
+    def discovery_cache
       if SimpleForm.cache_discovery
         self.class.discovery_cache
       else
@@ -566,14 +601,14 @@ module SimpleForm
       end
     end
 
-    def mapping_override(klass) #:nodoc:
+    def mapping_override(klass)
       name = klass.name
       if name =~ /^SimpleForm::Inputs/
         attempt_mapping name.split("::").last, Object
       end
     end
 
-    def attempt_mapping(mapping, at) #:nodoc:
+    def attempt_mapping(mapping, at)
       return if SimpleForm.inputs_discovery == false && at == Object
 
       begin