simple_form 1.3.0 → 1.4.0

data/lib/simple_form/form_builder.rb

@@ -5,13 +5,17 @@ module SimpleForm
     extend MapType
     include SimpleForm::Inputs
 
-    map_type :password, :text, :file,              :to => SimpleForm::Inputs::MappingInput
-    map_type :string, :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
+    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
@@ -85,12 +89,31 @@ module SimpleForm
       if block_given?
         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, attribute_name, column, input_type, options).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
@@ -133,7 +156,7 @@ module SimpleForm
         when :belongs_to
           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
           if options[:as] == :select
             html_options = options[:input_html] ||= {}
@@ -141,6 +164,12 @@ module SimpleForm
             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
 
@@ -175,12 +204,29 @@ module SimpleForm
     #    f.error :name, :id => "cool_error"
     #
     def error(attribute_name, options={})
-      options[:error_html] = options
+      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
     # an attribute for I18n lookup or a string. All the given options are sent
     # as :hint_html.
@@ -192,7 +238,7 @@ module SimpleForm
     #    f.hint "Don't forget to accept this"
     #
     def hint(attribute_name, options={})
-      options[:hint_html] = options
+      options[:hint_html] = options.dup
       if attribute_name.is_a?(String)
         options[:hint] = attribute_name
         attribute_name, column, input_type = nil, nil, nil
@@ -219,8 +265,8 @@ module SimpleForm
     def label(attribute_name, *args)
       return super if args.first.is_a?(String)
       options = args.extract_options!
+      options[:label_html] = options.dup
       options[:label]      = options.delete(:label)
-      options[:label_html] = options
       options[:required]   = options.delete(:required)
       column      = find_attribute_column(attribute_name)
       input_type  = default_input_type(attribute_name, column, options)
@@ -250,47 +296,94 @@ module SimpleForm
     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 /phone/     then :tel
-            when /url/       then :url
-            else
-              SimpleForm.input_mappings.find { |match, type|
-                attribute_name.to_s =~ match
-              }.try(:last) if SimpleForm.input_mappings
-          end
-
-          match || input_type || file_method?(attribute_name) || :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 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 if file && SimpleForm.file_methods.any? { |m| file.respond_to?(m) }
+      file && SimpleForm.file_methods.any? { |m| file.respond_to?(m) }
     end
 
-    # Finds the database column for the given attribute
     def find_attribute_column(attribute_name) #:nodoc:
-      @object.column_for_attribute(attribute_name) if @object.respond_to?(:column_for_attribute)
+      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/inputs/base.rb

@@ -28,8 +28,9 @@ module SimpleForm
         @reflection         = options.delete(:reflection)
         @options            = options
         @input_html_options = html_options_for(:input, input_html_classes).tap do |o|
-          o[:required] = true if attribute_required?
-          o[:disabled] = true if disabled?
+          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
 
@@ -71,8 +72,17 @@ module SimpleForm
         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?
-        object.class.respond_to?(:validators_on)
+        attribute_name && object.class.respond_to?(:validators_on)
       end
 
       def attribute_validators
@@ -120,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:
@@ -133,14 +152,36 @@ module SimpleForm
       #  Take a look at our locale example file.
       def translate(namespace, default='')
         return nil unless SimpleForm.translate
-        lookups = []
-        lookups << :"#{object_name}.#{lookup_action}.#{reflection_or_attribute_name}"
-        lookups << :"#{object_name}.#{reflection_or_attribute_name}"
+
+        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).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
@@ -148,6 +189,11 @@ module SimpleForm
         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

data/lib/simple_form/inputs/collection_input.rb

@@ -14,7 +14,6 @@ module SimpleForm
 
       def input
         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
@@ -31,6 +30,11 @@ module SimpleForm
         @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? ||

data/lib/simple_form/inputs/date_time_input.rb

@@ -7,6 +7,10 @@ module SimpleForm
 
     private
 
+      def has_required?
+        false
+      end
+
       def label_target
         case input_type
         when :date, :datetime

data/lib/simple_form/inputs/mapping_input.rb

@@ -4,7 +4,6 @@ module SimpleForm
     class MappingInput < Base
       extend MapType
 
-      map_type :password, :to => :password_field
       map_type :text,     :to => :text_area
       map_type :file,     :to => :file_field
 
@@ -14,11 +13,6 @@ module SimpleForm
 
     private
 
-      def input_method
-        self.class.mappings[input_type] or
-          raise("Could not find method for #{input_type.inspect}")
-      end
-
       def has_placeholder?
         (text? || password?) && placeholder_present?
       end

data/lib/simple_form/inputs/numeric_input.rb

@@ -2,10 +2,10 @@ module SimpleForm
   module Inputs
     class NumericInput < Base
       def input
