drg_cms 0.4.39 → 0.4.53

data/app/helpers/dc_page_renderer.rb

@@ -22,6 +22,15 @@
 #++
 
 ########################################################################
+# Page renderer renders data from dc_page collection documents. This renderer will
+# almost certainly be replaced by your own renderer so example here shows just basic code 
+# which just checks if user is allowed to view data and if so returns document body content
+# otherwise returns error message defined in site policy.
+# 
+# Example:
+#    <div id="page">
+#      <%= dc_render(:dc_page) %>
+#    </div>
 #
 ########################################################################
 class DcPageRenderer
@@ -29,29 +38,16 @@ class DcPageRenderer
 include DcApplicationHelper
 
 ########################################################################
-#
+# Object initialization.
 ########################################################################
-def initialize( parent, opts={} )
+def initialize( parent, opts={} ) #:nodoc:
   @parent = parent
   @opts   = opts
   @page   = @parent.page
 end
 
-=begin
-#########################################################################
-# Return code for editing this piece.
-########################################################################
-def link_4edit()
-  html = ''
-  if @opts[:edit_mode] > 1
-    html << dc_page_edit_menu() # @opts[:editparams] )
-  end  
-  html
-end
-=end
-
 #########################################################################
-# default DcPage render method
+# Default DcPage render method
 #########################################################################
 def default
   can_view, msg = dc_user_can_view(@parent, @page)
@@ -63,7 +59,7 @@ def default
 end
 
 #########################################################################
-# render html
+# Renderer dispatcher. Method returns HTML part of code.
 ########################################################################
 def render_html
   method = @opts[:method] || 'default'
@@ -71,7 +67,7 @@ def render_html
 end
 
 ########################################################################
-# render css
+# Return CSS part of code.
 ########################################################################
 def render_css
   @page.css

data/app/helpers/dc_part_renderer.rb

@@ -22,16 +22,31 @@
 #++
 
 ########################################################################
-#
+# Renders one or multiple parts grouped by div_id field.
+# Parts are scoped from design, page and dc_pieces documents.
+# 
+# Example (as used in design):
+#    <div id='div-main'>
+#      <div id='div-left'> <%= dc_render(:dc_part, position: 'left') %></div>
+#      <div id='page'> <%= dc_render(:dc_page) %></div>
+#      <div id='div-right'>
+#        <%= dc_render(:dc_part, method: 'in_page', name: 'welcome')
+#        <%= dc_render(:dc_part, position: 'right')</div>
+#      </div>
+#    </div>
+#    
+# Main page division in example is divided into 3 divisions. div-left, page and div-right.
+# div-left and div-right are populated with parts containing 'left' and 'right' div_id value. 
+# In addition part with name 'welcome' is located above 'right' parts.
 ########################################################################
 class DcPartRenderer
 
 include DcApplicationHelper
 
 ########################################################################
-#
+# Object initialization.
 ########################################################################
-def initialize( parent, opts={} )
+def initialize( parent, opts={} ) #:nodoc:
   @parent   = parent
   @opts     = opts
   @part_css = ''
@@ -39,7 +54,8 @@ def initialize( parent, opts={} )
 end
 
 ########################################################################
-# Render single particle
+# Method returns output from single part(icle). It checks if policy allows part to 
+# be viewed on page and ads links for editing when in edit mode.
 ########################################################################
 def render_particle(particle, opts)
   # Check if policy allows to view page
@@ -64,9 +80,10 @@ def render_particle(particle, opts)
 end
 
 ########################################################################
-# Load parts defined in design, page or dc_piece
+# Load all parts defined in design, page or piece collection into memory. 
+# Subroutine of default method.
 ########################################################################
-def load_parts
+def load_parts #:nodoc:
   @parent.parts = []
 # Start with parts in design. Collect to array and add values needed for editing
   if @parent.design
@@ -87,15 +104,26 @@ def load_parts
 end  
 
 ########################################################################
