simple_form 1.2.0 → 1.4.0

data/lib/simple_form/form_builder.rb

@@ -1,17 +1,21 @@
 module SimpleForm
   class FormBuilder < ActionView::Helpers::FormBuilder
-    attr_reader :template, :object_name, :object, :attribute_name, :column,
-                :reflection, :input_type, :options
+    attr_reader :template, :object_name, :object
 
     extend MapType
     include SimpleForm::Inputs
 
-    map_type :boolean, :password, :text, :file,   :to => SimpleForm::Inputs::MappingInput
-    map_type :string, :email, :url,               :to => SimpleForm::Inputs::StringInput
-    map_type :integer, :decimal, :float,          :to => SimpleForm::Inputs::NumericInput
-    map_type :select, :radio, :check_boxes,       :to => SimpleForm::Inputs::CollectionInput
-    map_type :date, :time, :datetime,             :to => SimpleForm::Inputs::DateTimeInput
-    map_type :country, :time_zone,                :to => SimpleForm::Inputs::PriorityInput
+    map_type :text, :file,                                    :to => SimpleForm::Inputs::MappingInput
+    map_type :string, :password, :email, :search, :tel, :url, :to => SimpleForm::Inputs::StringInput
+    map_type :integer, :decimal, :float,                      :to => SimpleForm::Inputs::NumericInput
+    map_type :select, :radio, :check_boxes,                   :to => SimpleForm::Inputs::CollectionInput
+    map_type :date, :time, :datetime,                         :to => SimpleForm::Inputs::DateTimeInput
+    map_type :country, :time_zone,                            :to => SimpleForm::Inputs::PriorityInput
+    map_type :boolean,                                        :to => SimpleForm::Inputs::BooleanInput
+
+    def self.discovery_cache
+      @discovery_cache ||= {}
+    end
 
     # Basic input helper, combines all components in the stack to generate
     # input html based on options the user define and some guesses through
@@ -79,18 +83,37 @@ module SimpleForm
     # given SimpleForm.time_zone_priority and SimpleForm.country_priority are used respectivelly.
     #
     def input(attribute_name, options={}, &block)
-      define_simple_form_attributes(attribute_name, options)
+      column     = find_attribute_column(attribute_name)
+      input_type = default_input_type(attribute_name, column, options)
 
       if block_given?
-        SimpleForm::Inputs::BlockInput.new(self, block).render
+        SimpleForm::Inputs::BlockInput.new(self, attribute_name, column, input_type, options, &block).render
       else
-        klass = self.class.mappings[input_type] ||
-          self.class.const_get(:"#{input_type.to_s.camelize}Input")
-        klass.new(self).render
+        find_mapping(input_type).new(self, attribute_name, column, input_type, options).render
       end
     end
     alias :attribute :input
 
+    # Creates a input tag for the given attribute. All the given options
+    # are sent as :input_html.
+    #
+    # == Examples
+    #
+    #   simple_form_for @user do |f|
+    #     f.input_field :name
+    #   end
+    #
+    # This is the output html (only the input portion, not the form):
+    #
+    #     <input class="string required" id="user_name" maxlength="100"
+    #        name="user[name]" size="100" type="text" value="Carlos" />
+    #
+    def input_field(attribute_name, options={})
+      options[:input_html] = options.except(:as)
+      options.merge!(:components => [:input], :wrapper => false)
+      input(attribute_name, options)
+    end
+
     # Helper for dealing with association selects/radios, generating the
     # collection automatically. It's just a wrapper to input, so all options
     # supported in input are also supported by association. Some extra options
@@ -123,30 +146,34 @@ module SimpleForm
 
       raise ArgumentError, "Association cannot be used in forms not associated with an object" unless @object
 
+      reflection = find_association_reflection(association)
+      raise "Association #{association.inspect} not found" unless reflection
+
       options[:as] ||= :select
-      @reflection = find_association_reflection(association)
-      raise "Association #{association.inspect} not found" unless @reflection
+      options[:collection] ||= reflection.klass.all(reflection.options.slice(:conditions, :order))
 
-      case @reflection.macro
+      attribute = case reflection.macro
         when :belongs_to
-          attribute = @reflection.options[:foreign_key] || :"#{@reflection.name}_id"
+          reflection.options[:foreign_key] || :"#{reflection.name}_id"
         when :has_one
-          raise ":has_one association are not supported by f.association"
+          raise ":has_one associations are not supported by f.association"
         else
-          attribute = :"#{@reflection.name.to_s.singularize}_ids"
-
           if options[:as] == :select
             html_options = options[:input_html] ||= {}
             html_options[:size]   ||= 5
             html_options[:multiple] = true unless html_options.key?(:multiple)
           end