-        input_html_options[:type] ||= "number"
+        input_html_options[:type] ||= "number" if SimpleForm.html5
         input_html_options[:size] ||= SimpleForm.default_input_size
-        input_html_options[:step] ||= 1 if integer?
-        infer_attributes_from_validations!
+        input_html_options[:step] ||= integer? ? 1 : "any" if SimpleForm.html5
+        infer_attributes_from_validations! if SimpleForm.html5
         @builder.text_field(attribute_name, input_html_options)
       end
 
@@ -35,23 +35,31 @@ module SimpleForm
 
       def minimum_value(validator_options)
         if integer? && validator_options.key?(:greater_than)
-          validator_options[:greater_than] + 1
+          evaluate_validator_option(validator_options[:greater_than]) + 1
         else
-          validator_options[:greater_than_or_equal_to]
+          evaluate_validator_option(validator_options[:greater_than_or_equal_to])
         end
       end
 
       def maximum_value(validator_options)
         if integer? && validator_options.key?(:less_than)
-          validator_options[:less_than] - 1
+          evaluate_validator_option(validator_options[:less_than]) - 1
         else
-          validator_options[:less_than_or_equal_to]
+          evaluate_validator_option(validator_options[:less_than_or_equal_to])
         end
       end
 
       def find_numericality_validator
         attribute_validators.find { |v| ActiveModel::Validations::NumericalityValidator === v }
       end
+
+      private
+
+      def evaluate_validator_option(option)
+        return option if option.is_a?(Numeric)
+        return object.send(option) if option.is_a?(Symbol)
+        return option.call(object) if option.respond_to?(:call)
+      end
     end
   end
 end

data/lib/simple_form/inputs/priority_input.rb

@@ -12,9 +12,13 @@ module SimpleForm
 
     protected
 
+      def has_required?
+        false
+      end
+
       def skip_include_blank?
         super || input_priority.present?
       end
     end
   end
-end
+end

data/lib/simple_form/inputs/string_input.rb

@@ -1,12 +1,19 @@
 module SimpleForm
   module Inputs
     class StringInput < Base
+      extend MapType
+
+      map_type :string, :email, :search, :tel, :url,  :to => :text_field
+      map_type :password,                             :to => :password_field
+
       def input
         input_html_options[:size]      ||= [limit, SimpleForm.default_input_size].compact.min
-        input_html_options[:maxlength] ||= limit if limit
-        input_html_options[:type]      ||= input_type unless string?
+        input_html_options[:maxlength] ||= limit if limit && SimpleForm.html5
+        if password? || SimpleForm.html5
+          input_html_options[:type]    ||= input_type unless string?
+        end
 
-        @builder.text_field(attribute_name, input_html_options)
+        @builder.send(input_method, attribute_name, input_html_options)
       end
 
       def input_html_classes
@@ -26,6 +33,10 @@ module SimpleForm
       def string?
         input_type == :string
       end
+
+      def password?
+        input_type == :password
+      end
     end
   end
 end

data/lib/simple_form/map_type.rb

@@ -1,13 +1,16 @@
+require 'active_support/core_ext/class/attribute'
+
 module SimpleForm
   module MapType
-    def mappings
-      @mappings ||= {}
+    def self.extended(base)
+      base.class_attribute :mappings
+      base.mappings = {}
     end
 
     def map_type(*types)
       map_to = types.extract_options![:to]
       raise ArgumentError, "You need to give :to as option to map_type" unless map_to
-      types.each { |t| mappings[t] = map_to }
+      self.mappings = mappings.merge types.each_with_object({}) { |t, m| m[t] = map_to }
     end
   end
 end

data/lib/simple_form/version.rb

@@ -1,3 +1,3 @@
 module SimpleForm
-  VERSION = "1.3.0".freeze
+  VERSION = "1.4.0".freeze
 end

data/lib/simple_form.rb

@@ -61,7 +61,7 @@ module SimpleForm
 
   # You can wrap each item in a collection of radio/check boxes with a tag, defaulting to none.
   mattr_accessor :item_wrapper_tag
-  @@item_wrapper_tag = nil
+  @@item_wrapper_tag = :span
 
   # You can wrap all inputs in a pre-defined tag. Default is a div.
   mattr_accessor :wrapper_tag
@@ -79,10 +79,29 @@ module SimpleForm
   mattr_accessor :label_text
   @@label_text = lambda { |label, required| "#{required} #{label}" }
 
+  # You can define the class to use on all labels. Default is nil.
+  mattr_accessor :label_class
+  @@label_class = nil
+
+  # You can define the class to use on all forms. Default is simple_form.
+  mattr_accessor :form_class
+  @@form_class = :simple_form
+
   # Whether attributes are required by default (or not).
   mattr_accessor :required_by_default
   @@required_by_default = true
 
