case_form 0.0.3

data/lib/case_form/element/errors/simple_error.rb

@@ -0,0 +1,76 @@
+module CaseForm
+  module Element
+    class SimpleError < Error
+      include ElementExt::Associationable
+      
+      attr_accessor :method
+      
+      # Initialize error object
+      # 
+      def initialize(builder, method, options={})
+        @method = method
+        super(builder, options)
+      end
+      
+      # Generate simple errors for method with HTML options
+      #
+      def generate
+        template.content_tag error_tag, error_messages, html_options
+      end
+        
+      private
+        # Distribute default options for simple error.
+        #
+        def default_options
+          options[:class] ||= [:error]
+          options[:id]    ||= "#{sanitized_object_name}_#{method}_error"
+        end
+        
+        # Return all errors on method. If method is association than it takes also errors on association.
+        # == Example:
+        #   
+        #   # Get errors both on :country and :country_id attribute
+        #
+        #   class User
+        #     belongs_to :country
+        #     validates_presence_of :country_id
+        #     validates_inclusion_of :country, :in => Country.priority
+        #   end
+        #
+        def method_errors
+          association ? errors[method] + errors[association_method] : errors[method]
+        end
+        
+        # Error messages as list.
+        #
+        # == Example:
+        #
+        #   # object.errors[:name] = ['can't be blank', 'should be uniq']
+        #
+        #   <ul>
+        #     <li>can't be blank</li>
+        #     <li>should be uniq</li>
+        #   </ul>
+        #
+        def translated_list
+          template.content_tag :ul, (method_errors.collect { |msg| template.content_tag :li, msg }).join.html_safe
+        end
+        
+        # Error messages as sentence.
+        #
+        # == Example:
+        #
+        #   # object.errors[:name] = ['can't be blank', 'should be uniq']
+        #
+        #   <div>
+        #     can't be blank and should be uniq
+        #   </div>
+        #
+        def translated_sentence
+          method_errors.to_sentence(:words_connector     => error_connector, 
+                                    :last_word_connector => last_error_connector,
+                                    :two_words_connector => last_error_connector)
+        end
+    end
+  end
+end

data/lib/case_form/element/fieldset.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class Fieldset < Base
+      self.allowed_options << [:text]
+      
+      # Generate fieldset with defined arguments or block.
+      # Optional add legend tag if determined in options.
+      #
+      def generate(*args, &block)
+        contents, legend = [], text
+        contents << template.content_tag(:legend, legend) if legend
+        contents << if block_given? 
+          template.capture(&block) 
+        else
+          args
+        end
+        template.content_tag(:fieldset, contents.join.html_safe, html_options)
+      end
+      
+      private
+        # Distribute default options for fieldset.
+        #
+        def default_options
+          options[:class] ||= [:fieldset]
+        end
+        
+        # Fieldset legend text.
+        #
+        def text
+          options.delete(:text)
+        end
+    end
+  end
+end

data/lib/case_form/element/hint.rb

@@ -0,0 +1,54 @@
+module CaseForm
+  module Element
+    class Hint < Base
+      self.allowed_options << [:text, :tag]
+      
+      attr_accessor :method
+      
+      # Initialize hint's object
+      #
+      def initialize(builder, method, options={})
+        @method = method
+        super(builder, options)
+      end
+      
+      # Generate hint with defined text and HTML options
+      #   
+      def generate
+        template.content_tag(hint_tag, text, html_options)
+      end
+      
+      private
+        # Distribute default options for hint.
+        #
+        def default_options
+          options[:class] ||= [:hint]
+          options[:id]    ||= "#{sanitized_object_name}_#{method.to_s.underscore}_hint"
+        end
+        
+        # Generate hint's text. By default it use :text option, entered string or translated with I18n method. 
+        #
+        def text
+          if options[:text]
+            options.delete(:text)
+          elsif method.is_a?(String)
+            method
+          else
+            translated_text
+          end
+        end
+        
+        # Translate hint's text with I18n.
+        #
+        def translated_text
+          I18n.t(:"#{object_name}.#{method}", :scope => :"case_form.hints")
+        end
+        
+        # Default hint's tag
+        #
+        def hint_tag
+          options.delete(:tag) || CaseForm.hint_tag
+        end
+    end
+  end
+end

