case_form 0.0.3

data/lib/case_form/core_ext/form_helper.rb

@@ -0,0 +1,54 @@
+module CaseForm
+  module FormHelper
+    @@default_field_error_proc = nil
+
+    # Override the default ActiveRecordHelper behaviour of wrapping the input.
+    # This gets taken care of semantically by adding an error class to the wrapper tag
+    # containing the input.
+    FIELD_ERROR_PROC = proc do |html_tag, instance_tag|
+      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
+    
+    # Define case_form_for and case_fields_for
+    [:form_for, :fields_for].each do |helper|
+      class_eval <<-METHOD, __FILE__, __LINE__
+        def case_#{helper}(record_or_name_or_array, *args, &block)
+          options = args.extract_options!
+          options[:builder] = CaseForm::FormBuilder
+          css_class = case record_or_name_or_array
+            when String, Symbol then record_or_name_or_array.to_s
+            when Array then dom_class(record_or_name_or_array.last)
+            else dom_class(record_or_name_or_array)
+          end
+          options[:html] ||= {}
+          options[:html][:class] = "case_form \#{css_class} \#{options[:html][:class]}".strip
+    
+          with_custom_field_error_proc do
+            #{helper}(record_or_name_or_array, *(args << options), &block)
+          end
+        end
+      METHOD
+    end
+    
+    # Define remote_case_form_for
+    class_eval <<-METHOD
+      def remote_case_form_for(record_or_name_or_array, *args, &block)
+        options = args.extract_options!
+        options[:remote] = true
+          
+        case_form_for(record_or_name_or_array, *(args << options), &block)
+      end
+    METHOD
+  end
+end
+
+# Include CaseForm
+ActionView::Helpers.send :include, CaseForm::FormHelper

data/lib/case_form/core_ext/layout_helper.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+module CaseForm
+  module LayoutHelper
+    def case_form_stylesheet_link_tag
+      stylesheet_link_tag("case_form_changes", "case_form")
+    end
+    alias_method :case_form_stylesheet, :case_form_stylesheet_link_tag
+    
+    def case_form_javascript_include_tag
+      javascript_include_tag("case_form")
+    end
+    alias_method :case_form_js, :case_form_javascript_include_tag
+  end
+end
+
+ActionView::Base.send :include, CaseForm::LayoutHelper

data/lib/case_form/core_ext/sentence_error.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+module CaseForm
+  module SentenceError
+    # Returns all the full error messages as a sentences in an array.
+    #
+    #   class User
+    #     validates_presence_of :password, :address, :email
+    #     validates_length_of :password, :in => 5..30
+    #     validates_confirmation_of :password
+    #   end
+    #
+    #   user = User.create(:address => '123 First St.')
+    #   user.errors.full_sentences # =>
+    #     ["Password is too short (minimum is 5 characters), can't be blank and should match confirmation"]
+    #
+    def full_sentences(options={})
+      full_sentences = []
+
+      keys.each do |attribute|
+        if attribute == :base
+          self[attribute].each {|m| full_sentences << m }
+        else
+          attr_name = attribute.to_s.gsub('.', '_').humanize
+          attr_name = @base.class.human_attribute_name(attribute, :default => attr_name)
+
+          messages = Array.wrap(self[attribute])
+          messages.collect! { |m| I18n.t(:"errors.format", :message => m, :attribute => nil).strip }
+
+          full_sentences << (attr_name + " " + messages.to_sentence(options))
+        end
+      end
+
+      full_sentences
+    end
+  end
+end
+
+ActiveModel::Errors.send :include, CaseForm::SentenceError

data/lib/case_form/element.rb

@@ -0,0 +1,40 @@
+
+
+# coding: utf-8
+module CaseForm
+  module Element
+    autoload :Base,                  'case_form/element/base'
+                                     
+    autoload :Fieldset,              'case_form/element/fieldset'
+                                                
+    autoload :Input,                 'case_form/element/input'
+    autoload :StringInput,           'case_form/element/inputs/string_input'
+    autoload :TextInput,             'case_form/element/inputs/text_input'
+    autoload :HiddenInput,           'case_form/element/inputs/hidden_input'
+    autoload :SearchInput,           'case_form/element/inputs/search_input'
+    autoload :FileInput,             'case_form/element/inputs/file_input'
+    autoload :DateTimeInput,         'case_form/element/inputs/datetime/date_time_input'
+    autoload :DateInput,             'case_form/element/inputs/datetime/date_input'
+    autoload :TimeInput,             'case_form/element/inputs/datetime/time_input'
+    autoload :TimeZoneInput,         'case_form/element/inputs/datetime/time_zone_input'
+    autoload :NumberInput,           'case_form/element/inputs/number_input'
+    autoload :CollectionInput,       'case_form/element/inputs/collection_input'
+    autoload :SelectInput,           'case_form/element/inputs/collection/select_input'
+    autoload :CheckboxInput,         'case_form/element/inputs/collection/checkbox_input'
+    autoload :RadioInput,            'case_form/element/inputs/collection/radio_input'
+                                             
+    autoload :Label,                 'case_form/element/label'
+    autoload :Hint,                  'case_form/element/hint'
+                                                
+    autoload :Button,                'case_form/element/button'
+                                     
+    autoload :Error,                 'case_form/element/error'
+    autoload :SimpleError,           'case_form/element/errors/simple_error'
+    autoload :ComplexError,          'case_form/element/errors/complex_error'
+    
+    autoload :NestedModel,           'case_form/element/nested_model'
+    autoload :Handle,                'case_form/element/nested_models/handle'
+    autoload :GeneratorHandle,       'case_form/element/nested_models/handles/generator_handle'
+    autoload :DestructorHandle,      'case_form/element/nested_models/handles/destructor_handle'
+  end
+end