-      end
 
-      options[:collection] ||= @reflection.klass.all(
-        :conditions => @reflection.options[:conditions], :order => @reflection.options[:order]
-      )
+          # 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
 
-      returning(input(attribute, options)) { @reflection = nil }
+      input(attribute, options.merge(:reflection => reflection))
     end
 
     # Creates a button:
@@ -158,8 +185,11 @@ module SimpleForm
     # It just acts as a proxy to method name given.
     #
     def button(type, *args, &block)
-      if respond_to?(:"#{type}_button")
-        send(:"#{type}_button", *args, &block)
+      options = args.extract_options!
+      options[:class] = "button #{options[:class]}".strip
+      args << options
+      if respond_to?("#{type}_button")
+        send("#{type}_button", *args, &block)
       else
         send(type, *args, &block)
       end
@@ -174,8 +204,27 @@ module SimpleForm
     #    f.error :name, :id => "cool_error"
     #
     def error(attribute_name, options={})
-      define_simple_form_attributes(attribute_name, :error_html => options)
-      SimpleForm::Inputs::Base.new(self).error
+      options[:error_html] = options.dup
+      column      = find_attribute_column(attribute_name)
+      input_type  = default_input_type(attribute_name, column, options)
+      SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options).error
+    end
+
+    # Return the error but also considering its name. This is used
+    # when errors for a hidden field need to be shown.
+    #
+    # == Examples
+    #
+    #    f.full_error :token #=> <span class="error">Token is invalid</span>
+    #
+    def full_error(attribute_name, options={})
+      options[:error_prefix] ||= if object.class.respond_to?(:human_attribute_name)
+        object.class.human_attribute_name(attribute_name.to_s)
+      else
+        attribute_name.to_s.humanize
+      end
+
+      error(attribute_name, options)
     end
 
     # Creates a hint tag for the given attribute. Accepts a symbol indicating
@@ -189,9 +238,15 @@ module SimpleForm
     #    f.hint "Don't forget to accept this"
     #
     def hint(attribute_name, options={})
-      attribute_name, options[:hint] = nil, attribute_name if attribute_name.is_a?(String)
-      define_simple_form_attributes(attribute_name, :hint => options.delete(:hint), :hint_html => options)
-      SimpleForm::Inputs::Base.new(self).hint
+      options[:hint_html] = options.dup
+      if attribute_name.is_a?(String)
+        options[:hint] = attribute_name
+        attribute_name, column, input_type = nil, nil, nil
+      else
+        column      = find_attribute_column(attribute_name)
+        input_type  = default_input_type(attribute_name, column, options)
+      end
+      SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options).hint
     end
 
     # Creates a default label tag for the given attribute. You can give a label
@@ -210,65 +265,125 @@ module SimpleForm
     def label(attribute_name, *args)
       return super if args.first.is_a?(String)
       options = args.extract_options!
-      define_simple_form_attributes(attribute_name, :label => options.delete(:label),
-        :label_html => options, :required => options.delete(:required))
-      SimpleForm::Inputs::Base.new(self).label
+      options[:label_html] = options.dup
+      options[:label]      = options.delete(:label)
+      options[:required]   = options.delete(:required)
+      column      = find_attribute_column(attribute_name)
+      input_type  = default_input_type(attribute_name, column, options)
+      SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options).label
     end
 
-  private
-
-    # Setup default simple form attributes.
-    def define_simple_form_attributes(attribute_name, options) #:nodoc:
-      @options = options
-
-      if @attribute_name = attribute_name
-        @column     = find_attribute_column
-        @input_type = default_input_type
-      end
+    # Creates an error notification message that only appears when the form object
+    # has some error. You can give a specific message with the :message option,
+    # otherwise it will look for a message using I18n. All other options given are
+    # passed straight as html options to the html tag.
+    #
+    # == Examples
+    #
+    #    f.error_notification
+    #    f.error_notification :message => 'Something went wrong'
+    #    f.error_notification :id => 'user_error_message', :class => 'form_error'
+    #
+    def error_notification(options={})
+      SimpleForm::ErrorNotification.new(self, options).render
     end
 
+  private
+
     # 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 #:nodoc:
-      return @options[:as].to_sym if @options[:as]
-      return :select              if @options[:collection]
-
-      input_type = @column.try(:type)
+    def default_input_type(attribute_name, column, options) #:nodoc:
+      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
 
+      input_type = column.try(:type)
       case input_type
