drg_cms 0.6.0.6 → 0.6.1.4

data/app/helpers/{cmsedit_index_helper.rb → cms_index_helper.rb}

@@ -27,60 +27,43 @@
 # data found in 3 major sections of DRG CMS form: index, result_set and form sections. 
 #
 ###########################################################################
-module CmseditIndexHelper
+module CmsIndexHelper
   
-############################################################################
-# Get standard actions when actions directive contains single line.
-# Subroutine of dc_actions_for_index
-# 
-# Allows for actions: new, filter, standard syntax
-############################################################################
-def define_standard_actions(actions_params, standard)
-  actions = {}
-  actions_params.split(',').each do |an_action|
-    an_action.strip!
-    if an_action == 'standard'
-      actions.merge!(standard)
-    else
-      standard.each do |index, action| 
-        (actions[index] = action; break) if action == an_action
-      end
-    end
-  end 
-  actions
-end
-
 ############################################################################
 # Creates action div for cmsedit index action. 
 ############################################################################
-def dc_actions_for_index()
+def dc_actions_for_index
   @js  = @form['script'] || @form['js'] || ''
   @css = @form['css'] || ''
-  return '' if @form['index'].nil? or @form['readonly']
+  return '' if @form['index'].nil?
+
   actions = @form['index']['actions']
   return '' if actions.blank?
   
   std_actions = {2 => 'new', 3 => 'sort', 4 => 'filter' }
+  std_actions.delete(2) if @form['readonly']
+
   if actions.class == String
-    actions = define_standard_actions(actions, std_actions)
+    actions = dc_define_standard_actions(actions, std_actions)
   elsif actions['standard']
     actions.merge!(std_actions)
     actions['standard'] = nil
   end
   
-# start div with hidden spinner image 
-  html = <<EOT
+  # start div with hidden spinner image
+  html = %(
 <form id="dc-action-menu">
   <span class="dc-spinner">#{fa_icon('spinner lg spin')}</span>
-  <ul class="dc-action-menu">
-EOT
-# Remove actions settings and sort
+  <ul class="dc-action-menu">)
+
+  # Remove actions settings and sort
   only_actions = []
   actions.each { |key, value| only_actions << [key, value] if key.class == Integer }
   only_actions.sort_by!(&:first)
   only_actions.each do |key, options|
     session[:form_processing] = "index:actions: #{key}=#{options}"
     next if options.nil? # must be
+
     url = @parms.clone
     yaml = options.class == String ? {'type' => options} : options # if single definition simulate type parameter
     action = yaml['type'].to_s.downcase 
@@ -88,7 +71,7 @@ EOT
       dc_deprecate "action: url will be deprecated. Use action: link in index: actions! Form #{params['form_name']}"
       action = 'link' 
     end
-# if return_to is present link directly to URL 
+    # if return_to is present link directly to URL
     if action == 'link' and yaml['url']
       url = yaml['url']
     else
@@ -98,11 +81,12 @@ EOT
       url['form_name']  = yaml['form_name'] if yaml['form_name']
       url['control']    = yaml['control'] if yaml['control']
     end
-# html link options
+    # html link options
     yhtml = yaml['html'] || {}
     yhtml['title'] = yaml['title'] if yaml['title']
-    code = case 
-# sort
+
+    code = case
+    # sort
     when action == 'sort' then 
       choices = [['id','id']]
       if @form['index']['sort']
@@ -113,26 +97,34 @@ EOT
       end
       fa_icon('sort-alpha-asc') + ' ' + t('drgcms.sort') + ' ' + 
               select('sort', 'sort', choices, { include_blank: true }, 
-              { class: 'drgcms_sort', 'data-table' => @form['table']} )
-# filter
+              { class: 'drgcms_sort', 'data-table' => @form['table'], 'data-form' => params['form_name']} )
+
+    # filter
     when action == 'filter' then 
       caption = t('drgcms.filter')
       caption << '&nbsp;' + fa_icon('caret-down lg') + DcFilter.menu_filter(self)
