simple_form 3.0.4 → 3.1.0.rc1

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,14 +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={})
-      components = (wrapper.components & ATTRIBUTE_COMPONENTS)
-
+    def input_field(attribute_name, options = {})
       options = options.dup
-      options[:input_html] = options.except(:as, :collection, :label_method, :value_method, *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(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
@@ -173,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,
@@ -185,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
@@ -244,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)
@@ -261,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)
@@ -283,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)
@@ -334,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
 
@@ -466,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)
 
@@ -488,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
@@ -513,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
@@ -543,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
@@ -554,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
@@ -568,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

data/lib/simple_form/helpers.rb

@@ -3,10 +3,10 @@ module SimpleForm
   # For instance, disabled cannot be turned on automatically, it requires the
   # user to explicitly pass the option disabled: true so it may work.
   module Helpers
-    autoload :Autofocus,    'simple_form/helpers/autofocus'
-    autoload :Disabled,     'simple_form/helpers/disabled'
-    autoload :Readonly,     'simple_form/helpers/readonly'
-    autoload :Required,     'simple_form/helpers/required'
-    autoload :Validators,   'simple_form/helpers/validators'
+    autoload :Autofocus,  'simple_form/helpers/autofocus'
+    autoload :Disabled,   'simple_form/helpers/disabled'
+    autoload :Readonly,   'simple_form/helpers/readonly'
+    autoload :Required,   'simple_form/helpers/required'
+    autoload :Validators, 'simple_form/helpers/validators'
   end
 end

data/lib/simple_form/inputs/base.rb

@@ -1,10 +1,12 @@
 require 'simple_form/i18n_cache'
 require 'active_support/core_ext/string/output_safety'
+require 'action_view/helpers'
 
 module SimpleForm
   module Inputs
     class Base
       include ERB::Util
+      include ActionView::Helpers::TranslationHelper
 
       extend I18nCache
 
@@ -45,7 +47,7 @@ module SimpleForm
       end
 
       # Always enabled.
-      enable :hint, :error
+      enable :hint
 
       # Usually disabled, needs to be enabled explicitly passing true as option.
       disable :maxlength, :placeholder, :pattern, :min_max
@@ -53,14 +55,14 @@ module SimpleForm
       def initialize(builder, attribute_name, column, input_type, options = {})
         super
 
-        options             = options.dup
-        @builder            = builder
-        @attribute_name     = attribute_name
-        @column             = column
-        @input_type         = input_type
-        @reflection         = options.delete(:reflection)
-        @options            = options.reverse_merge!(self.class.default_options)
-        @required           = calculate_required
+        options         = options.dup
+        @builder        = builder
+        @attribute_name = attribute_name
+        @column         = column
+        @input_type     = input_type
+        @reflection     = options.delete(:reflection)
+        @options        = options.reverse_merge!(self.class.default_options)
+        @required       = calculate_required
 
         # Notice that html_options_for receives a reference to input_html_classes.
         # This means that classes added dynamically to input_html_classes will
@@ -79,7 +81,7 @@ module SimpleForm
         end
       end
 
-      def input
+      def input(wrapper_options = nil)
         raise NotImplementedError
       end
 
@@ -167,7 +169,7 @@ module SimpleForm
       #            email: 'E-mail.'
       #
       #  Take a look at our locale example file.
-      def translate(namespace, default='')
+      def translate_from_namespace(namespace, default = '')
         model_names = lookup_model_names.dup
         lookups     = []
 
@@ -176,13 +178,33 @@ module SimpleForm
           model_names.shift
 
           lookups << :"#{joined_model_names}.#{lookup_action}.#{reflection_or_attribute_name}"
+          lookups << :"#{joined_model_names}.#{lookup_action}.#{reflection_or_attribute_name}_html"
           lookups << :"#{joined_model_names}.#{reflection_or_attribute_name}"
+          lookups << :"#{joined_model_names}.#{reflection_or_attribute_name}_html"
         end
         lookups << :"defaults.#{lookup_action}.#{reflection_or_attribute_name}"
+        lookups << :"defaults.#{lookup_action}.#{reflection_or_attribute_name}_html"
         lookups << :"defaults.#{reflection_or_attribute_name}"
+        lookups << :"defaults.#{reflection_or_attribute_name}_html"
         lookups << default
 
-        I18n.t(lookups.shift, scope: :"simple_form.#{namespace}", default: lookups).presence
+        t(lookups.shift, scope: :"#{i18n_scope}.#{namespace}", default: lookups).presence
+      end
+
+      def merge_wrapper_options(options, wrapper_options)
+        if wrapper_options
+          options.merge(wrapper_options) do |_, oldval, newval|
+            if Array === oldval
+              oldval + Array(newval)
+            end
+          end
+        else
+          options
+        end
+      end
+
+      def i18n_scope
+        SimpleForm.i18n_scope
       end
     end
   end