-# Default part_renderer method will collect all parts with the div_id defined
-# by position and create html output defined by order.
+# Default method collects all parts with the div_id field value defined by position option.
+# If more then one parts have same div_id they will be sorted by order field. Method
+# also loads all parts from design, page and pieces collections and cache them for 
+# consecutive calls.
+# 
+# Options: 
+# [position] String. Position (value of div_id) where parts will be rendered.
+# 
+# Example (as used in design):
+#     <div id='div-right'>
+#       <%= dc_render(:dc_part, position: 'right')
+#     </div>
 ########################################################################
 def default
   html = ''
 # Load all parts only once per call  
   load_parts if @parent.parts.nil?
   p 'DcPart: Parameter location will be deprecated! Please use position keyword.' if @opts['location']
-  @opts[:position] ||= @opts['position'] || @opts[:location] || @opts['location'] # symbols are not strings. Ensure that it works.
+  
+  @opts[:position] ||= @opts['position'] # symbols are not strings. Ensure that it works.
 # Select parts
   parts = []
   @parent.parts.each { |v| parts << v if v[0].div_id == @opts[:position] }
@@ -113,13 +141,14 @@ def default
 end
 
 ########################################################################
-# This method will search and render single part defined in page. Part may
-# be defined in current page or in any page in current pages file.
+# This method will search and render single part defined in pages file. Part may
+# be defined in current page document or in any page document in found in pages file. Parameters
+# are send through options hash. 
 # 
 # Options: 
-# required :name      : Name of part.
-# optional :page_id   : Id of page where part is saved if not current page.
-# optional :page_link : Subject link of page where part is saved if not current page.
+# [name] String. dc_parts name.
+# [page_id] String. Page document _id where part document is saved. Defaults to current page.
+# [page_link] String. Page may alternatively be found by subject_link field.
 ########################################################################
 def in_page
 # Part is in page with id  
@@ -145,7 +174,7 @@ def in_page
 end
 
 ########################################################################
-#
+# Renderer dispatcher. Method returns HTML part of code.
 ########################################################################
 def render_html
   method = @opts[:method] || 'default'
@@ -153,7 +182,7 @@ def render_html
 end
 
 ########################################################################
-#
+# Return CSS part of code.
 ########################################################################
 def render_css
   @part_css

data/app/helpers/dc_piece_renderer.rb

@@ -22,6 +22,12 @@
 #++
 
 ########################################################################
+# Piece renderer renders data from dc_piece collection documents. 
+# 
+# Example:
+#    <div id="page">
+#      <%= dc_render(:dc_piece, :name => 'some_piece') %>
+#    </div>
 #
 ########################################################################
 class DcPieceRenderer
@@ -29,9 +35,9 @@ class DcPieceRenderer
 include DcApplicationHelper
 
 ########################################################################
-#
+# Object initialization. It also loads requested dc_piece document.
 ########################################################################
-def initialize( parent, opts={} )
+def initialize( parent, opts={} ) #:nodoc:
   @parent = parent
   @opts   = opts
   @piece  = DcPiece.find(opts[:id]) if opts[:id]
@@ -46,36 +52,24 @@ def initialize( parent, opts={} )
 end
 
 #########################################################################
-# Return code for editing this piece.
+# Return link code for editing this piece.
 ########################################################################
 def link_4edit()
   html = ''
-  if @opts[:edit_mode] > 1
-    @opts[:editparams].merge!( { table: 'dc_piece', 
-                                 controller: 'cmsedit', 
-                                 action: 'edit', 
-                                 id: @piece.id,
-                                 title: "#{t('drgcms.edit')}: #{@piece.name}" } )
-    html << dc_link_for_edit( @opts[:editparams] )
-  end  
-  html
-end
-
-########################################################################
-# script renderer expects rails erb code (view) in the script field.
-# 
-# Usefull when you have many designs which have lots pieces of code in common.
-########################################################################
-def script
-  html = link_4edit()  
-  html << @parent.render(inline: @piece.script, layout: @opts[:layout]) 
+  return html if @opts[:edit_mode] < 2
+  @opts[:editparams].merge!( { table: 'dc_piece', 
+                               controller: 'cmsedit', 
+                               action: 'edit', 
+                               id: @piece.id,
+                               title: "#{t('drgcms.edit')}: #{@piece.name}" } )
+  html << dc_link_for_edit( @opts[:editparams] )
 end
 
 ########################################################################
