simple_form 1.5.2 → 2.0.0

data/lib/simple_form/action_view_extensions/form_helper.rb

@@ -1,6 +1,6 @@
 module SimpleForm
   module ActionViewExtensions
-    # This module creates simple form wrappers around default form_for and fields_for.
+    # This module creates SimpleForm wrappers around default form_for and fields_for.
     #
     # Example:
     #
@@ -21,34 +21,16 @@ module SimpleForm
         html_tag
       end
 
-      def with_custom_field_error_proc(&block)
-        @@default_field_error_proc = ::ActionView::Base.field_error_proc
-        ::ActionView::Base.field_error_proc = FIELD_ERROR_PROC
-        result = yield
-        ::ActionView::Base.field_error_proc = @@default_field_error_proc
-        result
-      end
-
       def simple_form_for(record, options={}, &block)
         options[:builder] ||= SimpleForm::FormBuilder
         options[:html] ||= {}
         unless options[:html].key?(:novalidate)
           options[:html][:novalidate] = !SimpleForm.browser_validations
         end
-        options[:html][:class] = [SimpleForm.form_class, css_class(record, options[:html])].compact.join(" ")
-        with_custom_field_error_proc do
-          form_for(record, options, &block)
-        end
-      end
+        options[:html][:class] = [SimpleForm.form_class, simple_form_css_class(record, options)].compact.join(" ")
 
-      def css_class(record, html_options)
-        if html_options.key?(:class)
-          html_options[:class]
-        elsif record.is_a?(String) || record.is_a?(Symbol)
-          record
-        else
-          record = record.last if record.is_a?(Array)
-          dom_class(record)
+        with_simple_form_field_error_proc do
+          form_for(record, options, &block)
         end
       end
 
@@ -56,10 +38,35 @@ module SimpleForm
         options, record_object = record_object, nil if record_object.is_a?(Hash) && record_object.extractable_options?
         options[:builder] ||= SimpleForm::FormBuilder
 
-        with_custom_field_error_proc do
+        with_simple_form_field_error_proc do
           fields_for(record_name, record_object, options, &block)
         end
       end
+
+      private
+
+      def with_simple_form_field_error_proc
+        @@default_field_error_proc = ::ActionView::Base.field_error_proc
+        ::ActionView::Base.field_error_proc = FIELD_ERROR_PROC
+        result = yield
+        ::ActionView::Base.field_error_proc = @@default_field_error_proc
+        result
+      end
+
+      def simple_form_css_class(record, options)
+        html_options = options[:html]
+        as = options[:as]
+
+        if html_options.key?(:class)
+          html_options[:class]
+        elsif record.is_a?(String) || record.is_a?(Symbol)
+          as || record
+        else
+          record = record.last if record.is_a?(Array)
+          action = record.respond_to?(:persisted?) && record.persisted? ? :edit : :new
+          as ? "#{action}_#{as}" : dom_class(record, action)
+        end
+      end
     end
   end
 end

data/lib/simple_form/components/errors.rb

@@ -1,42 +1,24 @@
 module SimpleForm
   module Components
     module Errors
-      include SimpleForm::Helpers::HasErrors
-
       def error
-        enabled_error
+        error_text if has_errors?
       end
 
-      def error_tag
-        options[:error_tag] || SimpleForm.error_tag
+      def has_errors?
+        object && object.respond_to?(:errors) && errors.present?
       end
 
+      protected
+
       def error_text
-        if options[:error_prefix]
-          options[:error_prefix] + " " + errors.send(error_method)
-        else
-          errors.send(error_method)
-        end
+        "#{options[:error_prefix]} #{errors.send(error_method)}".lstrip.html_safe
       end
 
       def error_method
         options[:error_method] || SimpleForm.error_method
       end
 
-      def error_html_options
-        html_options_for(:error, [SimpleForm.error_class])
-      end
-
-    protected
-
-      def enabled_error
-        template.content_tag(error_tag, error_text, error_html_options) if has_errors?
-      end
-
-      def disabled_error
-        nil
-      end
-
       def errors
         @errors ||= (errors_on_attribute + errors_on_association).compact
       end

data/lib/simple_form/components/hints.rb

@@ -1,30 +1,16 @@
 module SimpleForm
   module Components
+    # Needs to be enabled in order to do automatic lookups.
     module Hints
       def hint
-        enabled_hint
+        @hint ||= begin
+          hint = options[:hint]
+          hint.is_a?(String) ? hint : translate(:hints)
+        end
       end
 
-      private
-
-      def enabled_hint
-        template.content_tag(hint_tag, hint_text, hint_html_options) unless hint_text.blank?
-      end
-
-      def disabled_hint
-        nil
-      end
-
-      def hint_tag
-        options[:hint_tag] || SimpleForm.hint_tag
-      end
-
-      def hint_text
-        @hint_text ||= options[:hint] || translate(:hints)
-      end
-
-      def hint_html_options
-        html_options_for(:hint, [SimpleForm.hint_class])
+      def has_hint?
+        hint.present?
       end
     end
   end

data/lib/simple_form/components/html5.rb

