king_views 1.0.0

data/king_form/lib/king_form/builder/form_fields_overrides.rb

@@ -0,0 +1,146 @@
+module KingForm
+  module Builder
+    ##########################################################################
+    # Modified core html tag methods.
+    module FormFieldsOverrides
+#    private
+      def text_field(method, opts = {})
+        opts[:class] = (opts[:class] || '')  + ' text'
+        info_text = opts.delete(:info)
+        super(method, opts) + info_tag(info_text || method)
+      end
+
+      def text_area(method, opts = {})
+        opts[:size] ||= "20x3" # sized needed for valid html
+        info_text = opts.delete(:info)
+        super(method, opts) + info_tag(info_text || method)
+      end
+
+      def check_box(method, opts = {})
+        info_text = opts.delete(:info)
+        super(method, opts) + info_tag(info_text || method)
+      end
+
+      def radio_button(method, tag_value, opts = {})
+        info_text = opts.delete(:info)
+        super(method, tag_value, opts) + info_tag(info_text || method)
+      end
+
+      def select(method, choices, opts = {}, html_opts = {})
+        info_text = opts.delete(:info)
+        super(method, choices || [], opts, html_opts) + info_tag(info_text || method)
+      end
+
+      def date_select(method, opts = {}, html_opts = {})
+        info_text = opts.delete(:info)
+        super(method, opts, html_opts) + info_tag(info_text || method)
+      end
+
+      def password_field(method, opts = {})
+        info_text = opts.delete(:info)
+        super(method, opts) + info_tag(info_text || method)
+      end
+
+      def file_field(method, opts = {})
+        info_text = opts.delete(:info)
+        super(method, opts) + info_tag(info_text || method)
+      end
+
+      ###########
+
+      def text_field_tag(name, value = nil, opts = {})
+        opts[:class] = (opts[:class] || '')  + ' text'
+        name, infos, opts = build_id_name_info(name, opts)
+        @template.text_field_tag(name, value, opts) + infos
+      end
+      
+      # Create a hidden field tag and construct its fieldname (object[name]) from
+      # the current object
+      # When the name is beeing passed in as string its just taken like it is
+      # ==== Parameter
+      # same as hidden_field_tag in Rails plus:
+      # name<String>:: The name is passed right thought to hidden_field_tag
+      # name<Symbol>:: The name is put together with current object =>  object[name]
+      def hidden_field_tag(name, value = nil, opts = {})
+        name, infos, opts = build_id_name_info(name, opts)
+        @template.hidden_field_tag(name, value, opts) # obviously no infos
+      end
+
+      def password_field_tag(name = "password", value = nil, opts = {})
+        opts[:class] = (opts[:class] || '')  + ' text'
+        name, infos, opts = build_id_name_info(name, opts)
+        @template.password_field_tag(name, value, opts) + infos
+      end
+
+      # Overide the native filefield tag
+      # ==== Parameter
+      # name<(Symbol,String)>:: The name for the field. when given as symbol, the
+      # name is constructed for the current object oject[name] and an id is build.
+      # If passed as string, the name is taken right away and no auto id is created
+      # opts<Hash{Symbol=>String}>:: All file_field opts +
+      #   :info which is taken for the help text
+      def file_field_tag(name, opts = {})
+        opts[:class] ||=  nil
+        name, infos, opts = build_id_name_info(name, opts)
+        @template.file_field_tag(name, opts) + infos
+      end
+
+      def text_area_tag(name, value, opts = {})
+        opts[:size] ||= "20x3" # sized needed for valid html
+        name, infos, opts = build_id_name_info(name, opts)
+        @template.text_area_tag(name, value, opts) + infos
+      end
+
+      def check_box_tag(name, value = "1", checked = false, opts = {})
+        name, infos, opts = build_id_name_info(name, opts)
+        @template.check_box_tag(name, value, checked, opts) + infos
+      end
+
+      # Overriden rails select_tag
+      # Constructs the fieldname
+      # ==== Example
+      # - dl_fields_for @user do |u|
+      #   = u.selection :project_id, :choices => @projects, :title => "Projects"
+      #   = u.selection "user[custom_field]", :choices => @some_choices
+      #
+      # ==== Parameter
+      # name<Symbol, String>:: If symbol: the name and id is auto-constructed object[field_name]
+      # and the info tag is build from translation see info_tag.
+      # If String: The name is taken as it is, no id and info is auto-created.
+      # They must be passed in as opts[:id], opts[:info]
+      # option_tags<String>:: The opts as html for the select
+      # opts<Hash{Symbol=>String}>:: Rails select_tag opts + :info
+      def select_tag(name, option_tags = nil, opts = {})
+        name, infos, opts = build_id_name_info(name, opts)
+        @template.select_tag(name, option_tags, opts) + infos
+      end
+
+      # Builds name, opts, infos according to the given name type
+      # ==== Parameter
+      # name<Symbol>::
+      # - id for an element is build => client_name_id
+      # - info tag is looked up in I18n => see KingForm::Builder::Base info_tag
+      # - fieldname is assumed to belong to an object => client[name]
+      # name<String>::
+      # - id for an element must be present in opts[:id]
+      # - info tag is looked up in I18n when opts[:info] is a symbol, else string is taken #KingForm::Builder::Base info_tag
+      # - fieldname is assumed to belong to an object => client[name]
+      #
+      def build_id_name_info(name, opts)
+        if name.is_a?(Symbol)
+          opts[:id] ||= build_id(name)
+          # build info tag, cause info_tag(:symbol) is looking into I18n transl
+          infos = info_tag( opts.delete(:info) || name)
+          #now set real name as string
+          name = "#{@object_name}[#{name}]"
+        else
+          opts[:id] ||= nil
+          info_text = opts.delete(:info)
+          infos = info_text ? info_tag( info_text) : ''
+        end
+        [name, infos, opts ]
+      end
+
+    end
+  end
+end

