formtastic 1.2.4 → 3.1.5

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

@@ -0,0 +1,22 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Database
+        
+        def column
+          if object.respond_to?(:column_for_attribute)
+            # Remove deprecation wrapper & review after Rails 5.0 ships
+            ActiveSupport::Deprecation.silence do
+              object.column_for_attribute(method)
+            end
+          end
+        end
+        
+        def column?
+          !column.nil?
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+module Formtastic
+  module Inputs
+    module Base
+      module DatetimePickerish
+        include Base::Placeholder
+      
+        def html_input_type
+          raise NotImplementedError
+        end
+      
+        def default_size
+          raise NotImplementedError
+        end
+        
+        def value
+          raise NotImplementedError
+        end
+      
+        def input_html_options
+          super.merge(extra_input_html_options)
+        end
+      
+        def extra_input_html_options
+          {
+            :type => html_input_type, 
+            :size => size, 
+            :maxlength => maxlength, 
+            :step => step,
+            :value => value
+          }
+        end
+      
+        def size
+          return options[:size] if options.key?(:size)
+          return options[:input_html][:size] if options[:input_html] && options[:input_html].key?(:size)
+          default_size
+        end
+      
+        def step
+          return step_from_macro(options[:input_html][:step]) if options[:input_html] && options[:input_html][:step] && options[:input_html][:step].is_a?(Symbol)
+          return options[:input_html][:step] if options[:input_html] && options[:input_html].key?(:step)
+          default_step
+        end
+      
+        def maxlength
+          return options[:maxlength] if options.key?(:maxlength)
+          return options[:input_html][:maxlength] if options[:input_html] && options[:input_html].key?(:maxlength)
+          default_size
+        end
+      
+        def default_maxlength
+          default_size
+        end
+      
+        def default_step
+          1
+        end
+        
+        protected
+        
+        def step_from_macro(sym)
+          case sym
+
+            # date
+            when :day then "1"
+            when :seven_days, :week then "7"
+            when :two_weeks, :fortnight then "14"
+            when :four_weeks then "28"
+            when :thirty_days then "30"
+
+            # time
+            when :second then "1"
+            when :minute then "60"
+            when :fifteen_minutes, :quarter_hour then "900"
+            when :thirty_minutes, :half_hour then "1800"
+            when :sixty_minutes, :hour then "3600"            
+
+            else sym
+          end
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Errors
+        
+        def error_html
+          errors? ? send(:"error_#{builder.inline_errors}_html") : ""
+        end
+        
+        def error_sentence_html
+          error_class = builder.default_inline_error_class
+          template.content_tag(:p, Formtastic::Util.html_safe(errors.to_sentence.html_safe), :class => error_class)
+        end
+                
+        def error_list_html
+          error_class = builder.default_error_list_class
+          list_elements = []
+          errors.each do |error|
+            list_elements << template.content_tag(:li, Formtastic::Util.html_safe(error.html_safe))
+          end
+          template.content_tag(:ul, Formtastic::Util.html_safe(list_elements.join("\n")), :class => error_class)
+        end
+        
+        def error_first_html
+          error_class = builder.default_inline_error_class
+          template.content_tag(:p, Formtastic::Util.html_safe(errors.first.untaint), :class => error_class)
+        end
+        
+        def error_none_html
+          ""
+        end
+        
+        def errors?
+          !errors.blank?
+        end
+        
+        def errors
+          errors = []
+          if object && object.respond_to?(:errors)
+            error_keys.each do |key| 
+              errors << object.errors[key] unless object.errors[key].blank?
+            end
+          end
+          errors.flatten.compact.uniq
+        end
+        
+        def error_keys
+          keys = [method.to_sym]
+          keys << builder.file_metadata_suffixes.map{|suffix| "#{method}_#{suffix}".to_sym} if file?
+          keys << association_primary_key if belongs_to? || has_many?
+          keys.flatten.compact.uniq
+        end
+        
+      end
+    end
+  end
+end
+        

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

@@ -0,0 +1,23 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Fileish
+      
+        def file?
+          @file ||= begin
+            # TODO return true if self.is_a?(Formtastic::Inputs::FileInput::Woo)
+            object && object.respond_to?(method) && builder.file_methods.any? { |m| object.send(method).respond_to?(m) }
+          end
+        end
+      
+      end
+    end
+  end
+end
+
+
+
+        
+
+
+

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 => 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,53 @@
+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_attribute?,
+            :autofocus => autofocus?,
+            :readonly => readonly?
+          }.merge(options[:input_html] || {})
+        end
+
+        def dom_id
+          [
+            builder.dom_id_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,52 @@
+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
+          {
+            :for => input_html_options[:id],
+            :class => ['label'],
+          }
+        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("::")[-1].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/numeric.rb

@@ -0,0 +1,50 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Numeric
+        def input_html_options
+          defaults = super
+
+          # override rails default size - does not apply to numeric inputs
+          #@todo document/spec
+          defaults[:size] = nil
+          
+          if in_option
+            defaults[:min] = in_option.to_a.min
+            defaults[:max] = in_option.to_a.max
+          else
+            defaults[:min]  ||= min_option
+            defaults[:max]  ||= max_option
+          end
+          defaults[:step] ||= step_option
+          defaults
+        end
+        
+        def step_option
+          return options[:step] if options.key?(:step)
+          validation_step
+        end
+        
+        def min_option
+          return options[:min] if options.key?(:min)
+          validation_min
+        end
+        
+        def max_option
+          return options[:max] if options.key?(:max)
+          validation_max
+        end
+        
+        def in_option
+          options[:in]
+        end
+        
+        def wrapper_html_options
+          new_class = [super[:class], "numeric", "stringish"].compact.join(" ")
+          super.merge(:class => new_class)
+        end
+        
+      end
+    end
+  end
+end

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

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