-        when :timestamp
-          :datetime
-        when :string, nil
-          match = case @attribute_name.to_s
-            when /password/  then :password
-            when /time_zone/ then :time_zone
-            when /country/   then :country
-            when /email/     then :email
-            when /url/       then :url
-          end
-
-          match || input_type || file_method? || :string
+      when :timestamp
+        :datetime
+      when :string, nil
+        case attribute_name.to_s
+        when /password/  then :password
+        when /time_zone/ then :time_zone
+        when /country/   then :country
+        when /email/     then :email
+        when /phone/     then :tel
+        when /url/       then :url
         else
-          input_type
+          file_method?(attribute_name) ? :file : (input_type || :string)
+        end
+      else
+        input_type
       end
     end
 
-    # Checks if attribute is a file_method.
-    def file_method? #:nodoc:
-      file = @object.send(@attribute_name) if @object.respond_to?(@attribute_name)
-      :file if file && SimpleForm.file_methods.any? { |m| file.respond_to?(m) }
+    def find_custom_type(attribute_name) #:nodoc:
+      SimpleForm.input_mappings.find { |match, type|
+        attribute_name =~ match
+      }.try(:last) if SimpleForm.input_mappings
+    end
+
+    def file_method?(attribute_name) #:nodoc:
+      file = @object.send(attribute_name) if @object.respond_to?(attribute_name)
+      file && SimpleForm.file_methods.any? { |m| file.respond_to?(m) }
     end
 
-    # Finds the database column for the given attribute
-    def find_attribute_column #:nodoc:
-      @object.column_for_attribute(@attribute_name) if @object.respond_to?(:column_for_attribute)
+    def find_attribute_column(attribute_name) #:nodoc:
+      if @object.respond_to?(:column_for_attribute)
+        @object.column_for_attribute(attribute_name)
+      end
     end
 
-    # Find reflection related to association
     def find_association_reflection(association) #:nodoc:
-      @object.class.reflect_on_association(association) if @object.class.respond_to?(:reflect_on_association)
+      if @object.class.respond_to?(:reflect_on_association)
+        @object.class.reflect_on_association(association)
+      end
+    end
+
+    # Attempts to find a mapping. It follows the following rules:
+    #
+    # 1) It tries to find a registered mapping, if succeeds:
+    #    a) Try to find an alternative with the same name in the Object scope
+    #    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:
+      discovery_cache[input_type] ||=
+        if mapping = self.class.mappings[input_type]
+          mapping_override(mapping) || mapping
+        else
+          camelized = "#{input_type.to_s.camelize}Input"
+          attempt_mapping(camelized, Object) || attempt_mapping(camelized, self.class) ||
+            raise("No input found for #{input_type}")
+        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:
+      if SimpleForm.cache_discovery
+        self.class.discovery_cache
+      else
+        @discovery_cache ||= {}
+      end
+    end
+
+    def mapping_override(klass) #:nodoc:
+      name = klass.name
+      if name =~ /^SimpleForm::Inputs/
+        attempt_mapping name.split("::").last, Object
+      end
     end
 
+    def attempt_mapping(mapping, at) #:nodoc:
+      return if SimpleForm.inputs_discovery == false && at == Object
+
+      begin
+        at.const_get(mapping)
+      rescue NameError => e
+        e.message =~ /#{mapping}$/ ? nil : raise
+      end
+    end
   end
 end

data/lib/simple_form/has_errors.rb

@@ -0,0 +1,14 @@
+module SimpleForm
+  module HasErrors
+
+  protected
+
+    def errors
+      object.errors
+    end
+
+    def has_errors?
+      object && object.respond_to?(:errors) && errors.present?
+    end
+  end
+end

data/lib/simple_form/inputs/base.rb

@@ -11,14 +11,27 @@ module SimpleForm
 
       include SimpleForm::Components::Errors
       include SimpleForm::Components::Hints
-      include SimpleForm::Components::Labels
+      include SimpleForm::Components::LabelInput
+      include SimpleForm::Components::Placeholders
       include SimpleForm::Components::Wrapper
 
-      delegate :template, :object, :object_name, :attribute_name, :column,
-               :reflection, :input_type, :options, :to => :@builder
-
-      def initialize(builder)
-        @builder = builder
+      attr_reader :attribute_name, :column, :input_type, :reflection,
+                  :options, :input_html_options
+
+      delegate :template, :object, :object_name, :to => :@builder
+
+      def initialize(builder, attribute_name, column, input_type, options = {})
+        @builder            = builder
+        @attribute_name     = attribute_name
+        @column             = column
+        @input_type         = input_type
+        @reflection         = options.delete(:reflection)
+        @options            = options
+        @input_html_options = html_options_for(:input, input_html_classes).tap do |o|
+          o[:required]  = true if has_required? # Don't make this conditional on HTML5 here, because we want the CSS class to be set
+          o[:disabled]  = true if disabled?
+          o[:autofocus] = true if has_autofocus? && SimpleForm.html5
+        end
       end
 
       def input