-# add filter OFF link
+      # add filter OFF link
       sess = session[@form['table']]
       if sess and sess[:filter]
-        caption << '&nbsp;&nbsp;' + dc_link_to(nil,'remove lg', {controller: 'cmsedit', 
-                   filter: 'off', table: @form['table']}, { title: DcFilter.title4_filter_off(sess[:filter]) }) 
+        caption << '&nbsp;&nbsp;' + dc_link_to(nil,'remove lg',
+                   { controller: 'cmsedit', filter: 'off', table: @form['table'], form_name: params['form_name'] },
+                   { title: DcFilter.title4_filter_off(sess[:filter]) })
       end
       caption
-# new
+
+    # new
     when action == 'new' then 
       caption = yaml['caption'] || 'drgcms.new'
       dc_link_to(caption,'plus', url, yhtml )
-# menu      
-    when action == 'menu' then  
-      caption = t(options['caption'], options['caption']) + '&nbsp;' + fa_icon('caret-down lg')
-      caption + eval(options['eval'])      
+
+    # menu
+    when action == 'menu' then
+      if options['caption']
+        caption = t(options['caption'], options['caption']) + '&nbsp;' + fa_icon('caret-down lg')
+        caption + eval(options['eval'])
+      else # when caption is false, provide own actions
+        eval(options['eval'])
+      end
 =begin
 # reorder      
     when action == 'reorder' then  
@@ -146,13 +138,16 @@ EOT
     when action == 'script'
       html << dc_script_action(options)
       next
+
     when action == 'field'
       html << dc_field_action(yaml) 
       next 
+
     when %w(ajax link window submit).include?(action)
       html << dc_link_ajax_window_submit_action(options, nil)
       next
-    else 
+
+    else
       caption = yaml['caption'] || yaml['text']
       icon    = yaml['icon'] ? yaml['icon'] : action
       dc_link_to(caption, icon, url, yhtml)
@@ -160,22 +155,21 @@ EOT
     html << "<li class=\"dc-link dc-animate\">#{code}</li>"
     html << DcFilter.get_filter_field(self) if action == 'filter'
   end
-  html << '</ul>'
-  html << '</form>'
+  html << '</ul></form>'
   html.html_safe
 end
 
 ############################################################################
 # Creates filter div for cmsedit index/filter action.
 ############################################################################
-def dc_div_filter()
+def dc_div_filter
   choices = []
   filter = (@form['index'] and @form['index']['filter']) ? @form['index']['filter'] + ',' : ''
   filter << 'id as text_field' # filter id is added by default
   filter.split(',').each do |f| 
     f.strip!
     name = f.match(' as ') ? f.split(' ').first : f
-# like another field on the form
+    # like another field on the form
     if f.match(' like ')
       a    = f.split(' ')
       name = a.first
@@ -184,7 +178,7 @@ def dc_div_filter()
     choices << [ t("helpers.label.#{@form['table']}.#{name}", name), f ] 
   end
   choices4_operators = t('drgcms.choices4_filter_operators').chomp.split(',').inject([]) {|r,v| r << (v.match(':') ? v.split(':') : v )}
-# currently selected options
+  # currently selected options
   if session[@form['table']] and session[@form['table']][:filter]
     field_name, operators_value, dummy = session[@form['table']][:filter].split("\t")
   else
@@ -210,7 +204,7 @@ end
 ############################################################################
 # Creates popup div for setting filter on result set header.
 ############################################################################
-def dc_filter_popup()
+def dc_filter_popup
   html = %Q[<div class="filter-popup" style="display: none;">
   <div>#{t('drgcms.filter_set')}</div>
   <ul>]
@@ -224,102 +218,95 @@ def dc_filter_popup()
 end
 
 ############################################################################
-# Creates title div for cmsedit index result set records. Title div also includes paging 
-# options.
+# Will return title based on @form['title']
 ############################################################################
