simple_form 1.2.2 → 1.3.0

data/lib/simple_form/components.rb

@@ -1,9 +1,10 @@
 module SimpleForm
   module Components
-    autoload :Errors,     'simple_form/components/errors'
-    autoload :Hints,      'simple_form/components/hints'
-    autoload :LabelInput, 'simple_form/components/label_input'
-    autoload :Labels,     'simple_form/components/labels'
-    autoload :Wrapper,    'simple_form/components/wrapper'
+    autoload :Errors,       'simple_form/components/errors'
+    autoload :Hints,        'simple_form/components/hints'
+    autoload :LabelInput,   'simple_form/components/label_input'
+    autoload :Labels,       'simple_form/components/labels'
+    autoload :Placeholders, 'simple_form/components/placeholders'
+    autoload :Wrapper,      'simple_form/components/wrapper'
   end
 end

data/lib/simple_form/components/errors.rb

@@ -1,6 +1,8 @@
 module SimpleForm
   module Components
     module Errors
+      include SimpleForm::HasErrors
+
       def error
         template.content_tag(error_tag, error_text, error_html_options) if has_errors?
       end
@@ -18,15 +20,11 @@ module SimpleForm
       end
 
       def error_html_options
-        html_options_for(:error, [:error])
+        html_options_for(:error, [SimpleForm.error_class])
       end
 
     protected
 
-      def has_errors?
-        object && errors.present?
-      end
-
       def errors
         @errors ||= (errors_on_attribute + errors_on_association).compact
       end
@@ -40,4 +38,4 @@ module SimpleForm
       end
     end
   end
-end
+end

data/lib/simple_form/components/hints.rb

@@ -14,8 +14,8 @@ module SimpleForm
       end
 
       def hint_html_options
-        html_options_for(:hint, [:hint])
+        html_options_for(:hint, [SimpleForm.hint_class])
       end
     end
   end
-end
+end

data/lib/simple_form/components/labels.rb

@@ -52,16 +52,14 @@ module SimpleForm
         attribute_required? ? self.class.translate_required_html.dup : ''
       end
 
-      # First check human attribute name and then labels.
+      # First check labels translation and then human attribute name.
       def label_translation #:nodoc:
-        default = if object.class.respond_to?(:human_attribute_name)
+        translate(:labels) || if object.class.respond_to?(:human_attribute_name)
           object.class.human_attribute_name(reflection_or_attribute_name.to_s)
         else
           attribute_name.to_s.humanize
         end
-
-        translate(:labels, default)
       end
     end
   end
-end
+end

data/lib/simple_form/components/placeholders.rb

@@ -0,0 +1,22 @@
+module SimpleForm
+  module Components
+    module Placeholders
+      def placeholder
+        input_html_options[:placeholder] ||= placeholder_text if has_placeholder?
+        nil
+      end
+
+      def has_placeholder?
+        false
+      end
+
+      def placeholder_present?
+        options[:placeholder] != false && placeholder_text.present?
+      end
+
+      def placeholder_text
+        @placeholder ||= options[:placeholder] || translate(:placeholders)
+      end
+    end
+  end
+end

data/lib/simple_form/components/wrapper.rb

@@ -24,8 +24,15 @@ module SimpleForm
       def wrapper_html_options
         css_classes = input_html_classes.unshift(wrapper_class)
         css_classes << wrapper_error_class if has_errors?
+        css_classes << disabled_class if disabled?
         html_options_for(:wrapper, css_classes)
       end
+
+    private
+
+      def disabled_class
+        'disabled'
+      end
     end
   end
 end

data/lib/simple_form/error_notification.rb

@@ -1,6 +1,7 @@
 module SimpleForm
   class ErrorNotification
     delegate :object, :object_name, :template, :to => :@builder
+    include SimpleForm::HasErrors
 
     def initialize(builder, options)
       @builder = builder
@@ -24,12 +25,9 @@ module SimpleForm
       SimpleForm.error_notification_tag
     end
 
-    def has_errors?
-      object && object.respond_to?(:errors) && object.errors.present?
-    end
-
     def html_options
-      @options[:class] = "error_notification #{@options[:class]}".strip
+      @options[:class] = "#{SimpleForm.error_notification_class} #{@options[:class]}".strip
+      @options[:id] = SimpleForm.error_notification_id if SimpleForm.error_notification_id
       @options
     end
 
@@ -41,4 +39,4 @@ module SimpleForm
       I18n.t(lookups.shift, :scope => :"simple_form.error_notification", :default => lookups)
     end
   end
-end
+end

data/lib/simple_form/form_builder.rb

@@ -1,18 +1,17 @@
 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 :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 :boolean,                            :to => SimpleForm::Inputs::BooleanInput
+    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
 
     # Basic input helper, combines all components in the stack to generate
     # input html based on options the user define and some guesses through
@@ -80,14 +79,14 @@ 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
+        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
       end
     end
     alias :attribute :input
@@ -124,30 +123,28 @@ 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"
         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]
-      )
+          :"#{reflection.name.to_s.singularize}_ids"
+      end
 
-      input(attribute, options).tap { @reflection = nil }
+      input(attribute, options.merge(:reflection => reflection))
     end
 
     # Creates a button:
@@ -159,8 +156,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
@@ -175,8 +175,10 @@ 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
+      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
 
     # Creates a hint tag for the given attribute. Accepts a symbol indicating
@@ -190,9 +192,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
+      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
@@ -211,9 +219,12 @@ 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]      = 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)
+      SimpleForm::Inputs::Base.new(self, attribute_name, column, input_type, options).label
     end
 
     # Creates an error notification message that only appears when the form object
@@ -233,52 +244,47 @@ module SimpleForm
 
   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
-    end
-
     # 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]
+    def default_input_type(attribute_name, column, options) #:nodoc:
+      return options[:as].to_sym if options[:as]
+      return :select             if options[:collection]
 
-      input_type = @column.try(:type)
+      input_type = column.try(:type)
 
       case input_type
         when :timestamp
           :datetime
         when :string, nil
-          match = case @attribute_name.to_s
+          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? || :string
+          match || input_type || file_method?(attribute_name) || :string
         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)
+    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) }
     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:
+      @object.column_for_attribute(attribute_name) if @object.respond_to?(:column_for_attribute)
     end
 
     # Find reflection related to association

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

@@ -12,13 +12,25 @@ module SimpleForm
       include SimpleForm::Components::Errors
       include SimpleForm::Components::Hints
       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 attribute_required?
+          o[:disabled] = true if disabled?
+        end
       end
 
       def input
@@ -29,10 +41,6 @@ module SimpleForm
         options
       end
 
-      def input_html_options
-        html_options_for(:input, input_html_classes)
-      end
-
       def input_html_classes
         [input_type, required_class]
       end
@@ -41,7 +49,8 @@ module SimpleForm
         content = "".html_safe
         components_list.each do |component|
           next if options[component] == false
-          content.safe_concat send(component).to_s
+          rendered = send(component)
+          content.safe_concat rendered.to_s if rendered
         end
         wrap(content)
       end
@@ -49,19 +58,31 @@ module SimpleForm
     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 object.class.respond_to?(: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
           attribute_required_by_default?
         end
       end
 
+      def has_validators?
+        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
@@ -82,6 +103,10 @@ module SimpleForm
         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:
       #
@@ -107,19 +132,22 @@ 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}"
         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
 
       # 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
     end
   end
-end
+end