@@ -29,35 +42,61 @@ module SimpleForm
         options
       end
 
-      def input_html_options
-        html_options_for(:input, input_type, required_class)
+      def input_html_classes
+        [input_type, required_class]
       end
 
       def render
-        content = components_list.map do |component|
+        content = "".html_safe
+        components_list.each do |component|
           next if options[component] == false
-          send(component)
+          rendered = send(component)
+          content.safe_concat rendered.to_s if rendered
         end
-        content.compact!
-        wrap(content.join.html_safe)
+        wrap(content)
       end
 
     protected
 
       def components_list
-        SimpleForm.components
+        options[:components] || SimpleForm.components
       end
 
       def attribute_required?
-        if options.key?(:required)
+        if !options[:required].nil?
           options[:required]
-        elsif defined?(object.class.validators_on)
-          object.class.validators_on(attribute_name).any? { |v| v.kind == :presence }
+        elsif has_validators?
+          (attribute_validators + reflection_validators).any? { |v| v.kind == :presence }
         else
-          true
+          attribute_required_by_default?
         end
       end
 
+      # Whether this input is valid for HTML 5 required attribute.
+      def has_required?
+        attribute_required? && SimpleForm.html5
+      end
+
+      def has_autofocus?
+        options[:autofocus]
+      end
+
+      def has_validators?
+        attribute_name && object.class.respond_to?(:validators_on)
+      end
+
+      def attribute_validators
+        object.class.validators_on(attribute_name)
+      end
+
+      def reflection_validators
+        reflection ? object.class.validators_on(reflection.name) : []
+      end
+
+      def attribute_required_by_default?
+        SimpleForm.required_by_default
+      end
+
       def required_class
         attribute_required? ? :required : :optional
       end
@@ -68,12 +107,16 @@ module SimpleForm
       end
 
       # Retrieve options for the given namespace from the options hash
-      def html_options_for(namespace, *extra)
+      def html_options_for(namespace, extra)
         html_options = options[:"#{namespace}_html"] || {}
         html_options[:class] = (extra << html_options[:class]).join(' ').strip if extra.present?
         html_options
       end
 
+      def disabled?
+        options[:disabled]
+      end
+
       # Lookup translations for the given namespace using I18n, based on object name,
       # actual action and attribute name. Lookup priority as follows:
       #
@@ -87,6 +130,15 @@ module SimpleForm
       #  Action is the action being rendered, usually :new or :edit.
       #  And attribute is the attribute itself, :name for example.
       #
+      #  The lookup for nested attributes is also done in a nested format using
+      #  both model and nested object names, such as follow:
+      #
+      #   simple_form.{namespace}.{model}.{nested}.{action}.{attribute}
+      #   simple_form.{namespace}.{model}.{nested}.{attribute}
+      #   simple_form.{namespace}.{nested}.{action}.{attribute}
+      #   simple_form.{namespace}.{nested}.{attribute}
+      #   simple_form.{namespace}.{attribute}
+      #
       #  Example:
       #
       #    simple_form:
@@ -99,19 +151,49 @@ module SimpleForm
       #
       #  Take a look at our locale example file.
       def translate(namespace, default='')
-        lookups = []
-        lookups << :"#{object_name}.#{lookup_action}.#{reflection_or_attribute_name}"
-        lookups << :"#{object_name}.#{reflection_or_attribute_name}"
+        return nil unless SimpleForm.translate
+
+        model_names = lookup_model_names
+        lookups     = []
+
+        while !model_names.empty?
+          joined_model_names = model_names.join(".")
+          model_names.shift
+
+          lookups << :"#{joined_model_names}.#{lookup_action}.#{reflection_or_attribute_name}"
+          lookups << :"#{joined_model_names}.#{reflection_or_attribute_name}"
+        end
         lookups << :"#{reflection_or_attribute_name}"
         lookups << default