-def dc_table_title_for_result(result=nil)
-  title = if @form['title'] # form has title section
-    t(@form['title'], @form['title'])
-  else # get name from translations
-    t("helpers.label.#{@form['table']}.tabletitle", @form['table'])
-  end
-  dc_table_title(title, result)
+def dc_form_title
+  return t("helpers.label.#{@form['table']}.tabletitle", @form['table'])  if @form['title'].nil?
+  return t(@form['title'], @form['title']) if @form['title'].class == String
+
+  # Hash
+  dc_process_eval(@form['title']['eval'], [@form['title']['caption'] || @form['title']['text'], params])
 end
 
 ############################################################################
-# Creates code for link or ajax action type. Subroutine of dc_actions_for_result.
+# Creates title div for index action. Title div also includes paging options
+# and help link
 ############################################################################
-def __dc_link_or_ajax_action(yaml, parms) #:nodoc:
-  rest = {}
-  rest['method']  = yaml['method'] || yaml['request'] || 'get'
-  rest['caption'] = yaml['caption'] || yaml['text']
-  rest['class']   = 'dc-animate'
-  rest['title']   = yaml['title']
-  
-  if yaml['type'] == 'link'
-    dc_link_to(yaml['caption'], yaml['icon'], parms, rest ) 
-  else
-    rest['data-url'] = url_for(parms)
-    rest['class'] << " fa fa-#{yaml['icon']}"
-    fa_icon(yaml['icon'], rest ) 
-  end
+def dc_title_for_index(result = nil)
+  dc_table_title(dc_form_title(), result)
 end
 
 ############################################################################
 # Determines actions and width of actions column
 ############################################################################
-def dc_actions_column()
+def dc_actions_column
   actions = @form['result_set']['actions']
-  return [{},0] if actions.nil? or dc_dont?(actions)
-# standard actions  
+  return [{}, 0] if actions.nil? || dc_dont?(actions)
+
+  # standard actions
   actions = {'standard' => true} if actions.class == String && actions == 'standard'
-  std_actions = {' 2' => 'edit', ' 3' => 'delete'}
+  std_actions = { 2 => 'edit', 5 => 'delete' }
   if actions['standard']
     actions.merge!(std_actions) 
     actions.delete('standard')
   end
-#  
+
   width = @form['result_set']['actions_width'] || 18*actions.size
-  [ actions, width ] 
+  [actions, width]
 end
 
 ############################################################################
 # Calculates (blank) space required for actions when @record_footer is rendered 
 ############################################################################
-def dc_actions_column_for_footer()
+def dc_actions_column_for_footer
   return '' unless @form['result_set']['actions']
+
   ignore, width = dc_actions_column
   %Q[<div class="actions" style="width: #{width}px;"></div>].html_safe
 end
 
-
 ############################################################################
 # Creates actions that could be performed on single row of result set.
 ############################################################################
 def dc_actions_for_result(document)
   actions = @form['result_set']['actions']
-  return '' if actions.nil? or @form['readonly']
-#  
+  return '' if actions.nil? || @form['readonly']
+
   actions, width = dc_actions_column()
   html = %Q[<ul class="actions" style="width: #{width}px;">]
-  actions.each do |k,v|
+  actions.sort_by(&:first).each do |k, v|
     session[:form_processing] = "result_set:actions: #{k}=#{v}"
-    next if k == 'standard' # ignore standard definition
-    parms = @parms.clone   
+    parms = @parms.clone
     # if single definition simulate type parameter
-    yaml = v.class == String ? {'type' => v} : v
+    yaml = v.class == String ? { 'type' => v } : v
     # code already includes li tag
-    if %w(ajax link window submit).include?(yaml['type']) then
+    if %w(ajax link window submit).include?(yaml['type'])
       @record = document # otherwise document fields can't be used as parameters
-      html << dc_link_ajax_window_submit_action(yaml,document)
+      html << dc_link_ajax_window_submit_action(yaml, document)
     else
       html << '<li class="dc-link">'
       html << case
