generic_form_for 0.0.1

data/lib/generic_form_for/engine.rb

@@ -0,0 +1,11 @@
+module GenericFormFor
+  # @private
+  class Engine < ::Rails::Engine
+    initializer 'generic_form_for.initialize' do
+      ActiveSupport.on_load(:action_view) do
+        include GenericFormFor::Helpers::FormHelper
+      end
+      ActionView::Base.field_error_proc = proc { |input, instance| input }
+    end
+  end
+end

data/lib/generic_form_for/form_builder.rb

@@ -0,0 +1,111 @@
+module GenericFormFor
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    
+    attr_accessor :template
+    
+    def self.configure(name, value = nil)
+      class_attribute(name)
+      self.send(:"#{name}=", value)
+    end
+
+    configure :html5_browser_validate, :true
+    configure :html5_browser_autofocus, :true
+    configure :default_text_field_size, 40
+    configure :required_string, "<abbr>*</abbr>"
+    configure :use_translations, false
+    
+    include GenericFormFor::Helpers::FormHelper
+    include GenericFormFor::Helpers::InputHelper
+    include GenericFormFor::Helpers::FieldsetHelper
+    include GenericFormFor::Helpers::ActionHelper
+    include GenericFormFor::Helpers::ActionsHelper
+    
+    class_attribute :form_wrapper_proc
+    
+    self.form_wrapper_proc = Proc.new{form_html}
+    
+    # form_wrapper do
+    #   form :class => "form-vertical"
+    # end
+    # =>
+    # <form class="form-vertical" ...>
+    # </form>
+    #
+    def self.form_wrapper(&block)
+      self.form_wrapper_proc = block
+    end
+    
+    class_attribute :input_wrapper_proc
+    
+    self.input_wrapper_proc = Proc.new{wrap_in{label_html; input_html; error_html; hint_html}}
+    
+    class_attribute :fieldset_wrapper_proc
+    
+    self.fieldset_wrapper_proc = Proc.new{fieldset_html{legend_html}}
+    # fieldset_wrapper do
+    #   fieldset_html
+    # end
+    # =>
+    # <fieldset>
+    # </fieldset>
+    #
+    # fieldset_wrapper do
+    #   fieldset_html :tag => "div", :class => "fieldset" do
+    #     legend_html :tag => "span", :class => "legend"
+    #   end
+    # end
+    # =>
+    # <div class="fieldset">
+    #   <span class="legend"></span>
+    # </div>
+    #
+    def self.fieldset_wrapper(&block)
+      self.fieldset_wrapper_proc = block
+    end
+    
+    # input_wrapper do
+    #   wrap_in :class => "controls" do 
+    #     label_html
+    #     input_html
+    #     error_html
+    #   end
+    # end
+    # =>
+    # <div class="controls" ...>
+    #   <label for="one">My Column</label>
+    #   <input id="one" type="text" value="1"/>
+    #   <span class="errors">can not be blank</span>
+    # </div>
+    #
+    def self.input_wrapper(&block)
+      self.input_wrapper_proc = block
+    end
+  
+    class_attribute :actions_wrapper_proc
+
+    self.actions_wrapper_proc = Proc.new{actions_html}
+    # actions_wrapper do
+    #   actions_html
+    # end
+    # =>
+    # <div>
+    # </div>
+    #
+    def self.actions_wrapper(&block)
+      self.actions_wrapper_proc = block
+    end
+  
+    class_attribute :action_wrapper_proc
+    
+    self.action_wrapper_proc = Proc.new{action_html{icon_html}}
+    # action_wrapper do
+    #   action_html
+    # end
+    # =>
+    # <input type="submit" value="Save"/>
+    #
+    def self.action_wrapper(&block)
+      self.action_wrapper_proc = block
+    end
+  end
+end

data/lib/generic_form_for/helpers.rb

@@ -0,0 +1,10 @@
+module GenericFormFor
+  # @private
+  module Helpers
+    autoload :FormHelper, 'generic_form_for/helpers/form_helper'
+    autoload :InputHelper, 'generic_form_for/helpers/input_helper'
+    autoload :ActionHelper, 'generic_form_for/helpers/action_helper'
+    autoload :FieldsetHelper, 'generic_form_for/helpers/fieldset_helper'
+    autoload :ActionsHelper, 'generic_form_for/helpers/actions_helper'
+  end
+end

data/lib/generic_form_for/helpers/action_helper.rb