-        I18n.t(lookups.shift, :scope => :"simple_form.#{namespace}", :default => lookups)
+
+        I18n.t(lookups.shift, :scope => :"simple_form.#{namespace}", :default => lookups).presence
+      end
+
+      # Extract the model names from the object_name mess.
+      #
+      # Example:
+      #
+      # route[blocks_attributes][0][blocks_learning_object_attributes][1][foo_attributes]
+      # ["route", "blocks", "blocks_learning_object", "foo"]
+      #
+      def lookup_model_names
+        object_name.to_s.scan(/([a-zA-Z_]+)/).flatten.map do |x|
+          x.gsub('_attributes', '')
+        end
       end
 
       # The action to be used in lookup.
       def lookup_action
-        action = template.controller.action_name.to_sym
+        action = template.controller.action_name
+        return unless action
+        action = action.to_sym
         ACTIONS[action] || action
       end
+
+      def input_method
+        self.class.mappings[input_type] or
+          raise("Could not find method for #{input_type.inspect}")
+      end
     end
   end
-end
+end

data/lib/simple_form/inputs/block_input.rb

@@ -1,8 +1,9 @@
 module SimpleForm
   module Inputs
     class BlockInput < Base
-      def initialize(builder, block)
-        @builder, @block = builder, block
+      def initialize(*args, &block)
+        super
+        @block = block
       end
 
       def input

data/lib/simple_form/inputs/boolean_input.rb

@@ -0,0 +1,22 @@
+module SimpleForm
+  module Inputs
+    class BooleanInput < Base
+      def input
+        @builder.check_box(attribute_name, input_html_options)
+      end
+
+      def label_input
+        input + (options[:label] == false ? "" : label)
+      end
+
+    protected
+
+      # Booleans are not required by default because in most of the cases
+      # it makes no sense marking them as required. The only exception is
+      # Terms of Use usually presented at most sites sign up screen.
+      def attribute_required_by_default?
+        false
+      end
+    end
+  end
+end

data/lib/simple_form/inputs/collection_input.rb

@@ -13,10 +13,9 @@ module SimpleForm
       end
 
       def input
-        collection = (options[:collection] || self.class.boolean_collection).to_a
-        detect_collection_methods(collection, options)
-        @builder.send(:"collection_#{input_type}", attribute_name, collection, options[:value_method],
-                      options[:label_method], input_options, input_html_options)
+        label_method, value_method = detect_collection_methods
+        @builder.send(:"collection_#{input_type}", attribute_name, collection,
+                      value_method, label_method, input_options, input_html_options)
       end
 
       def input_options
@@ -27,6 +26,15 @@ module SimpleForm
 
     protected
 
+      def collection
+        @collection ||= (options.delete(:collection) || self.class.boolean_collection).to_a
+      end
+
+      # Select components does not allow the required html tag.
+      def has_required?
+        super && input_type != :select
+      end
+
       # Check if :include_blank must be included by default.
       def skip_include_blank?
         (options.keys & [:prompt, :include_blank, :default, :selected]).any? ||
@@ -38,21 +46,42 @@ module SimpleForm
       # on default label and value methods that can be configured through
       # SimpleForm.collection_label_methods and
       # SimpleForm.collection_value_methods.
-      def detect_collection_methods(collection, options)
-        sample = collection.first || collection.last
-
-        case sample
-          when Array
-            label, value = :first, :last
-          when Integer
-            label, value = :to_s, :to_i
-          when String, NilClass
-            label, value = :to_s, :to_s
+      def detect_collection_methods
+        label, value = options.delete(:label_method), options.delete(:value_method)
+
+        unless label && value
+          common_method_for = detect_common_display_methods
+          label ||= common_method_for[:label]
+          value ||= common_method_for[:value]
+        end
+
+        [label, value]
+      end
+
+      def detect_common_display_methods
+        collection_classes = detect_collection_classes
+
+        if collection_classes.include?(Array)
+          { :label => :first, :value => :last }
+        elsif collection_includes_basic_objects?(collection_classes)
+          { :label => :to_s, :value => :to_s }
+        else
+          sample = collection.first || collection.last
+
+          { :label => SimpleForm.collection_label_methods.find { |m| sample.respond_to?(m) },
+            :value => SimpleForm.collection_value_methods.find { |m| sample.respond_to?(m) } }
         end
+      end
+
+      def detect_collection_classes
+        collection.map { |e| e.class }.uniq
+      end
 
-        options[:label_method] ||= label || SimpleForm.collection_label_methods.find { |m| sample.respond_to?(m) }
-        options[:value_method] ||= value || SimpleForm.collection_value_methods.find { |m| sample.respond_to?(m) }
+      def collection_includes_basic_objects?(collection_classes)
+        (collection_classes & [
+          String, Integer, Fixnum, Bignum, Float, NilClass, Symbol, TrueClass, FalseClass
+        ]).any?
       end
     end
   end
-end
+end