-# script renderer expects rails erb code (view) in the script field.
-# Used for designs with common code and one part which is different.
-# It function is similar to dc_replace_in_design method except that design
-# is defined in dc_piece document and not in site document.
+# Script renderer method expects rails erb code (view) in the script field.
+# Used for designs with common code which can be shared and one part which is different.
+# It's functionality can be replaced with dc_replace_in_design method with 'piece' option 
+# specified.
 # 
 # Example: As used in design. Backslashing < and % is important \<\%
 # <% part = "<div  class='some-class'>\<\%= dc_render(:my_renderer, method: 'render_method') \%\></div>" %>
@@ -98,7 +92,7 @@ def script
 end
 
 #########################################################################
-# default DcPiece render method
+# Default DcPiece render method. 
 ########################################################################
 def default
   html = link_4edit()
@@ -106,7 +100,7 @@ def default
 end
 
 #########################################################################
-# render html
+# Renderer dispatcher. Method returns HTML part of code.
 ########################################################################
 def render_html
   return "DcPiece #{@opts[:id]} #{@opts[:name]} not found!" unless @piece
@@ -115,7 +109,7 @@ def render_html
 end
 
 ########################################################################
-# render css
+# Return CSS part of code.
 ########################################################################
 def render_css
   @piece ? "#{@piece.css}" : ''

data/app/helpers/dc_poll_renderer.rb

@@ -22,7 +22,8 @@
 #++
 
 ########################################################################
-#
+# Renders code for displaying a poll. Polls may replace forms when user interaction
+# is required in browser.
 ########################################################################
 class DcPollRenderer
   
@@ -32,9 +33,9 @@ include ActionView::Helpers::FormHelper # for form hepers
 include ActionView::Helpers::FormOptionsHelper # for select helper
 
 ########################################################################
-#
+# Object initialization.
 ########################################################################
-def initialize( parent, opts={} )
+def initialize( parent, opts={} ) #:nodoc:
   @parent   = parent
   @opts     = opts
   @part_css = ''
@@ -42,14 +43,14 @@ def initialize( parent, opts={} )
 end
 
 ########################################################################
-# Dummy params method to return params object
+# Dummy params method for accesing session params object from form.
 ########################################################################
 def params
   @parent.params
 end
 
 ########################################################################
-#
+# Outputs code required for poll item. Subroutine of default method.
 ########################################################################
 def do_one_item(poll, yaml)
   html = ''
@@ -118,9 +119,9 @@ def do_one_item(poll, yaml)
 end
 
 ########################################################################
-#
+# Default poll renderer method. Renders data for specified pool.
 ########################################################################
-def render_html
+def default
 # poll_id may be defined in params or opts
   poll_id = @parent.params[:poll_id] || @opts[:poll_id]
   return '<br>Poll id is not defined?<br>' if poll_id.nil?
@@ -182,35 +183,45 @@ def render_html
     items.each do |item|
       next unless item.active # disabled items
   # convert options to yaml
-      y = YAML.load(item.options) || {}
-      y['name'] = item.name
-      y['html'] ||= {}
-      y['html']['size'] = item.size
-      (y['html']['class'] ||= 'poll-submit') if item.type == 'submit_tag'
-      y['text'] = item.text
-      y['mandatory']  = item.mandatory
+      yaml = YAML.load(item.options) || {}
+      yaml['name'] = item.name
+      yaml['html'] ||= {}
+      yaml['html']['size'] = item.size
+      (yaml['html']['class'] ||= 'poll-submit') if item.type == 'submit_tag'
+      yaml['text'] = item.text
+      yaml['mandatory']  = item.mandatory
 #      y['options']    = item.options