data/king_form/lib/king_form/builder/labeled.rb

@@ -0,0 +1,116 @@
+module KingForm
+  module Builder
+    # Create forms with a fieldset->div->label->input structure
+    # ==== Example haml
+    #  - labeled_form_for(current_object) do |f|
+    #    - f.section _('legend.user.details') do
+    #      = f.text :first_name
+    #      = f.text :last_name
+    #
+    # => #<form ..>
+    #       <fieldset>
+    #         <legend>User Details</legend>
+    #         <div>
+    #           <label>Firstname</label>
+    #           <input type='text' value='Otto'/>
+    #         </div>
+    #         <div>
+    #           <label>Lastname</label>
+    #           <input type='text' value='Bismark'/>
+    #         </div>
+    #       </fieldset>
+    #      </form>
+    #
+    class Labeled < KingForm::Builder::Base
+      # Create a section(fieldset) within a form
+      # A section is a group of related object information with name/value pairs,
+      # like all dates of an object or the users name fields(last/first/title/nick).
+      #
+      # A section html consists of a fieldset > legend > div > label > input
+      # The dt holds the title/description (DefinitionType) of the current field
+      # The dd holds the value.
+      # This wrapup is preferred over ul/li or other listing types because of
+      # the semantic meaning of the html
+      #
+      #===Example haml
+      #    - f.section _('legend.user.details') do
+      #      = f.text :first_name
+      #      = f.text :last_name
+      #
+      # => # <fieldset>
+      #       <legend>User Details</legend>
+      #       <div>
+      #         <label>Firstname</label>
+      #         <input type='text' value='Otto'/>
+      #       </div>
+      #       <div>
+      #         <label>Lastname</label>
+      #         <input type='text' value='Bismark'/>
+      #       </div>  #
+      #      </fieldset>
+      #
+      def section(title = nil, options = {}, &block)
+        raise ArgumentError if title && !title.is_a?(String)
+        @template.haml_tag :fieldset, options do
+          @template.haml_tag :legend, title unless title.blank?
+          @template.haml_concat( @template.capture_haml(&block) )
+        end
+      end
+
+      # Show multiple inputs in one line (div tag)
+      # === Example haml
+      # - f.bundle _('Gender and Title') do
+      #   = f.selection :gender
+      #   = f.text :title, :medium
+      # ==== Parameter
+      # title<String>:: The name used as label
+      def bundle(title = nil, options = {}, &block)
+        @config[:bundle] = true
+        @bundle_counter = 0
+        tags = @template.capture(&block)
+        @config[:bundle] = false
+        @template.concat( tag_wrapper(title, tags, options) )
+      end
+
+      # Add titles/labels to input tag and wrap in div
+      #
+      # ==== Parameter
+      # fieldname_or_title<String Symbol>:: The title for the field
+      # tags<String>:: html tags as string
+      # options<Hash{Symbold=>String}>:: options for the surrounding html
+      # ==== Options
+      # :label => options for label
+      # :div => options for surrounding div
+      # :align => alignment in table
+      def tag_wrapper(fieldname_or_title, tags, options = {})
+        if @config[:bundle]
+          @bundle_counter += 1
+          tags
+        elsif @config[:table] # called from "table" => build a table cell (td)
+          # Only in first row: Build column header
+          if @config[:row_number] == 1
+            @config[:column_header].push :title => build_title(fieldname_or_title),
+                                         :options => { :align => options[:align] || 'left' }
+          end
+          @template.capture_haml do
+            @template.haml_tag(:td, tags, options)
+          end
+        else
+          out = if tags.match /checkbox/ # wrap only checkbox tag into to label, so it is clickable
+                  label_tag(fieldname_or_title + tags, options[:label])
+                else # other tags stay outside label tag, because they don't like to be wrapped sometimes
+                  label_tag(fieldname_or_title, options[:label]) + tags
+                end
+          "<div> #{out}</div>"
+        end
+      end
+
+      # Build a label tag
+      #TODO enhance with option <label for="fieldname">
+      def label_tag(fieldname_or_title, options = {})
+        fieldname_or_title.blank? ? "" : content_tag(:label, build_title(fieldname_or_title), options)
+      end
+
+    end # labeled class
+  end #module
+end#module