@@ -0,0 +1,26 @@
+module SimpleForm
+  module Components
+    module HTML5
+      def initialize(*)
+        @html5 = false
+      end
+
+      def html5
+        @html5 = true
+        input_html_options[:required] = true if has_required?
+        nil
+      end
+
+      def html5?
+        @html5
+      end
+
+      def has_required?
+        # We need to check browser_validations because
+        # some browsers are still checking required even
+        # if novalidate was given.
+        required_field? && SimpleForm.browser_validations
+      end
+    end
+  end
+end

data/lib/simple_form/components/labels.rb

@@ -22,7 +22,11 @@ module SimpleForm
       end
 
       def label
-        enabled_label
+        if generate_label_for_attribute?
+          @builder.label(label_target, label_text, label_html_options)
+        else
+          template.label_tag(nil, label_text, label_html_options)
+        end
       end
 
       def label_text
@@ -34,20 +38,18 @@ module SimpleForm
       end
 
       def label_html_options
-        label_options = html_options_for(:label, [input_type, required_class, SimpleForm.label_class])
-        label_options[:for] = options[:input_html][:id] if options.key?(:input_html) && options[:input_html].key?(:id)
-        label_options
-      end
-
-    protected
+        label_html_classes = SimpleForm.additional_classes_for(:label) {
+          [input_type, required_class, SimpleForm.label_class].compact
+        }
 
-      def enabled_label
-        @builder.label(label_target, label_text, label_html_options)
+        label_options = html_options_for(:label, label_html_classes)
+        if options.key?(:input_html) && options[:input_html].key?(:id)
+          label_options[:for] = options[:input_html][:id]
+        end
+        label_options
       end
 
-      def disabled_label
-        ""
-      end
+      protected
 
       def raw_label_text #:nodoc:
         options[:label] || label_translation
@@ -55,17 +57,23 @@ module SimpleForm
 
       # Default required text when attribute is required.
       def required_label_text #:nodoc:
-        attribute_required? ? self.class.translate_required_html.dup : ''
+        required_field? ? self.class.translate_required_html.dup : ''
       end
 
       # First check labels translation and then human attribute name.
       def label_translation #:nodoc:
-        translate(:labels) || if object.class.respond_to?(:human_attribute_name)
+        if SimpleForm.translate_labels && (translated_label = translate(:labels))
+          translated_label
+        elsif 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
       end
+
+      def generate_label_for_attribute?
+        true
+      end
     end
   end
 end

data/lib/simple_form/components/maxlength.rb

@@ -0,0 +1,41 @@
+module SimpleForm
+  module Components
+    # Needs to be enabled in order to do automatic lookups.
+    module Maxlength
+      def maxlength
+        input_html_options[:maxlength] ||= maximum_length_from_validation || limit
+        nil
+      end
+
+      private
+
+      def maximum_length_from_validation
+        maxlength = options[:maxlength]
+        if maxlength.is_a?(String) || maxlength.is_a?(Integer)
+          maxlength
+        else
+          length_validator = find_length_validator
+
+          if length_validator && !has_tokenizer?(length_validator)
+            length_validator.options[:is] || length_validator.options[:maximum]
+          end
+        end
+      end
+
+      def find_length_validator
+        find_validator(ActiveModel::Validations::LengthValidator)
+      end
+
+      def has_tokenizer?(length_validator)
+        tokenizer = length_validator.options[:tokenizer]
+
+        # TODO: Remove this check when we drop Rails 3.0 support
+        if ActiveModel::Validations::LengthValidator.const_defined?(:DEFAULT_TOKENIZER)
+          tokenizer && tokenizer != ActiveModel::Validations::LengthValidator::DEFAULT_TOKENIZER
+        else
+          tokenizer
+        end
+      end
+    end
+  end
+end

data/lib/simple_form/components/min_max.rb

@@ -0,0 +1,49 @@
+module SimpleForm
+  module Components
+    module MinMax
+      def min_max
+        if numeric_validator = find_numericality_validator
+          validator_options = numeric_validator.options
+          input_html_options[:min] ||= minimum_value(validator_options)
+          input_html_options[:max] ||= maximum_value(validator_options)
+        end
+      end
+
+      private
+
+      def integer?
+        input_type == :integer
+      end
+
+      def minimum_value(validator_options)
+        if integer? && validator_options.key?(:greater_than)
+          evaluate_numericality_validator_option(validator_options[:greater_than]) + 1
+        else
+          evaluate_numericality_validator_option(validator_options[:greater_than_or_equal_to])
+        end
+      end
+
+      def maximum_value(validator_options)
+        if integer? && validator_options.key?(:less_than)
+          evaluate_numericality_validator_option(validator_options[:less_than]) - 1
+        else
+          evaluate_numericality_validator_option(validator_options[:less_than_or_equal_to])
+        end
+      end
+
+      def find_numericality_validator
+        find_validator(ActiveModel::Validations::NumericalityValidator)
+      end
+
+      def evaluate_numericality_validator_option(option)
+        if option.is_a?(Numeric)
+          option
+        elsif option.is_a?(Symbol)
+          object.send(option)
+        elsif option.respond_to?(:call)
+          option.call(object)
+        end
+      end
+    end
+  end
+end