@@ -0,0 +1,52 @@
+module GenericFormFor 
+  module Helpers
+    module ActionHelper
+      
+      def action(name, options = {})
+        options = options.dup
+        options[:as] ||= default_action_type(name, options)
+        
+        klass = action_class(options[:as])
+        klass.new(self, template, @object, @object_name, name, options).to_html
+      end
+      
+      protected
+      
+      def default_action_type(name, options = {}) #:nodoc:
+        case name
+          when :submit then :input
+          when :reset then :input
+          when :button then :button
+          when :cancel then :link
+          when :back then :link
+        end
+      end
+            
+      def action_class(as)
+        @input_classes_cache ||= {}
+        @input_classes_cache[as] ||= begin
+          begin
+            begin
+              standard_action_class_name(as).constantize
+            rescue NameError
+              generic_action_class_name(as).constantize
+            end
+          rescue NameError => e
+            raise GenericFormFor::UnknownActionError, e.message
+          end
+        end
+      end
+
+      # :as => :string # => MyFormBuilder::Inputs::StringInput
+      def standard_action_class_name(as)
+        "#{self.class.to_s.split("::").first}::Actions::#{as.to_s.camelize}Action"
+      end
+      
+      # :as => :string # => GenericFormFor::Inputs::StringInput
+      def generic_action_class_name(as)
+        "GenericFormFor::Actions::#{as.to_s.camelize}Action"
+      end
+      
+    end
+  end
+end

data/lib/generic_form_for/helpers/actions_helper.rb

@@ -0,0 +1,35 @@
+module GenericFormFor 
+  module Helpers
+    module ActionsHelper
+      include I18n
+      
+      attr_accessor :args, :block
+      
+      def actions(*args, &block)
+        self.args, self.block = [*args], block
+        instance_exec &builder.actions_wrapper_proc
+        ""
+      end
+      
+      protected
+      
+      def actions_html(config_options={})
+        options = args.last.is_a?(Hash) ? args.dup.pop : {}
+        template.concat(
+          template.content_tag(
+            options.delete(:tag) || :div,
+            merge_actions_options(options,config_options)
+          ) do
+            template.concat(template.capture(&self.block)) if self.block
+          end
+        )
+      end
+      
+      def merge_actions_options(runtime_options,config_options)
+        runtime_options[:class] = [*runtime_options[:class], *config_options[:class]].compact.join(' ').strip
+        config_options.merge(runtime_options)
+      end
+      
+    end
+  end
+end

data/lib/generic_form_for/helpers/fieldset_helper.rb

@@ -0,0 +1,48 @@
+module GenericFormFor 
+  module Helpers
+    module FieldsetHelper
+      include I18n
+      
+      attr_accessor :args, :block
+      
+      def fieldset(*args, &block)
+        self.args, self.block = [*args], block
+        instance_exec &builder.fieldset_wrapper_proc
+        ""
+      end
+      
+      protected
+      
+      def fieldset_html(config_options={}, &html_block)
+        options = args.last.is_a?(Hash) ? args.dup.pop : {}
+        template.concat(
+          template.content_tag(
+            options.delete(:tag) || :fieldset,
+            merge_fieldset_options(options.except(:legend_html),config_options)
+          ) do
+            template.concat(template.capture(&html_block)) if block_given?
+            template.concat(template.capture(&self.block)) if self.block
+          end
+        )
+      end
+      
+      def legend_html(config_options={})
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        return "" unless args.first
+        # template.concat(
+          template.content_tag(
+            config_options.delete(:tag) || :legend, 
+            translate_legend(args.first), 
+            merge_fieldset_options(options[:legend_html] || {},config_options)
+          )
+        # )
+      end
+      
+      def merge_fieldset_options(runtime_options,config_options)
+        runtime_options[:class] = [*runtime_options[:class], *config_options[:class]].compact.join(' ').strip
+        config_options.merge(runtime_options).except(:legend_html)
+      end
+      
+    end
+  end
+end

data/lib/generic_form_for/helpers/form_helper.rb

@@ -0,0 +1,64 @@
+module GenericFormFor 
+  module Helpers
+    # FormHelper is a wrapper around Rails' built-in form helper
+    module FormHelper
+      
+      mattr_accessor :builder
+      
+      attr_accessor :autofocus
+      attr_accessor :record, :args, :proc
+      
+      # = generic_form_for @post, :html => {:novalidate => true} do |f|
+      # ..form content
+      # Behaves the same as form form. 
+      # Adittional options:
+      #   autofocus: false - will tur off autofocus for this form
+      #              by default autofocus is on and will set autofocus attribute to first visible element
+      def generic_form_for(record, *args, &proc)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        options[:builder] ||= GenericFormFor::FormBuilder
+        self.builder = options[:builder]
+        options[:html] ||= {}
+        self.record, self.args, self.proc = record, *(args << options), proc
+        instance_exec &builder.form_wrapper_proc
+      end
+      
+      def generic_fields_for(name, *args, &proc)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        options[:builder] ||= GenericFormFor::FormBuilder
+        fields_for(name, *(args << options), &proc)
+      end
+      
+      protected
+      
+      def _generic_form_for(record, *args, &proc)
+        form_for(record, *args, &proc)
+      end
+      
+      def form_html(options={})
+        self.args[:html][:class] = [[*self.args[:html][:class]],options.delete(:class)].compact.join(" ").strip
+        
+        if self.args.key?(:autofocus)
+          self.autofocus = self.args.delete(:autofocus)
+        elsif options.key?(:autofocus)
+          self.autofocus = options.delete(:autofocus)
+        else
+          self.autofocus =  @@builder.html5_browser_autofocus
+        end
+        
+        unless self.args[:html].key?(:novalidate)
+          if self.args.key?(:novalidate)
+            self.args[:html][:novalidate] ||= self.args.delete(:novalidate)
+          elsif options.key?(:novalidate)
+            self.args[:html][:novalidate] ||= options.delete(:novalidate)
+          else
+            self.args[:html][:novalidate] ||= !@@builder.html5_browser_validate
+          end
+        end
+          
+        _generic_form_for(self.record, (options || {}).deep_merge(self.args || {}), &self.proc)
+      end
+      
+    end
+  end
+end