data/king_form/lib/king_form/helper.rb

@@ -0,0 +1,97 @@
+module KingForm
+  module Helper
+
+    # renders a form with the # KingForm::Builder::DefinitionList
+    # It allows to devide the form into sections(fieldsets) where each contains
+    # a definition list with dl/dd blocks for each label/field
+    #
+    # Read on to find out more about the available tags/fieldtypes
+    #
+    # === Example haml
+    #  -dl_form_for(:client, :url => object_url, :html => { :method => :put }) do |f|
+    #    - f.section 'Client Details' do
+    #      = f.text :number
+    #      - f.bundle 'Gender/Title' do
+    #        = f.selection :gender
+    #        = f.text :title, :class => 'medium'
+    #      = f.text :position
+    #      = f.text :last_name
+    #      = f.date :birthday
+    #   # =><form .. method..> <fieldset>
+    #       <legend>Client Details</legend>
+    #       <dl>
+    #         <dt>Number</dt>
+    #         <dd><input name=client[number] type=text></dd>
+    #         ....
+    #         </dl>
+    #        </fieldset></form>
+    #
+    def dl_form_for(record_or_name_or_array, *args, &proc)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options[:builder] = KingForm::Builder::DefinitionList
+      form_for(record_or_name_or_array, *(args << options), &proc)
+    end
+
+    def dl_fields_for(record_or_name_or_array, *args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options[:builder] =  KingForm::Builder::DefinitionList
+      fields_for(record_or_name_or_array, *(args << options), &block)
+    end
+
+    # renders a form with the KingForm::Builder::Labeled
+    # It allows to devide the form into sections(fieldsets) where each contains
+    # a definition list with dl/dd blocks for each label/field
+    #
+    # Read on to find out more about the avalable tags/fieldtypes
+    #
+    # === Example haml
+    #  -labeled_form_for(:client, :url => object_url, :html => { :method => :put }) do |f|
+    #    - f.section 'Client Details' do
+    #      = f.text :number
+    #      - f.bundle 'Gender/Title' do
+    #        = f.text :gender
+    #        = f.text :title, :class => 'medium'
+    #   # =><form ...>
+    #        <fieldset>
+    #         <legend>Client Details</legend>
+    #         <div>
+    #           <label>Number </label>
+    #           <input name=client[number] type=text>
+    #         </div>
+    #         <div>
+    #           <label>Gender/Title</label>
+    #           <input type='text' name='client[gender]' value='male'/>
+    #           <input type='text' name='client[title]' value='Prof.'/>
+    #         </div>
+    #       </fieldset>
+    #      </form>
+    #
+    def labeled_form_for(record_or_name_or_array, *args, &proc)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options[:builder] =  KingForm::Builder::Labeled
+      form_for(record_or_name_or_array, *(args << options), &proc)
+    end
+
+    def labeled_fields_for(record_or_name_or_array, *args, &block)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options[:builder] =  KingForm::Builder::Labeled
+      fields_for(record_or_name_or_array, *(args << options), &block)
+    end
+
+    # Returns an array for a given settings which has comma-seperated values.
+    # In the view those are used for select boxes
+    # Accepts an optional block to change the array elements
+    def make_select(values, &block)
+      return nil unless values
+      raise ArgumentError unless values.class == String
+
+      result = []
+      values.split(',').each do |s|
+        s.strip!
+        s = yield(s) if block_given?
+        result.push(s)
+      end
+      result
+    end
+  end
+end

data/king_form/lib/king_form/nested_form_helper.rb

@@ -0,0 +1,61 @@
+module KingForm
+  #  was attribute_fu with changes from: http://github.com/odadata/attribute_fu/commit/a0402d12f2d380d8decc82bdfbcc5d8a0a185524
+  # Methods for building forms that contain fields for associated models.
+  module NestedFormHelper
+    
+    # Renders the form for nested objects defined via activerecord accepts_nested_attributes_for
+    #
+    # The associated argument can be either an object, or a collection of objects to be rendered.
+    #
+    # An options hash can be specified to override the default behaviors.
+    # 
+    # Options are:
+    # * <tt>:new</tt>        - specify a certain number of new elements to be added to the form. Useful for displaying a 
+    #                         few blank elements at the bottom.
+    # * <tt>:name</tt>       - override the name of the association, both for the field names, and the name of the partial
+    # * <tt>:partial</tt>    - specify the name of the partial in which the form is located.
+    # * <tt>:fields_for</tt> - specify additional options for the fields_for_associated call
+    # * <tt>:locals</tt>     - specify additional variables to be passed along to the partial
+    # * <tt>:render</tt>     - specify additional options to be passed along to the render :partial call
+    # * <tt>:skip</tt>       - array of elements which will be skipped, usefull if you already rendered a partial in the same form with parts of the data.
+    #                       eg. obj.addresses, render the firt address on top of form, render all the other addresses at the bottom
+    #
+    def render_nested_form(associated, opts = {})
+      associated = associated.is_a?(Array) ? associated : [associated] # preserve association proxy if this is one      
+      opts.symbolize_keys!
+      (opts[:new] - associated.select(&:new_record?).length).times { associated.build } if opts[:new]
+
+      unless associated.empty?
+        name              = extract_option_or_class_name(opts, :name, associated.first)
+        partial           = opts[:partial] || name
+        if opts[:skip]  # objects to be skipped are present
+          skip_el = opts[:skip].is_a?(Array) ? opts[:skip] : [opts[:skip]]
+          assoc_el = []
+          associated.each { |el|  assoc_el << el unless skip_el.include?(el) }
+        else # normal procedure
+          assoc_el = associated
+        end
+
+        output = assoc_el.map do |element|
+          fields_for(association_name(name), element, (opts[:fields_for] || {}).merge(:name => name)) do |f|
+
+            @template.render( {:partial => "#{partial}",
+                               #The current objects classname is always present in partial so:
+                               #when Object is LineItem locals has :line_item => object
+                               :locals => {name.to_sym => f.object, :f => f}.merge( opts[:locals] || {} )
+                              }.merge( opts[:render] || {} ) )
+          end
+        end
+        output.join
+      end
+    end
+    
+    private
+      def association_name(class_name)
+        @object.respond_to?("#{class_name}_attributes=") ? class_name : class_name.pluralize
+      end
+      def extract_option_or_class_name(hash, option, object)
+        (hash.delete(option) || object.class.name.split('::').last.underscore).to_s
+      end
+  end
+end

data/king_form/lib/king_form/overrides.rb

@@ -0,0 +1,25 @@
+# override rails extra_tags_for_form method wich creates hidden special form
+# fields -> method and auth_token
+# so they don't use inline styles anymore
+# From:
+#   <div style="margin:0;padding:0"><input name="authenticity_token"
+# To:
+#   <div><input name="authenticity_token"
+module ActionView::Helpers::FormTagHelper
+  private
+  # overridden method to kill inline styles
+  # from actionpack-2.1.0/lib/action_view/helpers/form_tag_helper.rb
+  def extra_tags_for_form(html_options)
+    case method = html_options.delete("method").to_s
+      when /^get$/i # must be case-insentive, but can't use downcase as might be nil
+        html_options["method"] = "get"
+        ''
+      when /^post$/i, "", nil
+        html_options["method"] = "post"
+        protect_against_forgery? ? content_tag(:div, token_tag) : ''
+      else
+        html_options["method"] = "post"
+        content_tag(:div, tag(:input, :type => "hidden", :name => "_method", :value => method) + token_tag)
+    end
+  end
+end