data/lib/simple_form/components/pattern.rb

@@ -0,0 +1,34 @@
+module SimpleForm
+  module Components
+    # Needs to be enabled in order to do automatic lookups.
+    module Pattern
+      def pattern
+        input_html_options[:pattern] ||= pattern_source
+        nil
+      end
+
+      private
+
+      def pattern_source
+        pattern = options[:pattern]
+        if pattern.is_a?(String)
+          pattern
+        elsif pattern_validator = find_pattern_validator
+          evaluate_format_validator_option(pattern_validator.options[:with]).source
+        end
+      end
+
+      def find_pattern_validator
+        find_validator(ActiveModel::Validations::FormatValidator)
+      end
+
+      def evaluate_format_validator_option(option)
+        if option.respond_to?(:call)
+          option.call(object)
+        else
+          option
+        end
+      end
+    end
+  end
+end

data/lib/simple_form/components/placeholders.rb

@@ -1,28 +1,16 @@
 module SimpleForm
   module Components
+    # Needs to be enabled in order to do automatic lookups.
     module Placeholders
       def placeholder
-        disabled_placeholder
-      end
-
-      private
-
-      def enabled_placeholder
-        input_html_options[:placeholder] ||= placeholder_text if placeholder_present?
-        nil
-      end
-
-      def disabled_placeholder
+        input_html_options[:placeholder] ||= placeholder_text
         nil
       end
 
-      def placeholder_present?
-        options[:placeholder] != false && placeholder_text.present?
-      end
-
       def placeholder_text
-        @placeholder_text ||= options[:placeholder] || translate(:placeholders)
+        placeholder = options[:placeholder]
+        placeholder.is_a?(String) ? placeholder : translate(:placeholders)
       end
     end
   end
-end
+end

data/lib/simple_form/components/readonly.rb

@@ -0,0 +1,22 @@
+module SimpleForm
+  module Components
+    # Needs to be enabled in order to do automatic lookups.
+    module Readonly
+      def readonly
+        if readonly_attribute? && !has_readonly?
+          input_html_options[:readonly] ||= true
+          input_html_classes << :readonly
+        end
+        nil
+      end
+
+      private
+
+      def readonly_attribute?
+        object.class.respond_to?(:readonly_attributes) &&
+          object.persisted? &&
+          object.class.readonly_attributes.include?(attribute_name)
+      end
+    end
+  end
+end

data/lib/simple_form/components.rb

@@ -1,10 +1,20 @@
 module SimpleForm
+  # Components are a special type of helpers that can work on their own.
+  # For example, by using a component, it will automatically change the
+  # output under given circumstances without user input. For example,
+  # the disabled helper always need a :disabled => true option given
+  # to the input in order to be enabled. On the other hand, things like
+  # hints can generate output automatically by doing I18n lookups.
   module Components
     autoload :Errors,       'simple_form/components/errors'
     autoload :Hints,        'simple_form/components/hints'
+    autoload :HTML5,        'simple_form/components/html5'
     autoload :LabelInput,   'simple_form/components/label_input'
     autoload :Labels,       'simple_form/components/labels'
+    autoload :MinMax,       'simple_form/components/min_max'
+    autoload :Maxlength,    'simple_form/components/maxlength'
+    autoload :Pattern,      'simple_form/components/pattern'
     autoload :Placeholders, 'simple_form/components/placeholders'
-    autoload :Wrapper,      'simple_form/components/wrapper'
+    autoload :Readonly,     'simple_form/components/readonly'
   end
 end

data/lib/simple_form/core_ext/hash.rb

@@ -0,0 +1,16 @@
+# TODO: Delete this file when we drop support for Rails 3.0
+#   This method is already implemented in active_support 3.1
+
+unless Hash.new.respond_to?(:deep_dup)
+  class Hash
+    # Returns a deep copy of hash.
+    def deep_dup
+      duplicate = self.dup
+      duplicate.each_pair do |k,v|
+        tv = duplicate[k]
+        duplicate[k] = tv.is_a?(Hash) && v.is_a?(Hash) ? tv.deep_dup : v
+      end
+      duplicate
+    end
+  end
+end

data/lib/simple_form/error_notification.rb

@@ -1,7 +1,6 @@
 module SimpleForm
   class ErrorNotification
     delegate :object, :object_name, :template, :to => :@builder
-    include SimpleForm::Helpers::HasErrors
 
     def initialize(builder, options)
       @builder = builder
@@ -17,8 +16,16 @@ module SimpleForm
 
     protected
 
+    def errors
+      object.errors
+    end
+
+    def has_errors?
+      object && object.respond_to?(:errors) && errors.present?
+    end
+
     def error_message
-      @message || translate_error_notification
+      (@message || translate_error_notification).html_safe
     end
 
     def error_notification_tag
@@ -27,7 +34,6 @@ module SimpleForm
 
     def html_options
       @options[:class] = "#{SimpleForm.error_notification_class} #{@options[:class]}".strip
-      @options[:id] = SimpleForm.error_notification_id if SimpleForm.error_notification_id
       @options
     end