data/lib/case_form/element/base.rb

@@ -0,0 +1,95 @@
+require 'case_form/element_ext/naming'
+require 'case_form/element_ext/columnable'
+require 'case_form/element_ext/validationable'
+require 'case_form/element_ext/associationable'
+
+# coding: utf-8
+module CaseForm
+  module Element
+    class Base
+      include ElementExt::Naming
+      
+      HTML_OPTIONS = [:id, :class, :style, :readonly, :disabled, :type, :name,
+                      :autofocus, :placeholder, :required, :multiple, :checked, :selected, 
+                      :for, :min, :max, :step, :pattern, :size, :maxlength, :cols, :rows]
+      
+      class_inheritable_accessor :allowed_options
+      self.allowed_options = [:custom, :id, :class, :style]
+
+      attr_accessor :builder, :options
+
+      def initialize(builder, options={})
+        @builder, @options = builder, options.symbolize_keys!
+        validate_options
+        default_options
+      end
+
+      private
+        def validate_options #:nodoc same as assert_valid_keys for Hash
+          allowed = self.class.allowed_options.flatten
+          banned = options.keys - allowed
+          raise(ArgumentError, "Unknown option(s): #{banned.join(', ')}. Available options: #{allowed.join(', ')}") unless banned.empty?
+        end
+        
+        def default_options
+          options         ||= {}
+          options[:class] ||= []
+          options[:id]    ||= []
+        end
+        
+        def wrapper_options
+          wrapper_options = {}
+          wrapper_options[:class] = []
+          wrapper_options
+        end
+        
+        def html_options
+          options.slice(*HTML_OPTIONS).merge(custom_options)
+        end
+        
+        def custom_options
+          custom_options = {}
+          return custom_options unless options.has_key?(:custom)
+          raise(ArgumentError, "Invalid :custom options! Custom options should be hash with key and value.") unless options[:custom].is_a?(Hash)
+          options.delete(:custom).each { |key, value| custom_options[:"data-#{key}"] = value }
+          custom_options
+        end
+        
+        def object_name
+          @builder.object_name
+        end
+
+        def object
+          @builder.object
+        end
+                
+        def template
+          builder.template
+        end
+        
+        def required?
+          if options.has_key?(:required)
+            options[:required]
+          elsif respond_to?(:validationable?) && validationable? && method_validations.any? { |v| v.kind == :presence }
+            true
+          elsif respond_to?(:columnable?) && object_column.present? && object_column.null == false
+            true
+          else
+            CaseForm.all_fields_required
+          end
+        end
+        
+        def new?
+          object.new_record?
+        end
+        
+        def action
+          new? ? :new : :edit
+        end
+        
+        def wrapper_tag
+          CaseForm.wrapper_tag
+        end
+    end
+  end
+end

data/lib/case_form/element/button.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class Button < Base
+      self.allowed_options << [:disabled, :text, :as]
+      
+      # Generate button with defined text and HTML options
+      #
+      def generate
+        template.content_tag wrapper_tag, button, wrapper_options
+      end
+      
+      private
+        # Distribute default options for button.
+        #
+        def default_options
+          options[:as]       ||= :commit
+          options[:class]    ||= [:button]
+          options[:id]       ||= "#{builder.object_name}_#{button_type}"
+          options[:type]     ||= button_type
+          options[:name]     ||= button_type
+        end
+        
+        # Distribute wrapper options for button.
+        #
+        def wrapper_options
+          wrapper_options = super
+          wrapper_options[:class] << :element
+          wrapper_options
+        end
+        
+        # Create submit button
+        #
+        def button
+          builder.submit(text, html_options)
+        end
+        
+        # Generate button text.
+        #
+        def text
+          options.delete(:text) || translated_text
+        end
+        
+        # Translate button text
+        def translated_text
+          lookups = []
+          lookups << :"#{builder.object_name}.#{button_type}"
+          lookups << :"#{button_type}"
+          lookups << default_button_text
+          I18n.t(lookups.shift, :scope => :"case_form.buttons", :default => lookups)
+        end
+        
+        # Default button text
+        def default_button_text
+          button_type == :submit ? (new? ? "Create" : "Update") : "Reset"
+        end
+        
+        # Button type (available: :commit and :reset)
+        def button_type
+          options[:as]
+        end
+    end
+  end
+end

