case_form 0.0.3

data/lib/case_form/element/inputs/datetime/date_input.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class DateInput < Input
+      self.allowed_options -= [:id]
+      self.allowed_options << [:placeholder, :readonly, :elements, :separator, 
+                               :year, :start_year, :end_year, :month, :short_month, :day, 
+                               :default, :date, :prompt, :blank, :disabled]
+      
+      private
+        def default_options
+          options[:elements]        ||= [:year, :month, :day]
+          options[:order]             = options.delete(:elements)
+          options[:discard_year]      = discard_element?(:year)
+          options[:discard_month]     = discard_element?(:month)
+          options[:discard_day]       = discard_element?(:day)
+          options[:start_year]      ||= nested_date_options(:year, :start, Time.now.year - 10)
+          options[:end_year]        ||= nested_date_options(:year, :end, Time.now.year + 10)
+          options[:use_month_names]   = nested_date_options(:month, :names, nil)
+          options[:use_short_month]   = nested_date_options(:month, :short, false)
+          options[:default]         ||= options.delete(:date) || nil
+          options[:date_separator]    = options.delete(:separator) || " - "
+          options[:include_blank]     = options.delete(:blank) || false
+          super
+        end
+        
+        def input
+          builder.date_select(specific_method, options, html_options)
+        end
+        
+        def discard_element?(type)
+          case 
+          when options.has_key?(type)
+            (options[type] == false) ? true : false
+          when options[:order].include?(type)
+            false
+          end
+        end
+        
+        def nested_date_options(type, option, default)
+          options.delete("#{option}_#{type}".to_sym) || (options[type].delete(option) if options[type].present?) || default
+        end
+    end
+  end
+end

data/lib/case_form/element/inputs/datetime/date_time_input.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class DateTimeInput < Input
+      self.allowed_options -= [:id]
+      self.allowed_options << [:placeholder, :readonly, :elements, :disabled,
+                               :separator, :datetime_separator, :date_separator, :time_separator,
+                               :year, :start_year, :end_year, :month, :short_month, :day, :hour, :minute, :second, 
+                               :minute_step, :default, :datetime, :prompt, :blank]
+                               
+      private
+        def default_options
+          options[:elements]           ||= [:year, :month, :day, :hour, :minute]
+          options[:order]                = options.delete(:elements)
+          options[:discard_year]         = discard_element?(:year)
+          options[:discard_month]        = discard_element?(:month)
+          options[:discard_day]          = discard_element?(:day)
+          options[:discard_hour]         = discard_element?(:hour)
+          options[:discard_minute]       = discard_element?(:minute)
+          options[:include_seconds]      = discard_element?(:second, false, true)
+          options[:start_year]         ||= nested_date_options(:year, :start, Time.now.year - 10)
+          options[:end_year]           ||= nested_date_options(:year, :end, Time.now.year + 10)
+          options[:use_month_names]      = nested_date_options(:month, :names, nil)
+          options[:use_short_month]      = nested_date_options(:month, :short, false)
+          options[:minute_step]        ||= nested_date_options(:minute, :step, 1)
+          options[:datetime_separator] ||= options.delete(:separator) || nil
+          options[:default]            ||= options.delete(:datetime) || nil
+          options[:include_blank]        = options.delete(:blank) || false
+          super
+        end
+        
+        def input
+          builder.datetime_select(specific_method, options, html_options)
+        end
+        
+        def discard_element?(type, t = true, f = false)
+          case 
+          when options.has_key?(type)
+            (options[type] == false) ? t : f
+          else 
+            options[:order].include?(type) ? f : t
+          end
+        end
+        
+        def nested_date_options(type, option, default)
+          options.delete("#{option}_#{type}".to_sym) || (options[type].delete(option) if options[type].present?) || default
+        end
+    end
+  end
+end