data/lib/case_form/element/input.rb

@@ -0,0 +1,106 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class Input < Base
+      include ElementExt::Validationable
+      include ElementExt::Columnable
+      
+      self.allowed_options << [:autofocus, :required, :label, :error, :hint]
+      
+      attr_accessor :method
+      
+      def initialize(builder, method, options={})
+        @method = method
+        super(builder, options)
+      end
+      
+      def generate
+        template.content_tag wrapper_tag, contents, wrapper_options
+      end
+      
+      private
+        def default_options
+          options[:class]    ||= [:input]
+          options[:required] ||= required?
+        end
+        
+        def wrapper_options
+          wrapper_options = super
+          wrapper_options[:class] << :element
+          wrapper_options
+        end
+        
+        def input_elements
+          CaseForm.input_elements
+        end
+        
+        def contents
+          contents = []
+          input_elements.each do |element| 
+            if options[element] == false
+              options.delete(element)
+              next
+            else
+              contents << send(element)
+            end
+          end
+          contents.join.html_safe
+        end
+        
+        def label
+          Element::Label.new(builder, method, label_options.merge(:required => required?)).generate
+        end
+        
+        def label_options
+          label_options = options.delete(:label) || {}
+          label_options.is_a?(String) ? { :text => label_options } : label_options
+        end
+        
+        def input
+          raise(NotImplementedInput)
+        end
+        
+        def input_options
+          options.except(:label, :error, :hint)
+        end
+        
+        def error
+          Element::SimpleError.new(builder, method, error_options).generate if error?
+        end
+        
+        def error?
+          object.errors[method].any? || object.errors[specific_method].any?
+        end
+        
+        def error_options
+          options.delete(:error) || {}
+        end
+        
+        def hint
+          Element::Hint.new(builder, method, hint_options).generate if hint?
+        end
+        
+        def hint?
+          options[:hint].present? || !I18n.t(:"#{object_name}.#{method}", :scope => :"case_form.hints", :default => '').blank?
+        end
+        
+        def hint_options
+          hint_options = options.delete(:hint) || {}
+          hint_options.is_a?(String) ? { :text => hint_options } : hint_options
+        end
+        
+        def input_size
+          validations = object.class.validators_on(method).select { |v| v.kind == :length }
+          if validations.any?
+            validations.first.options[:maximum]
+          else
+            CaseForm.input_size
+          end
+        end
+        
+        def input_type
+          options[:as]
+        end
+    end
+  end
+end

data/lib/case_form/element/inputs/collection/checkbox_input.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class CheckboxInput < CollectionInput
+      self.allowed_options << [:unchecked_value, :allow_multiple]
+      
+      private
+        def default_options
+          super
+          options[:unchecked_value] ||= ''
+          options[:checked]           = checked_values
+          options[:allow_multiple]  ||= multiple_collection?
+          options[:multiple]          = true if options[:allow_multiple] == true
+        end
+        
+        def input
+          collection.map do |element|
+            label, value  = element.first, element.last
+            checkbox_id   = "#{sanitized_object_name}_#{specific_method}_#{value}"
+            label_options = { :text     => label, 
+                              :required => false,
+                              :id       => "#{checkbox_id}_label", 
+                              :class    => :inline_label,
+                              :for      => checkbox_id }
+            
+            builder.check_box(specific_method, html_options.merge(html_options_for_value(value).merge!(:id => checkbox_id)), value, options[:unchecked_value]) <<
+              builder.label(specific_method, label_options)
+          end.join.html_safe
+        end
+        
+        def boolean_collection
+          [super.first]
+        end
+    end
+  end
+end