data/lib/generic_form_for/helpers/input_helper.rb

@@ -0,0 +1,77 @@
+module GenericFormFor 
+  module Helpers
+    module InputHelper
+      
+      def input(method, options = {})
+        options = options.dup
+        options[:as] ||= default_input_type(method, options)
+        
+        klass = input_class(options[:as])
+        klass.new(self, template, @object, @object_name, method, column_for(method), options).to_html
+      end
+      
+      protected
+      
+      def default_input_type(method, options = {}) #:nodoc:
+        return :select if options.key?(:collection)
+        return :select  if @object && reflection_for(method)
+
+        if column = column_for(method)
+          case column.type
+          when :string
+            return :password  if method.to_s =~ /password/
+            return :email     if method.to_s =~ /email/
+            return :url       if method.to_s =~ /^url$|^website$|_url$/
+            return :phone     if method.to_s =~ /(phone|fax|mobile)/
+            return :search    if method.to_s =~ /^search$/
+          when :integer
+            return :number
+          when :float, :decimal
+            return :number
+          when :timestamp
+            return :datetime
+          end
+          # Try 3: Assume the input name will be the same as the column type (e.g. string_input).
+          return column.type
+        else
+          return :password  if method.to_s =~ /password/
+          return :string
+        end
+      end
+      
+      def column_for(method) #:nodoc:
+        @object.column_for_attribute(method) if @object.respond_to?(:column_for_attribute)
+      end
+      
+      def reflection_for(method) #:nodoc:
+        @object.class.reflect_on_association(method) if @object.class.respond_to?(:reflect_on_association)
+      end
+      
+      def input_class(as)
+        @input_classes_cache ||= {}
+        @input_classes_cache[as] ||= begin
+          begin
+            begin
+              standard_input_class_name(as).constantize
+            rescue NameError
+              generic_input_class_name(as).constantize
+            end
+          rescue NameError => e
+            raise GenericFormFor::UnknownInputError, e.message
+          end
+        end
+      end
+      
+      # :as => :string # => MyFormBuilder::Inputs::StringInput
+      def standard_input_class_name(as)
+        "#{self.class.to_s.split("::").first}::Inputs::#{as.to_s.camelize}Input"
+      end
+      
+      # :as => :string # => GenericFormFor::Inputs::StringInput
+      def generic_input_class_name(as)
+        "GenericFormFor::Inputs::#{as.to_s.camelize}Input"
+      end
+      
+    end
+  end
+end

data/lib/generic_form_for/i18n.rb

@@ -0,0 +1,44 @@
+module GenericFormFor
+  module I18n
+    
+    def translate_placeholder(value)
+      translate(value) do
+        ::I18n.translate(value, :scope => "form_for.#{object_name}.placeholders")
+      end
+    end
+    
+    def translate_hint(value)
+      translate(value) do
+        ::I18n.translate(value, :scope => "form_for.#{object_name}.hints")
+      end
+    end
+    
+    def translate_label(value)
+      translate(value) do
+        ::I18n.translate(value, :scope => "activerecord.attributes.#{object_name}", :default => Proc.new{:"form_for.#{object_name}.attributes.#{value}"})
+      end
+    end
+    
+    def translate_action(value)
+      translate(value) do
+        ::I18n.translate(value, :scope => "form_for.actions", :default => Proc.new{:"actions.#{value}"})
+      end
+    end
+    
+    def translate_legend(value)
+      translate(value) do
+        ::I18n.translate(value, :scope => "form_for.#{object_name}.legends", :default => Proc.new{:"legends.#{value}"})
+      end
+    end
+    
+    def translate(value, &block)
+      if value.is_a?(Symbol)
+        return yield if builder.use_translations
+        value.to_s.camelize
+      else
+        value
+      end
+    end
+    
+  end
+end