data/lib/case_form/element/inputs/datetime/time_input.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class TimeInput < Input
+      self.allowed_options -= [:id]
+      self.allowed_options << [:placeholder, :readonly, :elements, :separator, :time, :default, 
+                               :prompt, :minute_step, :date, :blank, :disabled]
+      
+      private
+        def default_options
+          options[:elements]        ||= [:hour, :minute]
+          options[:time_separator]    = options.delete(:separator) || " : "
+          options[:include_blank]     = options.delete(:blank) || false
+          options[:include_seconds]   = time_seconds?
+          options[:ignore_date]       = with_date?
+          options[:default]         ||= options.delete(:time) || nil
+          super
+        end
+        
+        def input
+          builder.time_select(specific_method, options, html_options)
+        end
+        
+        def time_seconds?
+          options[:elements].include?(:second) || false
+        end
+        
+        def with_date?
+          @date ||= options.delete(:date) || false
+          !@date
+        end
+    end
+  end
+end

data/lib/case_form/element/inputs/datetime/time_zone_input.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class TimeZoneInput < Input
+      self.allowed_options << [:readonly, :blank, :disabled, 
+                               :priority_zones, :zones, :default, :time_zone]
+      
+      private
+        def default_options
+          options[:default]       = options.delete(:time_zone) || "UTC"
+          options[:include_blank] = options.delete(:blank) || false
+          super
+        end
+        
+        def input
+          builder.time_zone_select(specific_method, priority_zones, options, html_options)
+        end
+        
+        def priority_zones
+          options.delete(:priority_zones) || nil
+        end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class FileInput < Input
+      self.allowed_options << [:multiple, :readonly, :disabled]
+      
+      private
+        def input
+          builder.file_field(specific_method, html_options)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class HiddenInput < Input
+      self.allowed_options -= [:autofocus, :required, :label, :hint, :error]
+      
+      def generate
+        builder.hidden_field(specific_method, html_options)
+      end
+      
+      private
+        def default_options
+          options[:class] ||= [:input, :hidden]
+        end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class NumberInput < Input
+      self.allowed_options << [:as, :min, :max, :in, :step, :readonly, :disabled]
+      
+      private
+        def default_options
+          options[:min]  ||= input_limit(:minimum) 
+          options[:max]  ||= input_limit(:maximum)
+          options[:step] ||= number_step
+          options[:size] ||= CaseForm.input_size
+          super
+        end
+        
+        def input
+          builder.send("#{input_type}_field", specific_method, html_options)
+        end
+        
+        def input_limit(type)
+          validations = object.class.validators_on(method).select { |v| v.kind == :length }
+          if validations.any?
+            validations.first.options[type]
+          elsif object_column_type?(:decimal)
+            value = (10**(object_column.precision - object_column.scale))-number_step
+            value = value*(-1) if type == :minimum
+            value.to_f
+          else
+            nil
+          end
+        end
+        
+        def number_step
+          if object_column_type?(:decimal)
+            (10**(-object_column.scale)).to_f
+          else
+            CaseForm.number_step
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class SearchInput < Input
+      self.allowed_options -= [:required, :error, :hint]
+      
+      private
+        def wrapper_options
+          wrapper_options = super
+          wrapper_options[:class] << :search
+          wrapper_options
+        end
+        
+        def contents
+          contents = []
+          [:label, :input].each do |element| 
+            if options[element] == false
+              options.delete(element)
+              next
+            else
+              contents << send(element)
+            end
+          end
+          contents.join.html_safe
+        end
+        
+        def input
+          builder.search_field(specific_method, html_options)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class StringInput < Input
+      self.allowed_options << [:as, :size, :placeholder, :pattern, :disabled, :readonly, :maxlength]
+      
+      private
+        def default_options
+          options[:size] ||= input_size
+          super
+        end
+        
+        def input
+          builder.send("#{input_type}_field", specific_method, html_options)
+        end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class TextInput < Input
+      self.allowed_options << [:cols, :rows, :readonly, :maxlength, :escape, :disabled, :placeholder]
+      
+      private
+        def default_options
+          options[:cols] ||= CaseForm.textarea_cols
+          options[:rows] ||= CaseForm.textarea_rows
+          super
+        end
+        
+        def input
+          builder.text_area(specific_method, html_options)
+        end
+    end
+  end
+end

data/lib/case_form/element/label.rb