-      y['type']       = item.type
-      html << do_one_item(poll, y)
+      yaml['type']       = item.type
+      html << do_one_item(poll, yaml)
     end
 # Form. Just call do_one_item for each form item
   else
-    y = YAML.load(poll.form.gsub('&nbsp;',' ')) # very annoying. They come with copy&paste ;-)
+    yaml = YAML.load(poll.form.gsub('&nbsp;',' ')) # very annoying. They come with copy&paste ;-)
 # if entered without numbering yaml is returned as Hash otherwise as Array
-    y.each { |i| html << do_one_item(poll, (i.class == Hash ? i : i.last)) } # 
+    yaml.each { |i| html << do_one_item(poll, (i.class == Hash ? i : i.last)) } # 
   end
 # hide some fields usefull as parameters  
-  html << @parent.hidden_field_tag('return_to', @opts[:return_to] || @parent.params[:return_to] || '/')
+# was html << @parent.hidden_field_tag('return_to', @opts[:return_to] || @parent.params[:return_to] || '/')
+  html << @parent.hidden_field_tag('return_to', @opts[:return_to] || @parent.params[:return_to] || @parent.request.url)
   html << @parent.hidden_field_tag('return_to_error', @parent.request.url )
   html << @parent.hidden_field_tag('poll_id', poll_id )
   html << @parent.hidden_field_tag('page_id', @parent.page.id )
   html << "</form><br /></div>"
+  
   @part_css = poll.css
   html
 end
 
 ########################################################################
-#
+# Renderer dispatcher. Method returns HTML part of code.
+########################################################################
+def render_html
+  method = @opts[:method] || 'default'
+  respond_to?(method) ? send(method) : "Error DcPoll: Method #{method} doesn't exist!"
+end
+
+########################################################################
+# Return CSS part of code.
 ########################################################################
 def render_css
   @part_css

data/app/helpers/dc_renderer.rb

@@ -22,12 +22,13 @@
 #++
 
 ########################################################################
-#
+# This is abstract renderer class definition which can be reused by other
+# renders.
 ########################################################################
 class DcRenderer
   
 ########################################################################
-#
+# Object initialization.
 ########################################################################
 def initialize( parent, opts={} )
   @parent   = parent
@@ -37,7 +38,7 @@ def initialize( parent, opts={} )
 end
 
 ########################################################################
-#
+# Renderer dispatcher. Method returns HTML part of code.
 ########################################################################
 def render_html
   can_view, msg = @parent.dc_user_can_view(@parent, @parent.page)
@@ -47,7 +48,7 @@ def render_html
 end
 
 ########################################################################
-#
+# Return CSS part of code.
 ########################################################################
 def render_css
   @css

data/app/helpers/dc_simple_menu_renderer.rb

@@ -23,13 +23,19 @@
 #++
 
 ########################################################################
-#
+# Before dc_menu dc_simple_menu was the way to provide menu system. Renderer
+# provides 3 different renderer methods: default, as_dropdown, as_table. 
+# 
+# Example (as used in design):
+#    dc_render(:dc_simple_menu, name: 'my_menu', method: 'as_table')
+#    
+# If name parameter is omitted it must be provided in site document menu_name field.
 ########################################################################
 class DcSimpleMenuRenderer
 
 include DcApplicationHelper
 ########################################################################
-#
+# Object initialization.
 ########################################################################
 def initialize( parent, opts )
   @parent = parent
@@ -40,35 +46,40 @@ def initialize( parent, opts )
 end
 
 ########################################################################
-# Return selected topmenu level
+# Return selected top level menu document. Subroutine of menu renders. 
 ########################################################################
-def find_selected
+def find_selected #:nodoc:
   ret = @menu.dc_simple_menu_items.find( @parent.page.menu_id ) if @parent.page.menu_id
 # return first if not found (something is wrong)
   ret ||= @menu.dc_simple_menu_items[0]
 end
 
 ########################################################################
