formtastic 1.2.5 → 2.0.0.rc1

data/lib/formtastic/inputs/base/hints.rb

@@ -0,0 +1,31 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Hints
+        
+        def hint_html
+          if hint?
+            template.content_tag(
+              :p, 
+              Formtastic::Util.html_safe(hint_text), 
+              :class => (options[:hint_class] || builder.default_hint_class)
+            )
+          end
+        end
+        
+        def hint?
+          !hint_text.blank? && !hint_text.kind_of?(Hash)
+        end
+
+        def hint_text
+          localized_string(method, options[:hint], :hint)
+        end
+        
+        def hint_text_from_options
+          options[:hint]
+        end
+
+      end
+    end
+  end
+end

data/lib/formtastic/inputs/base/html.rb

@@ -0,0 +1,52 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Html
+        
+        # Defines how the instance of an input should be rendered to a HTML string.
+        #
+        # @abstract Implement this method in your input class to describe how the input should render itself.
+        #
+        # @example A basic label and text field input inside a standard wrapping might look like this:
+        #     def to_html
+        #       input_wrapping do
+        #         label_html <<
+        #         builder.text_field(method, input_html_options)
+        #       end
+        #     end
+        def to_html
+          raise NotImplementedError
+        end
+        
+        def input_html_options
+          { 
+            :id => dom_id,
+            :required => required?,
+            :autofocus => autofocus?
+          }.merge(options[:input_html] || {})
+        end
+        
+        def dom_id
+          [
+            builder.custom_namespace, 
+            sanitized_object_name, 
+            dom_index, 
+            association_primary_key || sanitized_method_name
+          ].reject { |x| x.blank? }.join('_')
+        end
+        
+        def dom_index
+          if builder.options.has_key?(:index)
+            builder.options[:index]
+          elsif !builder.auto_index.blank?
+            # TODO there's no coverage for this case, not sure how to create a scenario for it
+            builder.auto_index
+          else
+            ""
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/formtastic/inputs/base/labelling.rb

@@ -0,0 +1,55 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Labelling
+        
+        include Formtastic::LocalizedString
+        
+        def label_html
+          render_label? ? builder.label(input_name, label_text, label_html_options) : "".html_safe
+        end
+        
+        def label_html_options
+          # opts = options_for_label(options) # TODO
+          opts = {}
+          opts[:for] ||= input_html_options[:id]
+          opts[:class] = [opts[:class]]
+          opts[:class] << 'label'
+          
+          opts
+        end
+        
+        def label_text
+          ((localized_label || humanized_method_name) << requirement_text).html_safe
+        end
+        
+        # TODO: why does this need to be memoized in order to make the inputs_spec tests pass? 
+        def requirement_text_or_proc
+          @requirement_text_or_proc ||= required? ? builder.required_string : builder.optional_string
+        end
+        
+        def requirement_text
+          if requirement_text_or_proc.respond_to?(:call)
+            requirement_text_or_proc.call
+          else
+            requirement_text_or_proc
+          end
+        end
+
+        def label_from_options
+          options[:label]
+        end
+
+        def localized_label
+          localized_string(method, label_from_options || method, :label)
+        end
+        
+        def render_label?
+          return false if options[:label] == false
+          true
+        end
+        
+      end
+    end
+  end
+end

data/lib/formtastic/inputs/base/naming.rb

@@ -0,0 +1,42 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Naming
+
+        def as
+          self.class.name.split("::").last.underscore.gsub(/_input$/, '')
+        end
+        
+        def sanitized_object_name
+          object_name.to_s.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
+        end
+
+        def sanitized_method_name
+          @sanitized_method_name ||= method.to_s.gsub(/[\?\/\-]$/, '')
+        end
+
+        def attributized_method_name
+          method.to_s.gsub(/_id$/, '').to_sym
+        end
+        
+        def humanized_method_name
+          if builder.label_str_method != :humanize
+            # Special case where label_str_method should trump the human_attribute_name
+            # TODO: is this actually a desired bheavior, or should we ditch label_str_method and
+            # rely purely on :human_attribute_name.
+            method.to_s.send(builder.label_str_method)
+          elsif object && object.class.respond_to?(:human_attribute_name)
+            object.class.human_attribute_name(method.to_s)
+          else
+            method.to_s.send(builder.label_str_method)
+          end
+        end
+
+        def input_name
+          association_primary_key
+        end
+
+      end
+    end
+  end
+end

data/lib/formtastic/inputs/base/options.rb

@@ -0,0 +1,18 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Options
+        
+        def input_options
+          options.except(*formtastic_options)
+        end
+        
+        def formtastic_options
+          [:priority_countries, :priority_zones, :value_method, :label_method, :member_label, :member_value, :collection, :required, :label, :as, :hint, :input_html, :label_html, :value_as_class, :find_options, :class]
+        end
+      
+      end
+    end
+  end
+end
+

