edgarj 0.01.12

data/app/helpers/edgarj/field_helper.rb

@@ -0,0 +1,397 @@
+module Edgarj
+  # Edgarj::FieldHelper is independent from Edgarj default form (FormDrawer::Base)
+  # so you can use helper methods here for your customized
+  # form.
+  module FieldHelper
+    # Draw buttons for form.
+    #
+    # When no CREATE/UPDATE permission, save button is disabled.
+    # It can be overwritten by options[:save].
+    #
+    # When no DELETE permission, delete button is disabled.
+    # It can be overwritten by options[:delete].
+    #
+    # options may have:
+    # :save::         html options for 'save' button.
+    # :search_form::  html options for 'search_form' button.
+    # :delete::       html options for 'delete' button.
+    # :namespace::    delete url namespace
+    def draw_form_buttons(options = {})
+      content_tag(:table) do
+        content_tag(:tr) do
+          # save button
+          content_tag(:td) do
+            #cp_bitset = Edgarj::ModelPermission::FlagsBitset
+            #create_or_update = cp_bitset::CREATE + cp_bitset::UPDATE
+            tag(:input, {
+                type:     'button',
+                name:     'save',
+                onClick:  '$("#_edgarj_form").submit()',
+                value:    t('edgarj.default.save'),
+                class:    '_edgarj_form_save',})
+               #disabled: !permitted?(create_or_update)}.merge(options[:save]||{}))
+          end +
+
+          # search button
+          content_tag(:td) do
+            button_for_js(t('edgarj.default.search_form'), <<-JS,
+                $('#edgarj_form').hide();
+                $('#edgarj_search_form').show();
+              JS
+              {class: '_edgarj_form_search'}.merge(options[:search_form] ||{}))
+          end +
+
+          # clear button
+          content_tag(:td) do
+            button_to(t('edgarj.default.clear'),
+                {action: 'clear'},
+                {
+                  method:   :get,
+                  remote:   true,
+                })
+          end +
+
+          # delete button
+          content_tag(:td) do
+            button_to(t('edgarj.default.delete'),
+                polymorphic_path([options[:namespace], @record]),
+                {
+                  method:   :delete,
+                  remote:   true,
+                  data:     {confirm:  t('edgarj.form.delete_confirm')},
+                  disabled: @record.new_record?   # || !permitted?(cp_bitset::DELETE),
+                })
+          end
+        end
+      end
+    end
+
+    def draw_search_form_buttons
+      content_tag(:table) do
+        content_tag(:tr) do
+          # search button
+          content_tag(:td) do
+            button_for_js(v('search'), '$("#_edgarj_search_form").submit()')
+          end +
+
+          # search_end button
+          content_tag(:td) do
+            button_for_js(v('search_end'), <<-JS)
+              $('#edgarj_form').show();
+              $('#edgarj_search_form').hide();
+            JS
+          end +
+
+          # search_clear button
+          content_tag(:td) do
+            button_to(v('search_clear'),
+                {action: 'search_clear'},
+                {
+                  method:   :get,
+                  remote:   true,
+                })
+          end
+        end
+      end
+    end
+
+    def draw_search_save_popup
+      render :partial => 'edgarj/search_save_popup'
+    end
+
+    # draw default field for col.type
+    # 
+    # options[type] is passed to each rails helper.  Following types are 
+    # supported:
+    # * :date
+    # * :datetime
+    # * :integer
+    # * :boolean
+    # * :text
+    #
+    # === INPUTS
+    # f::         FormBuilder object
+    # col::       column info returned by AR.columns, or symbol
+    # options::   options hash passed to each helper.
+    def draw_field(f, col, options={})
+      case col.type
+      when :date
+        draw_date(f, col, options[:date] || {})
+      when :datetime
+        draw_datetime(f, col, options[:datetime] || {})
+      when :integer
+        f.text_field(col.name, options[:integer])
+      else
+        f.text_field(col.name, options[:text])
+      end
+    end
+
+    def draw_boolean(f, col, options={})
+      f.check_box(col.name, options)
+    end
+
+    # draw calendar date select
+    #
+    # === INPUTS
+    # f::           Form builder object.
+    # col_or_sym::  column object returned by rec.class.columns, or symbol
+    # options::     passed to calendar_date_select
+    def draw_date(f, col_or_sym, options={})
+      col_name  = get_column_name(col_or_sym)
+      dom_id    = sprintf("%s_%s", f.object_name, col_name)
+      f.text_field(col_name, id: dom_id, size: 14) +
+      javascript_tag(<<-EOJS)
+        $(function(){
+          $('##{dom_id}').datepicker({buttonImageOnly: true}).
+              datepicker('option', {
+                dateFormat:       'yy/mm/dd'
+              });
+        });
+      EOJS
+    end
+
+    # draw calendar datetime select
+    #
+    # === INPUTS
+    # f::           Form builder object.
+    # col_or_sym::  column object returned by rec.class.columns, or symbol
+    # options::     passed to calendar_date_select
+    def draw_datetime(f, col_or_sym, options={})
+      col_name  = get_column_name(col_or_sym)
+      f.text_field(col_name,
+          value: datetime_fmt(f.object.send(col_name)))
+    end
+
+    # draw 'edgarj_address' field
+    #
+    # The column, which is declared as 'edgarj_address', can be
+    # drawn by this helper.
+    #
+    # === INPUTS
+    # f::           FormBuilder
+    # col_or_sym::  column object returned by rec.class.columns, or symbol
+    def draw_address(f, col_or_sym)
+      address_name  = f.object.class.get_belongs_to_name(col_or_sym)
+      render('edgarj/address',
+          f:            f,
+          rec:          f.object,
+          address_name: address_name
+      )
+    end
+
+    # draw bitset checkboxes.
+    #
+    # When model class has integer field (e.g. 'flags') and
+    # Flags module which defines 'bitflag' constant,
+    # model.flags integer column is drawn as bitset checkboxes.
+    # Constant name will be translated by config/locales/*.yml
+    # See ModelPermission for example.
+    #
+    # 'flags' column value is calculated at client side by JavaScript.
+    #
+    # options is not used now.
+    #
+    # === INPUTS
+    # f::       Form builder object.
+    # col::     column object returned by rec.class.columns, or symbol
+    # bitset::  ruby module contains 'bitflag' integer constants
+    # options:: (not used)
+    def draw_bitset(f, col, bitset=nil, options={})
+      html          = ''
+      bitset        = model.const_get(col_name.to_s.camelize + 'Bitset') if !bitset
+      i             = 0
+      id_array_var  = sprintf('%s_%s_var', f.object_name, col.name)
+      ids           = []
+      for flag in bitset.constants do
+        checkbox_id = sprintf('%s_%s_%d', f.object_name, col.name, i)
+        html += draw_checkbox(f, checkbox_id, flag, bitset, id_array_var) +
+                label_tag(
+                    checkbox_id,
+                    f.object.class.human_const_name(bitset, flag)) +
+                '&nbsp;&nbsp;'.html_safe
+        ids << checkbox_id
+        i += 1
+      end
+      # draw hidden field to send sum-up value
+      html += f.hidden_field(col.name)
+
+      # add hidden-field name to ids' last
+      ids << sprintf("%s_%s", f.object_name, col.name)
+
+      # define arrays to calculate flags
+      html += "<script> var #{id_array_var}=[" +
+                    ids.map{|id| "'" + id + "'"}.join(',') +
+                "];</script>"
+      html.html_safe
+    end
+
+    # draw enum selection.
+    #
+    # 'Enum' in Edgarj is a module which integer constants are defined.
+    # draw_enum() draws selection rather than simple integer text field.
+    #
+    # Selection-option label is I18 supported by AR human_const_name API.
+    # See lib/edgarj/model.rb rdoc.
+    #
+    # === EXAMPLE
+    # Followings draws Question module's Priority selection
+    # on @question.priority integer column:
+    #
+    #   <%= edgarj_form do |f| %>
+    #       :
+    #     <%= draw_enum(f, :priority) %>
+    #       :
+    #   <% end %>
+    #
+    # === INPUTS
+    # f::           Form builder object.
+    # col_or_sym::  column object returned by rec.class.columns, or symbol
+    # enum::        enum module.  When nil, guess by column name.
+    # options::     draw_enum options and/or passed to select helper.
+    #
+    # ==== Supported options
+    # :choice_1st:: additional 1st choice (mainly used SearchForm enum selection)
+    # :class        AR class which will be used for human_const_name()
+    #
+    # === SEE ALSO
+    # get_enum()::          get enum definition
+    # draw_column_enum()::  draw enum column in list
+    #
+    # FIXME: choices for selection should be cached.
+    def draw_enum(f, col_or_sym, enum=nil, options={})
+      col_name            =  get_column_name(col_or_sym)
+      enum                = model.const_get(col_name.to_s.camelize) if !enum
+      sorted_elements     = enum.constants.sort{|a,b|
+                                enum.const_get(a) <=> enum.const_get(b)}
+      options_for_select  = options.dup
+      choice_1st          = options_for_select.delete(:choice_1st)
+      class_4_human_const = options_for_select.delete(:class) || f.object.class
+      f.select(col_name,
+                (choice_1st ? [choice_1st] : []) +
+                sorted_elements.map{|member|
+                  [class_4_human_const.human_const_name(enum, member),
+                   enum.const_get(member)]},
+                options_for_select)
+    end
+
+    def draw_question_history(question)
+      render :partial => '/questions/history', :locals=>{:question=>question}
+    end
+
+    # Field 'file_NN' in AR is handled as file attachement(upload/download) in Edgarj.
+    # Where, NN is 2-digits from 00 to 99.
+    #
+    # draw_file() helper draws file attachment(upload/download) user-interface
+    # for file_NN field.  It supports:
+    #
+    # 1. upload file          (Create)
+    # 1. download file        (Read)
+    # 1. upload another file  (Update)
+    # 1. clear the field      (Delete)
+    #
+    # === Model
+    # Integer value of file_NN column in any AR is interpreted a ID value
+    # to point to a FileInfo record.
+    # As NN means, any number of files (max 100) can be attached to any AR.
+    #
+    # belongs_to/has_one relation can be declared between the AR and FileInfo,
+    # but it is not required.  Those declarations are just for your
+    # customization level convenience.
+    #
+    # attr_accessible(or attr_protected) to hide file_NN from mass-assignment
+    # *SHOULD BE* applied.
+    #
+    # See Report model unit test for testing.
+    #
+    # === INPUTS
+    # f::           Form builder object.
+    # col_or_sym::  column object returned by rec.class.columns, or symbol
+    # options::     passed to select helper.
+    #
+    # === EXAMPLE
+    # draw_file(f, :file_00) draws:
+    #
+    #   <input type=file id='file_info[file_00][uploaded_data]' ...>
+    #
+    # === SEE ALSO
+    # ActiveRecord::Base#upsert_file_NN
+    def draw_file(f, col_or_sym, options={})
+      col_name  = get_column_name(col_or_sym)
+      file_info = FileInfo.safe_find(f.object.send(col_name))
+      error_wrapping(
+        if file_info
+          file_field_dom    = "file_info_#{col_name}_uploaded_data"
+          file_link_dom     = "file_info_#{col_name}_link"
+
+          file_field_sub(col_name, file_info, options.merge(:style=>'display:none')) +
+          ' ' +
+          content_tag(:span, :id=>file_link_dom) do
+            link_to(file_info.filename,
+                {:action    => 'file_download',
+                 :id        => f.object.id,
+                 :column    => col_name}) + ' ' +
+            link_to_function("[#{t('edgarj.default.clear')}]",
+                sprintf("Edgarj.clear_file('%s', '%s', '%s')",
+                    file_field_dom,
+                    "#{f.object_name}_#{col_name}",
+                    file_link_dom))
+          end +
+          f.hidden_field(col_name)
+        else
+          file_field_sub(col_name, FileInfo.new, options)
+        end, f.object.errors.on(col_name)
+      )
+    end
+
+  private
+    # Same as ActionView::Helpers::InstanceTag class instance method
+    def error_wrapping(html_tag, has_error)
+      has_error ? ActionView::Base.field_error_proc.call(html_tag, self) : html_tag
+    end
+
+    # draw Edgarj flags specific checkbox
+    def draw_checkbox(f, id, flag, bitset, id_array_var)
+      val       = f.object.send(:flags) || 0
+      flag_val  = bitset.const_get(flag)
+      tag(:input,
+          type:     'checkbox',
+          id:       id,
+          name:     id,
+          value:    flag_val,
+          onChange: "Edgarj.sum_bitset(#{id_array_var})",
+          checked:  (val & flag_val) != 0 )
+    end
+
+    # find column info from name
+    def find_col(rec, sym)
+      rec.class.columns.detect{|c| c.name == sym.to_s}
+    end
+
+    # get column name from column object or symbol
+    def get_column_name(col_or_sym)
+      if col_or_sym.is_a?(Symbol)
+        col_or_sym
+      else
+        col_or_sym.name
+      end
+    end
+
+    # generate following file field:
+    #
+    #   <input type='file' name='file_info[file_NN][uploaded_data]' ...>
+    def file_field_sub(col_name, file_info, options)
+      fields_for("file_info[#{col_name}]", file_info) do |f|
+        f.file_field(:uploaded_data, {:size=>20}.merge(options))
+      end
+    end
+
+    # replacement of button_to_function to avoid DEPRECATION WARNING.
+    #
+    # When the js is called just once, onClick is simpler than 
+    # unobtrusive-javascript approach.
+    def button_for_js(label, js, html_options={})
+      tag(:input, {type: 'button', value: label, onClick: js}.merge(
+        html_options))
+    end
+  end
+end