data/lib/case_form/element/error.rb

@@ -0,0 +1,54 @@
+module CaseForm
+  module Element
+    class Error < Base
+      self.allowed_options << [:tag, :as, :connector, :last_connector]
+      
+      private
+        # Defined error HTML tag
+        #
+        def error_tag
+          options.delete(:tag) || CaseForm.error_tag
+        end
+        
+        # Defined error type
+        #
+        # == Allowed types:
+        # * :sentence
+        # * :list
+        #
+        def error_type
+          options.delete(:as) || CaseForm.error_type
+        end
+        
+        # Defined error connector (default ', ')
+        #
+        def error_connector
+          options.delete(:connector) || CaseForm.error_connector
+        end
+        
+        # Defined last error connector (default ' and '). Used in sentence with many errors on one method. 
+        #
+        def last_error_connector
+          options.delete(:last_connector) || CaseForm.last_error_connector
+        end
+        
+        # Type of error 
+        def error_messages
+          list? ? translated_list : translated_sentence
+        end
+        
+        def list?
+          error_type == :list
+        end
+        
+        def sentence?
+          error_type == :sentence
+        end
+        
+        # OrderedHash with all errors
+        def errors
+          object.errors
+        end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+module CaseForm
+  module Element
+    class ComplexError < Error
+      self.allowed_options << [:header_tag, :header_message, :message_tag, :message]
+      
+      # Generate all error messages as HTML <ul> list with optional header and message.
+      # 
+      def generate
+        contents = []
+        contents << template.content_tag(header_tag, header_message) unless options[:header_message] == false
+        contents << template.content_tag(message_tag, message)       unless options[:message] == false
+        contents << template.content_tag(:ul, error_messages)
+        
+        template.content_tag(error_tag, contents.join.html_safe, html_options)
+      end
+      
+      private
+        # Distribute default options for complex errors.
+        #
+        def default_options
+          options[:class] ||= [:errors]
+          options[:id]    ||= "#{object_name}_errors"
+        end
+        
+        # Error messages as list.
+        #
+        # == Example:
+        #
+        #   # object.errors = { :name => ['can't be blank', 'should be uniq'],
+        #                       :price => 'should be more than 10' }
+        #
+        #   <ul>
+        #     <li>Name can't be blank</li>
+        #     <li>Name should be uniq</li>
+        #     <li>Price should be more than 10</li>
+        #   </ul>
+        #                 
+        def translated_list
+          (errors.full_messages.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'],
+        #                       :price => 'should be more than 10' }
+        #
+        #   <ul>
+        #     <li>Name can't be blank and should be uniq</li>
+        #     <li>Price should be more than 10</li>
+        #   </ul>
+        #
+        def translated_sentence
+          (errors.full_sentences(:words_connector     => error_connector, 
+                                 :last_word_connector => last_error_connector,
+                                 :two_words_connector => last_error_connector).collect { |msg| template.content_tag :li, msg }).join.html_safe
+        end
+        
+        # Defined error header message HTML tag.
+        #
+        def header_tag
+          options.delete(:header_tag) || CaseForm.complex_error_header_tag
+        end
+        
+        # Defined error header message from option or I18n.
+        #
+        def header_message
+          options.delete(:header_message) || translated_header_message
+        end
+        
+        # Translated error header message by I18n.
+        #
+        def translated_header_message
+          lookups = []
+          lookups << :"activemodel.errors.template.header_message"
+          lookups << :"activerecord.errors.template.header_message"
+          lookups << :"case_form.errors.template.header_message"
+          lookups << "Some errors prohibited this object from being saved"
+          I18n.t(lookups.shift, :default => lookups)
+        end
+        
+        # Defined error message HTML tag.
+        #
+        def message_tag
+          options.delete(:message_tag) || CaseForm.complex_error_message_tag
+        end
+        
+        # Defined error message from option or I18n.
+        #
+        def message
+          options.delete(:message) || translated_message
+        end
+        
+        # Translated error message by I18n.
+        #
+        def translated_message
+          lookups = []
+          lookups << :"activemodel.errors.template.message"
+          lookups << :"activerecord.errors.template.message"
+          lookups << :"case_form.errors.template.message"
+          lookups << "There were problems with the following fields:"
+          I18n.t(lookups.shift, :default => lookups)
+        end
+    end
+  end
+end