data/lib/case_form/element/inputs/collection/radio_input.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class RadioInput < CollectionInput
+      private
+        def default_options
+          super
+          options[:checked] = checked_values
+        end
+        
+        def input
+          collection.map do |element|
+            label, value  = element.first, element.last
+            radio_id      = "#{sanitized_object_name}_#{specific_method}_#{value}"
+            label_options = { :text     => label, 
+                              :required => false,
+                              :id       => "#{radio_id}_label", 
+                              :class    => :inline_label, 
+                              :for      => radio_id }
+            
+            builder.radio_button(specific_method, value, html_options.merge(html_options_for_value(value)).merge!(:id => radio_id)) << 
+              builder.label(specific_method, label_options)
+          end.join.html_safe
+        end
+    end
+  end
+end

data/lib/case_form/element/inputs/collection/select_input.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class SelectInput < CollectionInput
+      self.allowed_options << [:prompt, :blank, :allow_multiple, :size]
+      
+      private
+        def default_options
+          super
+          options[:selected]         = checked_values
+          options[:allow_multiple] ||= multiple_collection?
+          options[:multiple]         = true if options[:allow_multiple] == true
+          options[:blank]          ||= true
+          options[:include_blank]    = options.delete(:blank)
+        end
+        
+        def input
+          template.select(object_name, specific_method, collection, options, html_options)
+        end
+    end
+  end
+end

data/lib/case_form/element/inputs/collection_input.rb

@@ -0,0 +1,89 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class CollectionInput < Input
+      include ElementExt::Associationable
+      
+      self.allowed_options << [:disabled, :checked, :selected, :readonly, 
+                               :collection, :label_method, :value_method]
+                               
+      private
+        def default_options
+          super
+          options[:collection] ||= default_collection
+        end
+        
+        def html_options
+          super.except(:disabled, :selected, :checked)
+        end
+        
+        def default_collection
+          association ? extract_from_association_array(association_class.all) : boolean_collection
+        end
+        
+        def boolean_collection
+          [[I18n.t(:"case_form.yes", :default => "Yes"), true], 
+           [I18n.t(:"case_form.no", :default => "No"), false]]
+        end
+        
+        def collection_is_association_class?
+          association && options[:collection] == association.klass
+        end
+        
+        def collection
+          @collection ||= if collection_is_association_class? #:nodoc only class defined, example: :collection => User
+            association_class.all
+          else
+            options[:collection].to_a
+          end
+          extract_collection(@collection)
+        end
+        
+        def extract_collection(collection)
+          return case collection.first
+          when String, Integer, Symbol
+            Array.new(collection).collect! { |c| [c, c] }
+          when association_class
+            extract_from_association_array(collection)
+          else 
+            collection
+          end
+        end
+        
+        def extract_from_association_array(array)
+          if sample = array.first
+            label_method ||= options[:label_method] || collection_methods(:label, sample)
+            value_method ||= options[:value_method] || collection_methods(:value, sample)
+            array.map { |o| [o.send(label_method), o.send(value_method)] }
+          else
+            [[I18n.t(:"case_form.no_items", :default => "No #{sample.class.to_s.pluralize}"), '']]
+          end
+        end
+        
+        def collection_methods(type, sample)
+          CaseForm.send(:"collection_#{type}_methods").find { |m| sample.respond_to?(m.to_sym) }
+        end
+        
+        def multiple_collection?
+          association ? (association_type?(:belongs_to) ? false : true) : false
+        end
+        
+        def html_options_for_value(value)
+          new_options = {}
+          [:checked, :selected, :disabled].each do |option|
+            next unless options[option]
+            new_options[option] = [options[option]].flatten.include?(value) ? true : false
+          end
+          new_options
+        end
+        
+        def object_input_ids
+          @input_ids ||= (association ? object.send(association_method) : [])
+        end
+        
+        def checked_values
+          [options.delete(:checked), options.delete(:selected), object_input_ids].flatten.uniq
+        end
+    end
+  end
+end