@@ -0,0 +1,52 @@
+module CaseForm
+  module Element
+    class Label < Base
+      include ElementExt::Validationable
+      include ElementExt::Columnable
+      
+      self.allowed_options << [:for, :text, :required]
+      
+      attr_accessor :method
+      
+      # Initialize label object
+      #
+      def initialize(builder, method, options={})
+        @method = method
+        super(builder, options)
+      end
+      
+      # Generate label with defined text and HTML options
+      #
+      def generate
+        template.label(object_name, method, text, html_options)
+      end
+            
+      private
+        # Distribute default options for label.
+        #
+        def default_options
+          options[:class]    ||= [:label]
+          options[:id]       ||= "#{sanitized_object_name}_#{specific_method}_label"
+        end
+        
+        # Generate label text with optional required symbol.
+        #
+        def text
+          @text  = options.delete(:text) || translated_text
+          @text += CaseForm.require_symbol if required?
+          @text
+        end
+        
+        # Translate label text with I18n.
+        # 
+        def translated_text
+          lookups = []
+          lookups << :"activerecord.attributes.#{object_name}.#{method}"
+          lookups << :"activemodel.attributes.#{object_name}.#{method}"
+          lookups << :"case_form.attributes.#{object_name}.#{method}"
+          lookups << method.to_s.humanize
+          I18n.t(lookups.shift, :default => lookups)
+        end
+    end
+  end
+end

data/lib/case_form/element/nested_model.rb

@@ -0,0 +1,105 @@
+# coding: utf-8
+module CaseForm
+  module Element
+    class NestedModel < Base
+      include ElementExt::Associationable
+      
+      self.allowed_options << [:destructor, :generator, :collection, :fields]
+      
+      attr_accessor :method, :block
+      
+      def initialize(builder, method, options={}, &block)
+        @method = validate_nested_attributes_association(method, builder.object)
+        @block  = block
+        super(builder, options)
+      end
+      
+      def generate
+        contents = []
+        contents << nested_model_contents
+        contents << builder.new_object(method, :fields => (block.nil? ? options[:fields] : block)) if allow_create?
+        contents.join.html_safe
+      end
+      
+      private
+        def default_options
+          super
+          options[:custom]               = {}
+          options[:custom][:association] = method
+          options[:collection]         ||= default_collection
+          options[:fields]             ||= default_fields
+        end
+        
+        def nested_attributes_method_defined?
+          object.respond_to?(:"#{method}_attributes=")
+        end
+        
+        def nested_model_contents
+          contents = []
+          nested_models = [collection].flatten.compact
+          nested_models.each do |object|
+            contents << nested_model(object)
+          end
+          Element::Fieldset.new(builder, :class => "#{method}_association").generate(contents.join.html_safe) unless contents.blank?
+        end
+        
+        def nested_model(object)
+          template.content_tag(:div, nil, :class => "#{method}_association_inputs") do
+            builder.case_fields_for(method, object) do |b|
+              unless block.nil?
+                block.call(b) << (b.destroy_object if allow_destroy?)
+              else
+                fields = [options[:fields]].flatten 
+                fields << :_destroy if allow_destroy?
+                template.concat(b.attributes(*fields))
+              end
+            end
+          end
+        end
+        
+        def allow_create?
+          if collection_association?
+            if options.has_key?(:generator)
+              options[:generator] != false
+            elsif block.is_a?(Proc)
+              false
+            else
+              true
+            end
+          else
+            false
+          end
+        end
+        
+        def allow_destroy?
+          if collection_association?
+            if options.has_key?(:desctructor)
+              options[:destructor] != false
+            elsif block.is_a?(Proc)
+              false
+            else 
+              object.class.nested_attributes_options[method.to_sym][:allow_destroy]
+            end
+          else
+            false
+          end
+        end
+        
+        def default_collection
+          object.send(method) || (new_nested_model unless collection_association?)
+        end
+        
+        def default_fields
+          association_class.content_columns.map(&:name).map(&:to_sym) - CaseForm.locked_columns
+        end
+        
+        def new_nested_model
+          collection_association? ? association_class.new : object.send(:"build_#{method}")
+        end
+        
+        def collection
+          options[:collection]
+        end
+    end
+  end
+end