+  # Tell browsers whether to use default HTML5 validations (novalidate option).
+  mattr_accessor :browser_validations
+  @@browser_validations = true
+
+  # Determines whether HTML5 types (:email, :url, :search, :tel) and attributes
+  # (e.g. required) are used or not. True by default.
+  # Having this on in non-HTML5 compliant sites can cause odd behavior in
+  # HTML5-aware browsers such as Chrome.
+  mattr_accessor :html5
+  @@html5 = true
+
   # Collection of methods to detect if a file type was given.
   mattr_accessor :file_methods
   @@file_methods = [ :mounted_as, :file?, :public_filename ]
@@ -110,6 +129,14 @@ module SimpleForm
   mattr_accessor :translate
   @@translate = true
 
+  # Automatically discover new inputs in Rails' autoload path.
+  mattr_accessor :inputs_discovery
+  @@inputs_discovery = true
+
+  # Cache simple form inputs discovery
+  mattr_accessor :cache_discovery
+  @@cache_discovery = !Rails.env.development?
+
   # Default way to setup SimpleForm. Run rails generate simple_form:install
   # to create a fresh initializer with all configuration values.
   def self.setup

data/simple_form.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "simple_form/version"
+
+Gem::Specification.new do |s|
+  s.name        = "simple_form"
+  s.version     = SimpleForm::VERSION.dup
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = "Forms made easy!"
+  s.email       = "contact@plataformatec.com.br"
+  s.homepage    = "http://github.com/plataformatec/simple_form"
+  s.description = "Forms made easy!"
+  s.authors     = ['José Valim', 'Carlos Antônio']
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.test_files   -= Dir["test/support/country_select/**/*"]
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.rubyforge_project = "simple_form"
+end

data/test/action_view_extensions/builder_test.rb

@@ -1,9 +1,11 @@
 require 'test_helper'
 
 class BuilderTest < ActionView::TestCase
-
-  def with_concat_form_for(object, &block)
-    concat form_for(object, &block)
+  def with_custom_form_for(object, *args, &block)
+    with_concat_custom_form_for(object) do |f|
+      assert f.instance_of?(CustomFormBuilder)
+      yield f
+    end
   end
 
   def with_collection_radio(object, attribute, collection, value_method, text_method, options={}, html_options={})
@@ -116,10 +118,17 @@ class BuilderTest < ActionView::TestCase
     assert_select 'form li input[type=radio][value=false]#user_active_false'
   end
 
-  test 'collection radio does not wrap items by default' do
+  test 'collection radio wrap items in a span tag by default' do
     with_collection_radio @user, :active, [true, false], :to_s, :to_s
 
-    assert_no_select 'form li'
+    assert_select 'form span input[type=radio][value=true]#user_active_true + label'
+    assert_select 'form span input[type=radio][value=false]#user_active_false + label'
+  end
+
+  test 'collection radio does not wrap input inside the label' do
+    with_collection_radio @user, :active, [true, false], :to_s, :to_s
+
+    assert_no_select 'form label input'
   end
 
   # COLLECTION CHECK BOX
@@ -259,10 +268,17 @@ class BuilderTest < ActionView::TestCase
     assert_select 'form li input[type=checkbox][value=false]#user_active_false'
   end
 
-  test 'collection check box does not wrap items by default' do
+  test 'collection check box wrap items in a span tag by default' do
+    with_collection_check_boxes @user, :active, [true, false], :to_s, :to_s
+
+    assert_select 'form span input[type=checkbox][value=true]#user_active_true + label'
+    assert_select 'form span input[type=checkbox][value=false]#user_active_false + label'
+  end
+
+  test 'collection check box does not wrap input inside the label' do
     with_collection_check_boxes @user, :active, [true, false], :to_s, :to_s
 
-    assert_no_select 'form li'
+    assert_no_select 'form label input'
   end
 
   # SIMPLE FIELDS
@@ -273,4 +289,20 @@ class BuilderTest < ActionView::TestCase
       end
     end
   end
+
+  test 'fields for yields an instance of CustomBuilder if main builder is a CustomBuilder' do
+    with_custom_form_for(:user) do |f|
+      f.simple_fields_for(:company) do |company|
+        assert company.instance_of?(CustomFormBuilder)
+      end
+    end
+  end
+
+  test 'fields for yields an instance of FormBuilder if it was set in options' do
+    with_custom_form_for(:user) do |f|
+      f.simple_fields_for(:company, :builder => SimpleForm::FormBuilder) do |company|
+        assert company.instance_of?(SimpleForm::FormBuilder)
+      end
+    end
+  end
 end