+      when yaml['type'] == 'check' then
+        check_box_tag("check-#{document.id}", false,false,{ class: 'dc-check' })
+
       when yaml['type'] == 'edit' then
         parms['action'] = 'edit'
         parms['id']     = document.id
         dc_link_to( nil, 'pencil lg', parms )
+
       when yaml['type'] == 'duplicate' then
         parms['id']     = document.id
         # duplicate string will be added to these fields.
         parms['dup_fields'] = yaml['dup_fields'] 
         parms['action'] = 'create'
         dc_link_to( nil, 'copy lg', parms, data: { confirm: t('drgcms.confirm_dup') }, method: :post )
+
       when yaml['type'] == 'delete' then
         parms['action'] = 'destroy'
         parms['id']     = document.id
-        parms['return_to'] = request.url
+        #parms['return_to'] = request.url
         dc_link_to( nil, 'remove lg', parms, data: { confirm: t('drgcms.confirm_delete') }, method: :delete )
+
       # undocumented so far
       when yaml['type'] == 'edit_embedded'
         parms['controller'] = 'cmsedit'
@@ -327,21 +314,7 @@ def dc_actions_for_result(document)
         parms['ids']   ||= ''
         parms['ids']   +=  "#{document.id};"
         dc_link_to( nil, 'table lg', parms, method: :get )
-=begin        
-      when yaml['type'] == 'link' || yaml['type'] == 'ajax' then
-        if yaml['url']
-          parms['controller'] = yaml['url']
-          parms['idr']        = document.id
-        else
-          parms['id']         = document.id
-        end
-        parms['controller'] = yaml['controller'] if yaml['controller']
-        parms['action']     = yaml['action']     if yaml['action']
-        parms['table']      = yaml['table']      if yaml['table']
-        parms['form_name']  = yaml['form_name']  if yaml['form_name']
-        parms['target']     = yaml['target']     if yaml['target']
-        dc_link_or_ajax_action(yaml, parms)
-=end        
+    
       else # error. 
         yaml['type'].to_s
       end
@@ -355,37 +328,43 @@ end
 ############################################################################
 # Creates header div for result set.
 ############################################################################
-def dc_header_for_result()
+def dc_header_for_result
   html = '<div class="dc-result-header">'
   if @form['result_set']['actions'] and !@form['readonly']
     ignore, width = dc_actions_column()
