nuatt-formtastic 0.2.2 → 0.2.3

data/lib/formtastic/inputs.rb

@@ -0,0 +1,29 @@
+module Formtastic
+  module Inputs
+    extend ActiveSupport::Autoload
+
+    autoload :Base
+    autoload :Basic
+    autoload :BooleanInput
+    autoload :CheckBoxesInput
+    autoload :CountryInput
+    autoload :DateInput
+    autoload :DatetimeInput
+    autoload :EmailInput
+    autoload :FileInput
+    autoload :HiddenInput
+    autoload :NumberInput
+    autoload :NumericInput
+    autoload :PasswordInput
+    autoload :PhoneInput
+    autoload :RadioInput
+    autoload :SearchInput
+    autoload :SelectInput
+    autoload :StringInput
+    autoload :TextInput
+    autoload :TimeInput
+    autoload :TimeZoneInput
+    autoload :Timeish
+    autoload :UrlInput
+  end
+end

data/lib/formtastic/inputs/base.rb

@@ -0,0 +1,50 @@
+module Formtastic
+  module Inputs
+    module Base
+      
+      attr_accessor :builder, :template, :object, :object_name, :method, :options
+      
+      def initialize(builder, template, object, object_name, method, options)
+        @builder = builder
+        @template = template
+        @object = object
+        @object_name = object_name
+        @method = method
+        @options = options.dup
+      end
+      
+      extend ActiveSupport::Autoload
+      
+      autoload :Associations
+      autoload :Collections
+      autoload :Choices
+      autoload :Database
+      autoload :Errors
+      autoload :Fileish
+      autoload :GroupedCollections
+      autoload :Hints
+      autoload :Html
+      autoload :Labelling
+      autoload :Naming
+      autoload :Options
+      autoload :Stringish
+      autoload :Timeish
+      autoload :Validations
+      autoload :Wrapping
+      
+      include Html
+      include Options
+      include Database
+      include Errors
+      include Hints
+      include Naming
+      include Validations
+      include Fileish
+      include Associations
+      include Labelling
+      include Wrapping
+      
+    end
+  end
+end
+  

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