-# Creates edit link if in edit mode.
+# Creates edit icon for menu if in edit mode.
 ########################################################################
-def link_4edit
-  c = ''
-  if @opts[:edit_mode] > 1
-    @opts[:editparams].merge!( { table: 'dc_simple_menu', controller: 'cmsedit', action: 'edit' } )
-    title = "#{t('drgcms.edit')}: "
-    @opts[:editparams].merge!( { id: @menu.id, title: "#{title}#{@menu.name}" } ) if @menu
+def link_4edit()  #:nodoc:
+  html = ''
+  return html unless @opts[:edit_mode] > 1
+#
+  @opts[:editparams].merge!( { table: 'dc_simple_menu', controller: 'cmsedit', action: 'edit' } )
+  title = "#{t('drgcms.edit')}: "
+  if @menu # edit, when menu exists
+    @opts[:editparams].merge!( { id: @menu.id, title: "#{title}#{@menu.name}" } ) 
+  else # list available menus when menu does not yet exist
     title << t('helpers.label.dc_simple_menu.tabletitle')
-    @opts[:editparams].merge!( { action: 'index', title: title }) if @menu.nil?
-    c << dc_link_for_edit( @opts[:editparams] )
+    @opts[:editparams].merge!( { action: 'index', title: title })
   end
-  c
+  html << dc_link_for_edit( @opts[:editparams] )
 end
 
 ########################################################################
-# Returns html code required for link in a menu.
+# Returns html code required for creating one link in a menu.
+# 
+# Parameters:
+# [item] SimpleMenuItem.
 ########################################################################
 def link_4menu(item)
-# Error in early development. Throw out
+# Link should start with /
   item.link = ((item.link[0,1] == '/' ? '' : '/') + item.link) unless item.link.match('http:')
   target = item.target.blank? ? nil : item.target
   if item.caption.match('pic:')
@@ -84,54 +95,59 @@ def link_4menu(item)
 end
 
 ########################################################################
-# Renders menu as table. Thus menu is rendered evenly justified in the width defined by CSS.
+# Renders menu as table. This is single level menu only and uses table elements to 
+# display menu options evenly justified. 
 ########################################################################
 def as_table
-  c = link_4edit
-  return "#{c}#{@opts[:name]}<br>Menu not found!" if @menu.nil?
+  html = link_4edit
+  return "#{html}#{@opts[:name]}<br>Menu not found!" if @menu.nil?
 #  
   @selected = find_selected
-  c << "<table class=\"#{@menu.name.downcase}\"><tr>"
+# use div_name if specified otherwise menu.name  
+  div_name  = (@menu.div_name.to_s.size > 2 ? @menu.div_name : @menu.name).downcase
+  html << "<table class=\"#{div_name}\"><tr>"
 # sort items acording to :order  
-  items = @menu.dc_simple_menu_items.sort {|a,b| a.order <=> b.order}
+#  items = @menu.dc_simple_menu_items.sort {|a,b| a.order <=> b.order}
+  items = @menu.dc_simple_menu_items.where(active: true).order(order: 1)
   items.each do |item|
-    next unless item.active
 # menu can be hidden from user
     can_view, msg = dc_user_can_view(@parent, item)
     next unless can_view
     
-    klas = item.id == @selected.id ? "#{@menu.name.downcase}-selected" : "#{@menu.name.downcase}-item"
-    c << "<td class=\"td-#{klas}\">#{ link_4menu(item) }</td>" #
+    klas = item.id == @selected.id ? "#{div_name}-selected" : "#{div_name}-item"
+    html << "<td class=\"td-#{klas}\">#{ link_4menu(item) }</td>" #
   end
-  c << "</table>"
+  html << "</table>"
 end
 
 ########################################################################
-# Creates menu with single level dropdown menu
+# Creates menu with single level dropdown menu. This is older version of method which
+# also provided select field for selecting menu if mobile device is beeing detected.
 ########################################################################
 def as_dropdown_old