data/lib/formtastic/inputs/base/stringish.rb

@@ -0,0 +1,35 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Stringish
+        
+        # @abstract Override this method in your input class to describe how the input should render itself.
+        def to_html
+          input_wrapping do
+            label_html <<
+            builder.text_field(method, input_html_options)
+          end
+        end
+        
+        # Overrides standard `input_html_options` to provide a `maxlength` and `size` attribute.
+        def input_html_options
+          {
+            :maxlength => options[:input_html].try(:[], :maxlength) || limit,
+            :size => builder.default_text_field_size,
+            :placeholder => placeholder_text
+          }.merge(super)
+        end
+        
+        def placeholder_text
+          localized_string(method, options[:placeholder], :placeholder)
+        end
+        
+        def wrapper_html_options
+          new_class = [super[:class], "stringish"].compact.join(" ")
+          super.merge(:class => new_class)
+        end
+        
+      end
+    end
+  end
+end

data/lib/formtastic/inputs/base/timeish.rb

@@ -0,0 +1,128 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Timeish
+        
+        def to_html
+          input_wrapping do
+            fragments_wrapping do
+              fragments_label <<
+              template.content_tag(:ol,
+                fragments.map do |fragment|
+                  fragment_wrapping do
+                    fragment_label_html(fragment) <<
+                    fragment_input_html(fragment)
+                  end
+                end.join.html_safe, # TODO is this safe?
+                { :class => 'fragments-group' } # TODO refactor to fragments_group_wrapping
+              )
+            end
+          end
+        end
+        
+        def fragments
+          date_fragments + time_fragments
+        end
+        
+        def time_fragments
+          options[:include_seconds] ? [:hour, :minute, :second] : [:hour, :minute]
+        end
+        
+        def date_fragments
+          options[:order] || i18n_date_fragments || default_date_fragments
+        end
+        
+        def default_date_fragments
+          [:year, :month, :day]
+        end
+        
+        def fragment_wrapping(&block)
+          template.content_tag(:li, template.capture(&block), fragment_wrapping_html_options)
+        end
+        
+        def fragment_wrapping_html_options
+          { :class => 'fragment' }
+        end
+        
+        def fragment_label(fragment)
+          labels_from_options = options[:labels] || {}
+          if labels_from_options.key?(fragment)
+            labels_from_options[fragment]
+          else
+            ::I18n.t(fragment.to_s, :default => fragment.to_s.humanize, :scope => [:datetime, :prompts])
+          end
+        end
+        
+        def fragment_id(fragment)
+          "#{input_html_options[:id]}_#{position(fragment)}i"
+        end
+        
+        def fragment_name(fragment)
+          "#{method}(#{position(fragment)}i)"
+        end
+        
+        def fragment_label_html(fragment)
+          text = fragment_label(fragment)
+          text.blank? ? "" : template.content_tag(:label, text, :for => fragment_id(fragment))
+        end
+        
+        def value
+          object.send(method) if object && object.respond_to?(method)
+        end
+        
+        def fragment_input_html(fragment)
+          opts = input_options.merge(:prefix => object_name, :field_name => fragment_name(fragment), :default => value, :include_blank => include_blank?)
+          template.send(:"select_#{fragment}", value, opts, input_html_options.merge(:id => fragment_id(fragment)))
+        end
+        
+        # TODO extract to BlankOptions or similar -- Select uses similar code
+        def include_blank?
+          options.key?(:include_blank) ? options[:include_blank] : builder.include_blank_for_select_by_default
+        end
+        
+        def positions
+          { :year => 1, :month => 2, :day => 3, :hour => 4, :minute => 5, :second => 6 }
+        end
+        
+        def position(fragment)
+          positions[fragment]
+        end
+        
+        def i18n_date_fragments
+          order = ::I18n.t(:order, :scope => [:date])
+          order = nil unless order.is_a?(Array)
+          order
+        end
+        
+        def fragments_wrapping(&block)
+          template.content_tag(:fieldset,
+            template.capture(&block).html_safe, 
+            fragments_wrapping_html_options
+          )
+        end
+        
+        def fragments_wrapping_html_options
+          { :class => "fragments" }
+        end
+        
+        def fragments_label
+          if render_label?
+            template.content_tag(:legend, 
+              builder.label(method, label_text, :for => "#{input_html_options[:id]}_1i"), 
+              :class => "label"
+            )
+          else
+            ""
+          end
+        end
+        
+        def fragments_inner_wrapping(&block)
+          template.content_tag(:ol,
+            template.capture(&block)
+          )
+        end
+        
+      end
+    end
+  end
+end