@@ -0,0 +1,33 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Associations
+
+        # :belongs_to, etc
+        def association
+          @association ||= reflection.macro if reflection
+        end
+
+        def reflection
+          @reflection ||= object.class.reflect_on_association(method) if object.class.respond_to?(:reflect_on_association)
+        end
+
+        def belongs_to?
+          association == :belongs_to
+        end
+
+        def association_primary_key
+          if association
+            return reflection.options[:foreign_key] unless reflection.options[:foreign_key].blank?
+            return reflection.foreign_key if reflection.respond_to?(:foreign_key)
+            return :"#{method}_id" if belongs_to?
+            return "#{method.to_s.singularize}_id".pluralize.to_sym
+          else
+            return method.to_s
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Choices
+        
+        def choices_wrapping(&block)
+          template.content_tag(:fieldset, 
+            template.capture(&block),
+            choices_wrapping_html_options
+          )
+        end
+
+        def choices_wrapping_html_options
+          {}
+        end
+
+        def choices_group_wrapping(&block)
+          template.content_tag(:ol, 
+            template.capture(&block),
+            choices_group_wrapping_html_options
+          )
+        end
+
+        def choices_group_wrapping_html_options
+          {}
+        end
+
+        def choice_wrapping(html_options, &block)
+          template.content_tag(:li, 
+            template.capture(&block),
+            html_options
+          )
+        end
+
+        def choice_wrapping_html_options(choice)
+          { :class => value_as_class? ? "#{sanitized_method_name.singularize}_#{choice_html_safe_value(choice)}" : '' }
+        end
+
+        def choice_html(choice)        
+          raise "choice_html() needs to be implemented when including Formtastic::Inputs::Base::Choices"
+        end
+
+        def choice_label(choice)
+          choice.is_a?(Array) ? choice.first : choice
+        end
+
+        def choice_value(choice)
+          choice.is_a?(Array) ? choice.last : choice
+        end
+
+        def choice_html_safe_value(choice)
+          choice_value(choice).to_s.gsub(/\s/, '_').gsub(/\W/, '').downcase
+        end
+
+        def choice_input_dom_id(choice)
+          [
+            builder.custom_namespace,
+            sanitized_object_name,
+            association_primary_key || method,
+            choice_html_safe_value(choice)
+          ].compact.reject { |i| i.blank? }.join("_")
+        end
+        
+        def value_as_class?
+          options[:value_as_class]
+        end
+
+        def legend_html
+          if render_label?
+            template.content_tag(:legend,
+              template.content_tag(:label, label_text),
+              label_html_options.merge(:class => "label")
+            )
+          else
+            "".html_safe
+          end
+        end
+        
+        # Override to remove the for attribute since this isn't associated with any element, as it's
+        # nested inside the legend.
+        def label_html_options
+          super.merge(:for => nil)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Collections
+        
+        def label_method
+          label_and_value_method(raw_collection).first
+        end
+      
+        def value_method
+          label_and_value_method(raw_collection).last
+        end
+      
+        def label_and_value_method(_collection, grouped=false)
+          sample = _collection.first || _collection.last
+      
+          case sample
+          when Array
+            label, value = :first, :last
+          when Integer
+            label, value = :to_s, :to_i
+          when String, NilClass
+            label, value = :to_s, :to_s
+          end
+      
+          # Order of preference: user supplied method, class defaults, auto-detect
+          label = (grouped ? options[:grouped_label_method] : options[:label_method]) || label || builder.collection_label_methods.find { |m| sample.respond_to?(m) }
+          value = (grouped ? options[:grouped_value_method] : options[:value_method]) || value || builder.collection_value_methods.find { |m| sample.respond_to?(m) }
+      
+          [label, value]
+        end
+            
+        def raw_collection
+          @raw_collection ||= (collection_from_options || collection_from_association || collection_for_boolean)
+        end
+      
+        def collection
+          # Return if we have a plain string
+          return raw_collection if raw_collection.instance_of?(String) || raw_collection.instance_of?(ActiveSupport::SafeBuffer)
+        
+          # Return if we have an Array of strings, fixnums or arrays
+          return raw_collection if (raw_collection.instance_of?(Array) || raw_collection.instance_of?(Range)) &&
+                               [Array, Fixnum, String, Symbol].include?(raw_collection.first.class) &&
+                               !(options.include?(:label_method) || options.include?(:value_method))
+                       
+          raw_collection.map { |o| [send_or_call(label_method, o), send_or_call(value_method, o)] }
+        end
+      
+        def collection_from_options
+          items = options[:collection]
+          items = items.to_a if items.is_a?(Hash)
+          items
+        end
+      
+        def collection_from_association
+          if reflection
+            raise PolymorphicInputWithoutCollectionError.new("A collection must be supplied for #{method} input. Collections cannot be guessed for polymorphic associations.") if reflection.options[:polymorphic] == true
+
+            find_options_from_options = options[:find_options] || {}
+            conditions_from_options = find_options_from_options[:conditions] || {}
+            conditions_from_reflection = reflection.options[:conditions] || {}
+            
+            if conditions_from_options.any?
+              reflection.klass.where(
+                conditions_from_reflection.merge(conditions_from_options)
+              )
+            else
+              find_options_from_options.merge!(:include => group_by) if self.respond_to?(:group_by) && group_by
+              reflection.klass.where(conditions_from_reflection.merge(find_options_from_options))
+            end
+          end
+        end
+        
+        def collection_for_boolean
+          true_text = options[:true] || Formtastic::I18n.t(:yes)
+          false_text = options[:false] || Formtastic::I18n.t(:no)
+        
+          # TODO options[:value_as_class] = true unless options.key?(:value_as_class)
+      
+          [ [true_text, true], [false_text, false] ]
+        end
+      
+        def send_or_call(duck, object)
+          if duck.is_a?(Proc)
+            duck.call(object)
+          else
+            object.send(duck)
+          end
+        end
+      
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Formtastic
+  module Inputs
+    module Base
+      module Database
+        
+        def column
+          object.column_for_attribute(method) if object.respond_to?(:column_for_attribute)
+        end
+        
+        def column?
+          !column.nil?
+        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 = options[: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 = options[: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 = options[: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?
+          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/grouped_collections.rb

@@ -0,0 +1,77 @@
+module Formtastic
+  module Inputs
+    module Base
+      module GroupedCollections
+      
+        def raw_grouped_collection
+          @raw_grouped_collection ||= raw_collection.map { |option| option.send(options[:group_by]) }.uniq
+        end
+      
+        def grouped_collection
+          @grouped_collection ||= raw_grouped_collection.sort_by { |group_item| group_item.send(group_label_method) }
+        end
+      
+        def group_label_method
+          @group_label_method ||= (group_label_method_from_options || group_label_method_from_grouped_collection)
+        end
+      
+        def group_label_method_from_options
+          options[:group_label_method]
+        end
+      
+        def group_label_method_from_grouped_collection
+          label_and_value_method(raw_grouped_collection, true).first
+        end
+      
+        def group_association
+          @group_association ||= (group_association_from_options || group_association_from_reflection)
+        end
+      
+        def group_association_from_options
+          options[:group_association]
+        end
+      
+        def group_by
+          options[:group_by]
+        end
+      
+        def group_association_from_reflection
+          method_to_group_association_by = reflection.klass.reflect_on_association(group_by)
+          group_class = method_to_group_association_by.klass
+      
+          # This will return in the normal case
+          return method.to_s.pluralize.to_sym if group_class.reflect_on_association(method.to_s.pluralize)
+      
+          # This is for belongs_to associations named differently than their class
+          # form.input :parent, :group_by => :customer
+          # eg.
+          # class Project
+          #   belongs_to :parent, :class_name => 'Project', :foreign_key => 'parent_id'
+          #   belongs_to :customer
+          # end
+          # class Customer
+          #   has_many :projects
+          # end
+          group_method = group_class.to_s.underscore.pluralize.to_sym
+          return group_method if group_class.reflect_on_association(group_method) # :projects
+      
+          # This is for has_many associations named differently than their class
+          # eg.
+          # class Project
+          #   belongs_to :parent, :class_name => 'Project', :foreign_key => 'parent_id'
+          #   belongs_to :customer
+          # end
+          # class Customer
+          #   has_many :tasks, :class_name => 'Project', :foreign_key => 'customer_id'
+          # end
+          possible_associations = group_class.reflect_on_all_associations(:has_many).find_all {|assoc| assoc.klass == reflection.klass }
+          return possible_associations.first.name.to_sym if possible_associations.count == 1
+      
+          raise "Cannot infer group association for #{method} grouped by #{group_by}, there were #{possible_associations.empty? ? 'no' : possible_associations.size} possible associations. Please specify using :group_association"
+        end
+
+      end
+    end
+  end
+end
+