-  c = link_4edit
-  return "#{c}#{@opts[:name]}<br>Menu not found!" if @menu.nil?
+  html = link_4edit
+  return "#{html}#{@opts[:name]}<br>Menu not found!" if @menu.nil?
   # 
   items = @menu.dc_simple_menu_items.sort {|a,b| a.order <=> b.order}
 # CSS dropdown-s don't work very well on mobiles. Create simple select menu instead 
   if @parent.session[:is_mobile] == 1
-    c << "<div class=\"#{@menu.name.downcase}-mobile\">\n"
-    c << '<select onchange="window.location.href=this.options[this.selectedIndex].value">'
-    c << "<option value=\"\">#{t('drgcms.simple_menu_mobile_menu_text',' M E N U ')}</option>"
+    html << "<div class=\"#{@menu.name.downcase}-mobile\">\n"
+    html << '<select onchange="window.location.href=this.options[this.selectedIndex].value">'
+    html << "<option value=\"\">#{t('drgcms.simple_menu_mobile_menu_text',' M E N U ')}</option>"
+#    
     items.each do |item|
       next unless item.active
       # menu can be hidden from user    
       can_view, msg = dc_user_can_view(@parent, item)
       next unless can_view
-      c << "<option value=\"#{item.link}\">#{item.caption}</option>"
+      html << "<option value=\"#{item.link}\">#{item.caption}</option>"
       y = YAML.load(item.submenu) || {}
-      y.each { |k,v| c << "<option value=\"#{v['link']}\">--#{v['title']}</option>" }
+      y.each { |k,v| html << "<option value=\"#{v['link']}\">--#{v['title']}</option>" }
     end    
-    c << "</select>\n</div>\n"
+    html << "</select>\n</div>\n"
   else  
     @selected = find_selected
-    c << "<table class=\"#{@menu.name.downcase}\"><tr>"
+    html << "<table class=\"#{@menu.name.downcase}\"><tr>"
     # sort items acording to :order  
     items.each do |item|
       next unless item.active
@@ -141,33 +157,33 @@ def as_dropdown_old
       
       klas = item.id == @selected.id ? 'menu-selected' : 'menu-item'
 #      caption = item.caption.match('pic:') ? @parent.image_tag(item.caption.sub('pic:','')) : item.caption
-      c << "<td class=\"td-#{klas}\">#{ link_4menu(item) }"
+      html << "<td class=\"td-#{klas}\">#{ link_4menu(item) }"
       y = YAML.load(item.submenu) || {}
       if y.size > 0
-        c << '<ul>'
+        html << '<ul>'
         y.each do |k,v|
-          c << "<li>#{@parent.link_to(v['title'], v['link'], {target: v['target']})}</li>"
+          html << "<li>#{@parent.link_to(v['title'], v['link'], {target: v['target']})}</li>"
         end
-        c << '</ul>'
+        html << '</ul>'
       end
-      c << '</td>'
+      html << '</td>'
     end
-    c << '</tr></table>'
+    html << '</tr></table>'
   end
 end
 
 ########################################################################
-# Creates menu with single level dropdown menu
+# Creates menu with single level dropdown menu.
 ########################################################################
 def as_dropdown
-  c = link_4edit
-  return "#{c}#{@opts[:name]}<br>Menu not found!" if @menu.nil?
+  html = link_4edit
+  return "#{html}#{@opts[:name]}<br>Menu not found!" if @menu.nil?
   # 
   items = @menu.dc_simple_menu_items.sort {|a,b| a.order <=> b.order}
   @selected = find_selected
 
-  c << "<div id='#{@menu.div_name}'>" unless @menu.div_name.blank?
-  c << '<table><tr>'
+  html << "<div id='#{@menu.div_name}'>" unless @menu.div_name.blank?
+  html << '<table><tr>'
   # sort items acording to :order 
   items.each do |item|
     next unless item.active