-    html << %Q[<div class="actions" style="width: #{width}px;"></div>]
+    if width > 0 && @form['result_set']['actions'][0].to_s == 'check'
+      check_all = fa_icon('check-square-o', class: 'dc-check-all')
+    end
+    html << %Q[<div class="actions" style="width:#{width}px;">#{check_all}</div>]
   end
   # preparation for sort icon  
   sort_field, sort_direction = nil, nil
   if session[@form['table']]
     sort_field, sort_direction = session[@form['table']][:sort].to_s.split(' ')
   end
-  #  
+
   if (columns = @form['result_set']['columns'])
-    columns.sort.each do |k,v|
+    columns.sort.each do |k, v|
       session[:form_processing] = "result_set:columns: #{k}=#{v}"
-      th = %Q[<div class="th" style="width: #{v['width'] || '15%'};text-align: #{v['align'] || 'left'};" data-name="#{v['name']}"]
-      # when no caption or name is defined it might be just spacer      
-      if (caption = v['caption']).nil? 
-        caption = v['name'] ? t("helpers.label.#{@form['table']}.#{v['name']}") : ''
-      end
+      next if v['width'].to_s.match(/hidden|none/i)
+
+      th = %Q[<div class="th" style="width:#{v['width'] || '15%'};text-align:#{v['align'] || 'left'};" data-name="#{v['name']}"]
+      label = v['caption'] || v['label']
+      label = (v['name'] ? "helpers.label.#{@form['table']}.#{v['name']}" : '') if label.nil?
+      label = t(label) if label.match(/\./)
       # no sorting when embedded documents or custom filter is active 
-      sort_ok = @form['result_set'].nil? || (@form['result_set'] && @form['result_set']['filter'].nil?)
+      #sort_ok = @form['result_set'].nil? || (@form['result_set'] && @form['result_set']['filter'].nil?)
+      sort_ok = true
       sort_ok = sort_ok || (@form['index'] && @form['index']['sort'])
+      sort_ok = sort_ok && !dc_dont?(v['sort'], false)
       if @tables.size == 1 and sort_ok
         icon = 'sort lg'
         if v['name'] == sort_field
           icon = sort_direction == '1' ? 'sort-alpha-asc lg' : 'sort-alpha-desc lg'
         end        
-        th << ">#{dc_link_to(caption, icon, sort: v['name'], table: params[:table], form_name: params[:form_name], action: :index, icon_pos: :last )}</div>"
+        th << ">#{dc_link_to(label, icon, sort: v['name'], table: params[:table], form_name: params[:form_name], action: :index, icon_pos: :last )}</div>"
       else
-        th << ">#{caption}</div>"
+        th << ">#{label}</div>"
       end
       html << "<div class=\"spacer\"></div>" + th
     end
@@ -407,12 +386,14 @@ def dc_clicks_for_result(document)
     opts[:form_name]  = yaml['form_name']
     opts[:method]     = yaml['method'] || 'get'
     opts[:id]         = document['id']
+    opts[:readonly]   = yaml['readonly'] if yaml['readonly']
+    opts[:window_close] = yaml['window_close'] if yaml['window_close']
     html << ' data-dblclick=' + url_for(opts) 
   else
      html << (' data-dblclick=' +
-       url_for(action: 'show', controller: 'cmsedit', id: document.id, 
-       readonly: (params[:readonly] ? 2 : 1), table: params[:table],
-       form_name: params[:form_name], ids: params[:ids])  ) if @form['form'] 
+                url_for(action: 'show', controller: 'cmsedit', id: document.id, ids: params[:ids],
+                        readonly: (params[:readonly] ? 2 : 1), table: params[:table],
+                        form_name: params[:form_name]) ) if @form['form']
   end
   html
 end
@@ -422,14 +403,15 @@ end
 ############################################################################
 def dc_format_value(value, format=nil)
   return '' if value.nil?
+
   klass = value.class.to_s
-  case when klass.match('Time') then
-    format ||= t('time.formats.default')
-    value.strftime(format)  
-  when klass.match('Date') then
-    format ||= t('date.formats.default')
-    value.strftime(format)  
-  when format.to_s[0] == 'N' then
+  return CmsCommonHelper.dc_format_date_time(value, format) if klass.match(/time|date/i)
+
+  format = format.to_s.upcase
+  if format[0] == 'N'
+    return '' if value == 0 && format.match('Z')
+
+    format.gsub!('Z', '')
     dec = format[1].blank? ? nil : format[1].to_i
     sep = format[2].blank? ? nil : format[2]
     del = format[3].blank? ? nil : format[3]
@@ -440,26 +422,6 @@ def dc_format_value(value, format=nil)
   end
 end      
 
-############################################################################
-# Defines style or class for row (tr) or column (td)
-############################################################################
-def dc_style_or_class(selector, yaml, value, record)
-  return '' if yaml.nil?
-# alias record and value so both names can be used in eval
-  field, document = value, record
-  html = selector ? "#{selector}=\"" : ''
-  html << if yaml.class == String
-    yaml
-  # direct evaluate expression
-  elsif yaml['eval']
-    eval(yaml['eval']) rescue 'background-color:red;'
-  elsif yaml['method']
-    dc_process_eval(yaml['method'],record)
-  end
-  html << '"' if selector 
-  html
-end 
-
 ############################################################################
 # Creates tr code for each row of result set.
 ############################################################################