data/lib/formtastic/inputs/base/validations.rb

@@ -0,0 +1,166 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Validations
+
+        class IndeterminableMinimumAttributeError < ArgumentError
+          def message
+            [
+              "A minimum value can not be determined when the validation uses :greater_than on a :decimal or :float column type.",
+              "Please alter the validation to use :greater_than_or_equal_to, or provide a value for this attribute explicitly with the :min option on input()."
+            ].join("\n")
+          end
+        end
+
+        class IndeterminableMaximumAttributeError < ArgumentError
+          def message
+            [
+              "A maximum value can not be determined when the validation uses :less_than on a :decimal or :float column type.",
+              "Please alter the validation to use :less_than_or_equal_to, or provide a value for this attribute explicitly with the :max option on input()."
+            ].join("\n")
+          end
+        end
+
+        def validations
+          @validations ||= if object && object.class.respond_to?(:validators_on)
+            object.class.validators_on(attributized_method_name).select do |validator|
+              validator_relevant?(validator)
+            end
+          else
+            []
+          end
+        end
+
+        def validator_relevant?(validator)
+          return true unless validator.options.key?(:if) || validator.options.key?(:unless)
+          conditional = validator.options.key?(:if) ? validator.options[:if] : validator.options[:unless]
+
+          result = if conditional.respond_to?(:call)
+            conditional.call(object)
+          elsif conditional.is_a?(::Symbol) && object.respond_to?(conditional)
+            object.send(conditional)
+          else
+            conditional
+          end
+
+          result = validator.options.key?(:unless) ? !result : !!result
+          not_required_through_negated_validation! if !result && [:presence, :inclusion, :length].include?(validator.kind)
+
+          result
+        end
+
+        def validation_limit
+          validation = validations? && validations.find do |validation|
+            validation.kind == :length
+          end
+          if validation
+            validation.options[:maximum] || (validation.options[:within].present? ? validation.options[:within].max : nil)
+          else
+            nil
+          end
+        end
+
+        # Prefer :greater_than_or_equal_to over :greater_than, for no particular reason.
+        def validation_min
+          validation = validations? && validations.find do |validation|
+            validation.kind == :numericality
+          end
+
+          if validation
+            # We can't determine an appropriate value for :greater_than with a float/decimal column
+            raise IndeterminableMinimumAttributeError if validation.options[:greater_than] && column? && [:float, :decimal].include?(column.type)
+
+            return validation.options[:greater_than_or_equal_to] if validation.options[:greater_than_or_equal_to]
+            return (validation.options[:greater_than] + 1)       if validation.options[:greater_than]
+          end
+        end
+
+        # Prefer :less_than_or_equal_to over :less_than, for no particular reason.
+        def validation_max
+          validation = validations? && validations.find do |validation|
+            validation.kind == :numericality
+          end
+          if validation
+            # We can't determine an appropriate value for :greater_than with a float/decimal column
+            raise IndeterminableMaximumAttributeError if validation.options[:less_than] && column? && [:float, :decimal].include?(column.type)
+
+            return validation.options[:less_than_or_equal_to] if validation.options[:less_than_or_equal_to]
+            return (validation.options[:less_than] - 1)       if validation.options[:less_than]
+          end
+        end
+
+        def validation_step
+          validation = validations? && validations.find do |validation|
+            validation.kind == :numericality
+          end
+          if validation
+            validation.options[:step]
+          else
+            nil
+          end
+        end
+
+        def validation_integer_only?
+          validation = validations? && validations.find do |validation|
+            validation.kind == :numericality
+          end
+          if validation
+            validation.options[:only_integer]
+          else
+            false
+          end
+        end
+
+        def validations?
+          !validations.empty?
+        end
+
+        def required?
+          return false if options[:required] == false
+          return true if options[:required] == true
+          return false if not_required_through_negated_validation?
+          if validations?
+            validations.select { |validator|
+              [:presence, :inclusion, :length].include?(validator.kind) &&
+              validator.options[:allow_blank] != true
+            }.any?
+          else
+            return responds_to_global_required? && !!builder.all_fields_required_by_default
+          end
+        end
+
+        def not_required_through_negated_validation?
+          @not_required_through_negated_validation
+        end
+
+        def not_required_through_negated_validation!
+          @not_required_through_negated_validation = true
+        end
+
+        def responds_to_global_required?
+          true
+        end
+
+        def optional?
+          !required?
+        end
+
+        def autofocus?
+          opt_autofocus = options[:input_html] && options[:input_html][:autofocus]
+
+          !!opt_autofocus
+        end
+
+        def column_limit
+          column.limit if column? && column.respond_to?(:limit)
+        end
+
+        def limit
+          validation_limit || column_limit
+        end
+
+      end
+    end
+  end
+end
+