@@ -176,33 +192,39 @@ def as_dropdown
     next unless can_view
 #
     selector = item.id == @selected.id ? 'th' : 'td'
-    c << "<#{selector}>#{ link_4menu(item) }"
+    html << "<#{selector}>#{ link_4menu(item) }"
     y = YAML.load(item.submenu) || {}
     if y.size > 0
-      c << '<ul>'
+      html << '<ul>'
       y.each do |k,v|
-        c << "<li>#{@parent.link_to(v['title'], v['link'], {target: v['target']})}</li>"
+        html << "<li>#{@parent.link_to(v['title'], v['link'], {target: v['target']})}</li>"
       end
-      c << '</ul>'
+      html << '</ul>'
     end
-    c << "</#{selector}>"
+    html << "</#{selector}>"
 
   end
-  c << '</tr></table>'
-  c << '</div>' unless @menu.div_name.blank?
-  c
+  html << '</tr></table>'
+  html << '</div>' unless @menu.div_name.blank?
+  html
 end
 
 ########################################################################
-#
+# Default renderer provides top menu menu with submenu items displayed in a line (div) below.
+# 
+# Top menu and submenu items are styled separately. If div_name is specified in
+# menu document it will be used in div, ul and li CSS names of generated HTML code. 
+# If div_name is not defined then document name will be used.
 ########################################################################
 def default
-  c = link_4edit
-  return "#{c}#{@opts[:name]}<br>Menu not found!" if @menu.nil?
+  html = link_4edit
+  return "#{html}#{@opts[:name]}<br>Menu not found!" if @menu.nil?
 #  
   @selected = find_selected
-  c << "<div class=\"#{@menu.name.downcase}\">"
-  c << "<ul class=\"ul-#{@menu.name.downcase}\">"
+# use div_name if specified otherwise menu.name  
+  div_name  = (@menu.div_name.to_s.size > 2 ? @menu.div_name : @menu.name).downcase
+  html << "<div class=\"#{div_name}\">"
+  html << "<ul class=\"ul-#{div_name}\">"
 # sort items acording to :order  
   items = @menu.dc_simple_menu_items.sort {|a,b| a.order <=> b.order}
   items.each do |item|
@@ -211,23 +233,23 @@ def default
     can_view, msg = dc_user_can_view(@parent, item)
     next unless can_view
     
-    klas = item.id == @selected.id ? "#{@menu.name.downcase}-selected" : "#{@menu.name.downcase}-item"
-    c << "<li class=\"li-#{klas}\">#{ link_4menu(item) }</li>"
+    klas = item.id == @selected.id ? "#{div_name}-selected" : "#{div_name}-item"
+    html << "<li class=\"li-#{klas}\">#{ link_4menu(item) }</li>"
   end
-  c << "</ul></div>"
+  html << "</ul></div>"
 # submenu
-  c << "<div class=\"sub-#{@menu.name.downcase}\">
-        <ul class=\"ul-sub-#{@menu.name.downcase}\">"
+  html << "<div class=\"sub-#{div_name}\">
+        <ul class=\"ul-sub-#{div_name}\">"
   y = YAML.load(@selected.submenu) || {}
   y.each do |k,v|
-    c << "<li class=\"li-sub-#{@menu.name.downcase}\">#{@parent.link_to(v['title'], v['link'])}</li>"
+    html << "<li class=\"li-sub-#{div_name}\">#{@parent.link_to(v['title'], v['link'])}</li>"
   end
-  c << '</ul></div>'
+  html << '</ul></div>'
 end
 
 
 ########################################################################
-#
+# Renderer dispatcher. Method returns HTML part of code.
 ########################################################################
 def render_html
   method = @opts[:method] || 'default'
@@ -235,7 +257,7 @@ def render_html
 end
 
 ########################################################################
-#
+# Return CSS part of code.
 ########################################################################
 def render_css
   @menu ? "#{@menu.css}\n #{@selected ? @selected.css : ''}\n" : ''