@@ -469,6 +431,61 @@ def dc_row_for_result(document)
   "<div  id=\"#{document.id}\" class=\"dc-result-data #{clas}\" #{dc_clicks_for_result(document)} #{style}>".html_safe
 end
 
+############################################################################
+# Creates column for each field of result set document.
+############################################################################
+def dc_columns_for_result(document)
+  return '' unless @form['result_set']['columns']
+
+  html = ''  
+  @form['result_set']['columns'].sort.each do |k,v|
+    session[:form_processing] = "result_set:columns: #{k}=#{v}"
+    next if v['width'].to_s.match(/hidden|none/i)
+
+    # convert shortcut to hash 
+    v = {'name' => v} if v.class == String    
+    begin
+      # eval
+      value = if v['eval']
+        dc_process_column_eval(v, document)
+      # as field        
+      elsif document.respond_to?(v['name'])
+        dc_format_value(document.send( v['name'] ), v['format']) 
+      # as hash (dc_memory)
+      elsif document.class == Hash 
+        dc_format_value(document[ v['name'] ], v['format'])
+      # error
+      else
+        "??? #{v['name']}"
+      end
+    rescue Exception => e
+      dc_log_exception(e, 'dc_columns_for_result')
+      value = '!!!Error'
+    end
+    html << '<div class="spacer"></div>'
+    # set class
+    clas = dc_style_or_class(nil, v['td_class'], value, document)
+    # set width and align an additional style
+    style = dc_style_or_class(nil, v['td_style'] || v['style'], value, document)
+    flex_align  = v['align'].to_s == 'right' ? 'flex-direction:row-reverse;' : ''
+    width_align = %Q[width:#{v['width'] || '15%'};#{flex_align}]
+    style = "style=\"#{width_align}#{style}\" "
+
+    html << "<div class=\"td #{clas}\" #{style}>#{value}</div>"
+  end
+  html.html_safe
+end
+
+############################################################################
+# Split eval expression to array by parameters.
+# Ex. Will split dc_name4_value(one ,"two") => ['dc_name4_value', 'one', 'two']
+############################################################################
+def dc_eval_to_array(expression)
+  expression.split(/\ |\,|\(|\)/).delete_if {|e| e.blank? }.map {|e| e.gsub(/\'|\"/,'').strip }
+end
+
+private
+
 ############################################################################
 # Process eval. Breaks eval option and calls with send method.
 # Parameters:
@@ -491,77 +508,94 @@ end
 # Used for processing single field column on result_set or form head.
 ############################################################################
 def dc_process_column_eval(yaml, document)
-  # dc_name4_id
-  if yaml['eval'].match('dc_name4_id')
-    a = yaml['eval'].split(/\ |\,/)
-    if a.size == 3
-      dc_name4_id(a[1], a[2], nil, document[ yaml['name'] ])
+  # dc_name_for_id
+  if yaml['eval'].match(/dc_name4_id|dc_name_for_id/)
+    parms = dc_eval_to_array(yaml['eval'])
+    if parms.size == 3
+      dc_name_for_id(parms[1], parms[2], nil, document[ yaml['name'] ])
     else
-      dc_name4_id(a[1], a[2], a[3], document[ yaml['name'] ])
+      dc_name_for_id(parms[1], parms[2], parms[3], document[ yaml['name'] ])
     end
-  # dc_name4_value  
-  elsif yaml['eval'].match('dc_name4_value')
-    dc_name4_value( @form['table'], yaml['name'], document[ yaml['name'] ] )
+
+  # dc_name_for_value from locale definition
+  elsif yaml['eval'].match(/dc_name4_value|dc_name_for_value/)
+    parms = dc_eval_to_array(yaml['eval'])
+    if parms.size == 1
+      dc_name_for_value( @form['table'], yaml['name'], document[ yaml['name'] ] )
+    else
+      dc_name_for_value( parms[1], parms[2], document[ yaml['name'] ] )
+    end
+
+  # defined in helpers. For example dc_icon_for_boolean
+  elsif respond_to?(yaml['eval'])
+    send(yaml['eval'], document[yaml['name']])
+
+  # defined in model
+  elsif document.respond_to?(yaml['eval'])
+    document.send(yaml['eval'])
+
+  # special eval  
   elsif yaml['eval'].match('eval ')
   # TO DO evaluate with specified parameters
+
+  # eval with params
   else
-    parameters = if yaml['params']
-      # pass document as parameter
-      if yaml['params'] == 'document' or yaml['params'] == 'record'     
-        document
-      else
-        yaml['params'].chomp.split(',').inject([]) do |result,e| 
-          result << document[e.strip]
-        end        
-      end        
+    parms = {}
+    if yaml['params'].class == String
+      parms = dc_value_for_parameter(yaml['params'], document)
+    elsif yaml['params'].class == Hash
+      yaml['params'].each { |k, v| parms[k] = dc_value_for_parameter(v) }
     else
-      document[ yaml['name'] ]
+      parms = document[ yaml['name'] ]
     end
-    # evaluate by calling send method 
-    dc_process_eval(yaml['eval'], parameters)
+    dc_process_eval(yaml['eval'], parms)
   end
 end
 
 ############################################################################
-# Creates column for each field of result set document.
+# Defines style or class for row (tr) or column (td)
 ############################################################################
-def dc_columns_for_result(document)
-  return '' unless @form['result_set']['columns']
-  html = ''  
-  @form['result_set']['columns'].sort.each do |k,v|
-    session[:form_processing] = "result_set:columns: #{k}=#{v}"
-    # convert shortcut to hash 
-    v = {'name' => v} if v.class == String    
-    begin
-      # eval
-      value = if v['eval']
-        dc_process_column_eval(v, document)
-      # as field        
-      elsif document.respond_to?(v['name'])
-        dc_format_value(document.send( v['name'] ), v['format']) 
-      # as hash (dc_memory)
-      elsif document.class == Hash 
-        dc_format_value(document[ v['name'] ], v['format'])
-      # error
-      else
-        "!!! #{v['name']}"
-      end
-    rescue Exception => e
-      dc_log_exception(e)
-      value = '!!!Error'
-    end
-    html << '<div class="spacer"></div>'
-    # set class
-    clas = dc_style_or_class(nil, v['td_class'], value, document)
-    # set width and align an additional style
-    style = dc_style_or_class(nil, v['td_style'] || v['style'], value, document)
-    width_align = %Q[width: #{v['width'] || '15%'};text-align: #{v['align'] || 'left'};]
-    style = "#{width_align}#{style}"
+def dc_style_or_class(selector, yaml, value, record)
+  return '' if yaml.nil?
 
-    html << "<div class=\"td #{clas}\" style=\"#{style}\">#{value}</div>"
+  # alias record and value so both names can be used in eval
+  field, document = value, record
+  html = selector ? "#{selector}=\"" : ''
+  begin
+    html << if yaml.class == String
+              yaml
+              # direct evaluate expression
+            elsif yaml['eval']
+              eval(yaml['eval'])
+            elsif yaml['method']
+              dc_process_eval(yaml['method'], record)
+            end
+  rescue Exception => e
+    dc_log_exception(e, 'dc_style_or_class')
   end
-  html.html_safe
-end
+  html << '"' if selector
+  html
+end 
 
+############################################################################
+# Get standard actions when actions directive contains single line.
+# Subroutine of dc_actions_for_index
+# 
+# Allows for actions: new, filter, standard syntax
+############################################################################
+def dc_define_standard_actions(actions_params, standard)
+  actions = {}
+  actions_params.split(',').each do |an_action|
+    an_action.strip!
+    if an_action == 'standard'
+      actions.merge!(standard)
+    else
+      standard.each do |index, action| 
+        (actions[index] = action; break) if action == an_action
+      end
+    end
+  end 
+  actions
+end
 
 end