ribit 0.3.0

data/lib/ribit/ribitlogger.rb

@@ -0,0 +1,192 @@
+#--
+#    Copyright (C) 2004-2005 Tero Vuorela
+#
+#    This program is free software; you can redistribute it and/or modify it
+#    under the terms of the GNU General Public License as published by the Free
+#    Software Foundation; either version 2 of the License, or (at your option)
+#    any later version.
+#
+#    This program is distributed in the hope that it will be useful, but WITHOUT
+#    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+#    more details.
+#
+#    You should have received a copy of the GNU General Public License along with
+#    this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+#    Place - Suite 330, Boston, MA 02111-1307, USA.
+#++
+
+require 'rubygems'
+require_gem 'log4r'
+require 'log4r/configurator'
+require 'log4r/outputter/extendedrollingfileoutputter'
+require 'common/loggerfactory'
+
+#
+module Ribit
+  
+  ##
+  #
+  class RibitLogger
+    #
+    def RibitLogger.new( loggerName )
+      return LoggerFactory.get_logger( loggerName )
+    end
+  end
+  
+  ##
+  #
+  class RibitLoggerConfig
+    @@configurationFileLoaded = false
+    
+    #
+    def RibitLoggerConfig.init_with_stdout  
+      LoggerFactory.set_instance( RibitLoggerFactory.new )
+    end
+      
+    #
+    def RibitLoggerConfig.init_from_file( configFileName )
+      Log4r::Configurator.load_xml_file( configFileName )
+      LoggerFactory.set_instance( RibitLoggerFactory.new )
+      
+      logger = LoggerFactory.get_logger( RibitLoggerConfig )
+      @@configurationFileLoaded = true
+      logger.info( 'Log4r system configured and started' ) 
+    end
+    
+    #
+    def RibitLoggerConfig.configure( log4rLogger )
+      if ( not @@configurationFileLoaded )
+        Log4r::Outputter.stdout.formatter = Log4r::PatternFormatter.new( :pattern => "%l: [%C] %m" )
+        log4rLogger.outputters = Log4r::Outputter.stdout  
+      end
+    end
+    
+    #
+    def RibitLoggerConfig.reset
+      @@configurationFileLoaded = false
+    end
+    
+  end
+  
+  ##
+  # 
+  class RibitLoggerImpl
+    #
+    def initialize( loggerName )
+      @name = loggerName.to_s
+
+      # we add Ribit:: if not yet there
+      if not /^Ribit::/.match( @name )
+        @name = 'Ribit::' + @name
+      end
+      
+      @logger = Log4r::Logger.new( @name )
+      RibitLoggerConfig.configure( @logger )
+    end
+    
+    #
+    def debug( msg )
+      @logger.debug( buildMsg( msg ) )
+    end
+    
+    #
+    def info( msg )
+      @logger.info( buildMsg( msg ) )
+    end
+    
+    #
+    def warn( msg )
+      @logger.warn( buildMsg( msg ) )
+    end
+    
+    #
+    def error( msg )
+      @logger.error( buildMsg( msg ) )
+    end
+    
+    #
+    def fatal( msg )
+      @logger.fatal( buildMsg( msg ) )
+    end
+  
+    #
+    def debug?
+      @logger.debug?
+    end
+    
+  private 
+    #
+    def buildMsg( msg )
+        # currently use msg as it is
+      return msg
+    end  
+  end
+  
+  ##
+  #
+  class RibitLoggerFactory
+    
+    #
+    def initialize
+      @loggersByName = {}
+    end
+    
+    #
+    def get_logger( loggerName )
+      logger = @loggersByName[loggerName]
+      
+      if ( logger == nil )
+        logger = RibitLoggerImpl.new( loggerName )
+        @loggersByName[loggerName] = logger
+      end
+      
+      return logger
+    end
+    
+  end
+
+  ##
+  #
+  class RibitLoggerWrapper 
+    # log-level constants
+    FATAL = 1
+    ERROR = 2
+    WARN = 3
+    INFO = 4 
+    DEBUG = 5
+
+    #
+    def initialize( ribitLogger, level, prefix='' )
+      @ribitLogger = ribitLogger
+      @level = level
+      @prefix = prefix
+    end
+    
+    # Directs logging to proper level
+    def <<( data ) 
+      case @level
+        when FATAL
+          @ribitLogger.fatal( @prefix + data.strip )
+        when ERROR
+          @ribitLogger.error( @prefix + data.strip )
+        when WARN
+          @ribitLogger.warn( @prefix + data.strip )
+        when INFO
+          @ribitLogger.info( @prefix + data.strip )
+        when DEBUG
+          @ribitLogger.debug( @prefix + data.strip )
+        else
+          @ribitLogger.error( @prefix + 'Unknown logging level for RibitLoggerWrapper' + @level.to_s )
+          @ribitLogger.info( @prefix + data.strip )
+      end
+    end
+    
+    #
+    def debug?
+      @ribitLogger.debug?
+    end
+    
+  end
+    
+end # end of module

data/lib/ribit/webpage.rb

@@ -0,0 +1,802 @@
+#--
+#    Copyright (C) 2004-2005 Tero Vuorela
+#
+#    This program is free software; you can redistribute it and/or modify it
+#    under the terms of the GNU General Public License as published by the Free
+#    Software Foundation; either version 2 of the License, or (at your option)
+#    any later version.
+#
+#    This program is distributed in the hope that it will be useful, but WITHOUT
+#    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+#    more details.
+#
+#    You should have received a copy of the GNU General Public License along with
+#    this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+#    Place - Suite 330, Boston, MA 02111-1307, USA.
+#++
+
+require 'ribit/xhtmldocument'
+require 'ribit/contentparser'
+require 'ribit/xhtmltag'
+require 'ribit/actionelement'
+require 'ribit/common'
+require 'ribit/action'
+require 'ribit/constants'
+require 'ribit/localization'
+require 'common/assert'
+require 'common/properties'
+require 'set'
+
+##
+#
+class WebPage
+  
+  # 
+  def initialize
+  end
+  
+  #
+  def output_page( pageResponse )
+    pageResponse.set_body( get_data() )
+    pageResponse.set_content_type( get_content_type() )
+  end
+  
+  #
+  def get_data
+    raise 'WebPage.get_data() should be overriden in subclasses'
+  end
+  
+  # 
+  def get_content_type
+    raise 'WebPage.get_content_type() should be overriden in subclasses'
+  end
+  
+end
+
+#
+class RawPage < WebPage
+  
+  #
+  def initialize( data, content_type='text/plain' )
+    @data = data
+    @contentType = content_type
+  end
+  
+  #
+  def get_data
+    return @data
+  end
+  
+  # 
+  def get_content_type
+    return @contentType
+  end
+  
+end
+
+##
+#
+class XHTMLPage < WebPage
+  
+  # Throws error if not valid XHTML document
+  def initialize( xhtmlData )
+    @doc = XHTMLDocument.new( xhtmlData )
+    @logger = RibitLogger.new( XHTMLPage )
+    @messageText = nil
+  end
+  
+  # 
+  def set_message( text )
+    @messageText = text
+  end
+  
+  # Fills the template document and returns document in String format
+  def get_data
+    
+    # TODO: can following be optional or should they be removed
+    #      decl = REXML::XMLDecl.new
+    #      decl.encoding= REXML::XMLDecl::DEFAULT_ENCODING
+    #      @doc << decl
+    #      
+    #      # write DOCTYPE
+    #      info = [
+    #      'html',
+    #      'PUBLIC',
+    #      '"-//W3C//DTD XHTML Basic 1.0//EN"',
+    #      '"http://www.w3.org/TR/xhtml-basic/xhtml-basic10.dtd"']
+    #  
+    #      @doc << REXML::DocType.new( info )
+    
+    @doc.process_marked_elements do |id, ele|
+      @logger.debug( "Handling action for ID=#{id}, ele.name=#{ele.name}" )
+      begin
+        handle_element( id, ele )
+      rescue RibitException => e 
+        @logger.warn( "Couldn't handle action in HTML, element will be removed: #{e.message}" )
+        @logger.warn( format_exception( e ) )
+        ele.remove
+      end
+    end
+    
+    return @doc.to_s
+  end
+  
+  #
+  def add_head_element( element )
+    @doc.add_metadata( element )
+  end
+  
+  # 
+  def handle_element( id, element )
+    case id
+    when 'link:main'
+      if ( element.name != 'a' )
+        raise RibitException, "link:main is not suitable for element #{element.name}", caller
+      end
+      
+      actionEle = LinkActionElement.new( id, element )
+      
+      # no URL => refers to base URL that points to 
+      # the default page (=main page)
+      actionEle.url = ''
+      
+    when 'link:categories'
+      if ( element.name != 'a' )
+        raise RibitException, "link:categories is not suitable for element #{element.name}", caller
+      end
+      
+      actionEle = LinkActionElement.new( id, element )
+      actionEle.url = ViewCategoriesActionAdapter.new().get_url
+      @logger.debug( "URL to ViewCategories is " + actionEle.url )
+      
+    when 'text:message'
+      # replaces all 'text:message' entries
+      if ( @messageText != nil )
+        insert_html_text( element, @messageText )
+      else
+        element.remove
+      end
+      
+    else
+      # rest of text and link elements are removed
+      if ( /^text:/.match( id ) or /^link:/.match( id ) )
+        element.remove
+      else
+        raise RibitException, "Unknown actionID=#{id}, don't know how to handle", caller
+      end
+    end
+  end
+  
+  # insert text that can contain html tags => they are not escaped
+  def insert_html_text( element, text )
+    element.text = nil
+    # NOTE: some reason setting raw in constructor didn't work 
+    text = REXML::Text.new( text, true, nil, false )
+    text.raw = true
+    element.add_text( text )
+  end
+  
+end
+
+##
+# 
+class TextPage < XHTMLPage
+  include Assert
+  
+  def initialize( ribitData, page, ribitConfig )
+    assert_not_nil( ribitData )
+    assert_not_nil( ribitConfig )
+    template = ribitData.get_page_by_full_name( "core::pagetemplate" )
+    
+    super( template.data )
+    
+    @ribitData = ribitData
+    @ribitConfig = ribitConfig
+    
+    @page = page
+    @logger = RibitLogger.new( TextPage )
+    
+  end
+  
+  # Always text/html
+  def get_content_type
+    return 'text/html'
+  end
+  
+  #
+  def handle_element( id, element )
+    case id
+    when 'text:title'
+      insert_html_text( element, @page.title )
+    when "text:body"
+      insert_html_text( element, get_page_data )
+      
+    when 'link:edit'
+      if ( element.name != 'a' )
+        raise RibitException, "link:edit is not suitable for element #{element.name}", caller
+      end
+      
+      actionEle = LinkActionElement.new( id, element )
+      actionEle.url = EditActionAdapter.new( @page.full_id ).get_url()    
+      
+    when 'link:validator'
+      if ( element.name != 'a' )
+        raise RibitException, "link:validator is not suitable for element #{element.name}", caller
+      end
+      
+      viewUrl = ViewActionAdapter.new( @page.full_id ).get_url
+      baseUrlStr = @ribitConfig.get_base_url
+      
+      validator = W3CValidatorLinkActionAdapter.new( baseUrlStr + '/' + viewUrl.to_s )
+      
+      actionEle = LinkActionElement.new( id, element )
+      actionEle.url = validator.get_url
+      
+    when 'link:category-bar'
+      handle_category_bar( id, element )
+      
+    when 'link:category-bar-next-level'
+      handle_category_bar_next_level( id, element )    
+      
+    else
+      super( id, element )
+    end    
+    
+  end
+  
+  #
+  def handle_category_bar( id, element )
+    @logger.debug( "Category-bar selected: pageID=#{@page.full_id}" )
+    adapters = []
+    
+    # the current page whose parent categories are searched
+    category = @page.category
+    
+    while ( category != nil )
+      mainPageID = category.get_main_page_full_id
+      if ( mainPageID != nil )
+        adapters.push( ViewActionAdapter.new( mainPageID, category.name ) )
+      else
+        mainPageID = category.id.to_s + "::empty"
+        adapters.push( ViewActionAdapter.new( mainPageID, category.name ) )
+      end
+      category = category.get_parent_category
+    end
+    
+    actionEle = CategoryBarActionElement.new( id, element )
+    actionEle.replace_link_elements( adapters.reverse )
+  end
+  
+  #
+  def handle_category_bar_next_level( id, element )
+    @logger.debug( "Category-bar-next-level selected: pageID=#{@page.full_id}" )
+    adapters = []
+    
+    # the current page whose parent categories are searched
+    category = @page.category
+    @logger.debug( "childs.size(): " + category.get_child_categories.size().to_s )
+    
+    # before iterating sort categories
+    children = category.get_child_categories
+    
+    if ( children != nil and children.size() > 0 )
+      children = children.sort do |a,b| 
+        @logger.debug( "compare: a =" + a.name + ", b =" + b.name )
+        a.name<=>b.name
+      end
+      
+      children.each do |childCategory|
+        mainPageID = childCategory.get_main_page_full_id
+        if ( mainPageID != nil )
+          adapters.push( ViewActionAdapter.new( mainPageID, childCategory.name ) )
+        else
+          mainPageID = childCategory.id + "::empty"
+          adapters.push( ViewActionAdapter.new( mainPageID, childCategory.name ) )
+        end
+      end
+    end
+    
+    actionEle = CategoryBarNextLevelActionElement.new( id, element )
+    actionEle.replace_link_elements( adapters )
+  end
+  
+  #
+  def get_page_data
+    @logger.debug( "Converting data for page ID=#{@page.full_id}, fullName=#{@page.full_name}" )
+    
+    @logger.debug( "Going to convert following data:\n" + @page.data )
+    parser = ContentParser.new(  @ribitData )
+    data = parser.parse( @page )
+    
+    @logger.debug( "Result is:\n" + data )
+    return data
+  end  
+  
+end
+
+##
+# 
+class CategoriesPage < XHTMLPage
+  include Assert
+  include Localization
+  
+  def initialize( ribitData, ribitConfig )
+    assert_not_nil( ribitData )
+    assert_not_nil( ribitConfig )
+    template = ribitData.get_page_by_full_name( "core::pagetemplate" )
+    
+    super( template.data )
+    
+    @ribitData = ribitData
+    @ribitConfig = ribitConfig
+    
+    @logger = RibitLogger.new( CategoriesPage )    
+  end
+  
+  # Always text/html
+  def get_content_type
+    return 'text/html'
+  end
+  
+  # 
+  def handle_element( id, element )
+    @logger.debug( "Handling action ID=#{id}" )
+    case id
+      
+    when 'link:category-bar-next-level'
+      @logger.debug( "Category-bar-next-level selected for Categories page" )
+      adapters = []
+      
+      # before iterating sort categories
+      categories = @ribitData.get_all_categories
+      
+      if ( categories != nil and categories.size > 0 )
+        categories = categories.sort do |a,b| 
+          #@logger.debug( "compare: a =" + a.name + ", b =" + b.name )
+          a.name<=>b.name
+        end
+        
+        categories.each do |category|
+          #@logger.debug( "cat " + category.name + " vis = " + category.visible?.to_s )
+          if ( category.toplevel_category? and category.visible? )
+            mainPageID = category.get_main_page_full_id
+            if ( mainPageID != nil )
+              adapters.push( ViewActionAdapter.new( mainPageID, category.name ) )
+            else
+              mainPageID = category.id + "::empty"
+              adapters.push( ViewActionAdapter.new( mainPageID, category.name ) )
+            end
+          end
+        end
+      end
+      
+      actionEle = CategoryBarNextLevelActionElement.new( id, element )
+      actionEle.replace_link_elements( adapters )
+      
+    when 'text:title'
+      insert_html_text( element, get_localized( TITLE_CATEGORIES_PAGE ) )
+    when 'text:body'
+      insert_html_text( element, get_page_data )
+      
+    when 'link:validator'
+      if ( element.name != 'a' )
+        raise RibitException, "link:validator is not suitable for element #{element.name}", caller
+      end
+      
+      viewUrl = ViewCategoriesActionAdapter.new().get_url
+      baseUrlStr = @ribitConfig.get_base_url
+      
+      validator = W3CValidatorLinkActionAdapter.new( baseUrlStr + '/' + viewUrl.to_s )
+      
+      actionEle = LinkActionElement.new( id, element )
+      actionEle.url = validator.get_url
+      
+    else
+      @logger.debug( "Action not found, calling super" )
+      super( id, element )
+    end
+    
+  end
+  
+  #
+  def get_page_data
+    data = "<ul>"
+    
+    categories = @ribitData.get_visible_root_categories
+    categories.sort! { |a,b| a.full_name<=>b.full_name }
+    @logger.debug( "Processing categories: " + categories.to_s )
+    
+    categories.each do |category|
+      data << format_category( category, "" )
+    end
+    data << "</ul>"
+    @logger.debug( "Result is:\n" + data )
+    return data
+  end  
+  
+  #
+  def format_category( category, parentPath )
+    fullName = category.full_name
+    
+    data = "<li>"
+    data << "<strong>#{fullName}</strong> "
+    
+    editCategoryAction = EditCategoryActionAdapter.new( category.id )
+    linkTag = LinkTag.new( editCategoryAction.get_url, '[edit]', false )
+    linkTag.set_class( 'edit-category-link' )
+    data << linkTag.to_s 
+    
+    data << "<ul>"
+    
+    categoryMainPageFullID = category.get_main_page_full_id()
+    
+    pages = category.get_pages
+    pages.sort! { |a,b| a.name<=>b.name }
+    
+    pages.each do |page|
+      data << "<li>"
+      action = ViewActionAdapter.new( page.full_id )	
+      data << LinkTag.new( action.get_url, page.name, false ).to_s
+      
+      if ( page.full_id == categoryMainPageFullID )
+        data << ' (m)'
+      end
+      
+      data << "</li>"
+    end
+    data << "</ul>"
+    
+    data << "</li>"
+    childs = category.get_child_categories
+    
+    if ( childs != nil and childs.size > 0 )
+      childs.sort! { |a,b| a.full_name<=>b.full_name }
+      
+      childs.each do |child|
+        data << format_category( child, fullName )
+      end
+    end
+    
+    return data
+  end
+  
+end
+
+##
+# 
+class EditPage < XHTMLPage
+  include Assert
+  include Localization
+  
+  def initialize( ribitData, pageID, previousPageID, ribitConfig )
+    assert_not_nil( ribitData )
+    assert_not_nil( ribitConfig )
+    assert_not_nil( previousPageID )
+    
+    @ribitData = ribitData
+    @ribitConfig = ribitConfig
+    @pageID = pageID
+    @logger = RibitLogger.new( EditPage )
+    @hiddenFormFields = Array.new
+    @formActionParams = PropertyList.new
+    
+    @previousPageID = previousPageID
+    add_hidden_form_field( HiddenFormInputTag.new( Constants::PREV_FORM_PARAM_NAME, previousPageID ) )
+    
+    template = ribitData.get_page_by_full_name( 'core::edittemplate' )
+    super( template.data )
+  end
+  
+  # Always text/html
+  def get_content_type
+    return 'text/html'
+  end
+  
+  #
+  def add_hidden_form_field( hiddenFieldTag )
+    @hiddenFormFields.push( hiddenFieldTag )
+  end
+  
+  #
+  def add_form_action_params( key, value )
+    @formActionParams.put( key, value )
+  end
+  
+  #
+  def handle_element( id, element )
+    case id
+    when 'text:title'
+      if ( @pageID == Constants::NEW_PAGE_ID )
+        insert_html_text( element, get_localized( TITLE_NEW_PAGE ) )
+      else
+        insert_html_text( element, @ribitData.get_page_by_id( @pageID ).title )
+      end  
+      
+    when 'text:body'
+      if ( @pageID == Constants::NEW_PAGE_ID )
+        element.text = ''
+      else
+        #puts "### get_replacement_data: " + @ribitData[@pageID].data
+        
+        # allow entity encoding happen
+        element.text = @ribitData.get_page_by_id( @pageID ).data
+      end    
+      
+    when "replace:category"
+      if ( @pageID == Constants::NEW_PAGE_ID )
+        categoryFullName = @formActionParams.get( Constants::CATEGORY_REQUEST_PARAM_NAME )
+        
+        if ( /^::/.match( categoryFullName ) == nil )
+          categoryFullName = '::' + categoryFullName
+        end
+      else
+        categoryFullName = @ribitData.get_page_by_id( @pageID ).category.full_name
+      end
+      
+      element.text = element.text.gsub( /#\{category\}/, categoryFullName )
+      
+    when "set:page-name"
+      if ( @pageID == Constants::NEW_PAGE_ID )
+        element.attributes['value'] = @formActionParams.get( Constants::PAGE_NAME_REQUEST_PARAM_NAME )
+      else
+        element.attributes['value'] = @ribitData.get_page_by_id( @pageID ).name
+      end
+      
+      element.text = nil
+      
+    when 'link:validator'
+      if ( element.name != 'a' )
+        raise RibitException, "link:validator is not suitable for element #{element.name}", caller
+      end
+      
+      # NOTE: this could be nicer but should work (we know too many details)
+      if ( @pageID == Constants::NEW_PAGE_ID )
+        viewUrl = EditNewActionAdapter.new(
+          @formActionParams.get( Constants::PAGE_NAME_REQUEST_PARAM_NAME ),
+          @formActionParams.get( Constants::CATEGORY_REQUEST_PARAM_NAME ),
+          @previousPageID ).get_url
+        
+      else
+        viewUrl = EditActionAdapter.new( @pageID ).get_url
+      end
+      baseUrlStr = @ribitConfig.get_base_url
+      
+      validator = W3CValidatorLinkActionAdapter.new( baseUrlStr + '/' + viewUrl.to_s )
+      #@logger.debug( "validator url: " + validator.get_url )
+      
+      actionEle = LinkActionElement.new( id, element )
+      actionEle.url = validator.get_url
+      
+    when 'action:form'
+      if ( element.name != 'form' )
+        raise RibitException, "action:form is not suitable for element #{element.name}", caller
+      end
+      
+      adapter = FormActionAdapter.new( @pageID )
+      
+      # add action parameters
+      @formActionParams.keys.each do |key|
+        adapter.add_param( key, @formActionParams.get( key ) )
+      end
+      
+      actionEle = FormActionElement.new( id, element )
+      # NOTE: prevent double encoding (could be nicer)
+      actionEle.url = adapter.get_url( false )
+      
+      if ( not @hiddenFormFields.empty? )
+        # input fields can't be directly under 'form'
+        p = DivTag.new()
+        
+        # NOTE: here we rely on that 'action' is FormActionElement
+        actionEle.insert_to_top( p )
+        
+        @hiddenFormFields.each do |fieldTag|
+          p.add_element( fieldTag )
+        end
+        
+      end
+    else
+      super( id, element )
+    end    
+    
+  end
+  
+end
+
+##
+# 
+class EditCategoryPage < XHTMLPage
+  include Assert
+  include Localization
+  
+  def initialize( ribitData, categoryID, ribitConfig )
+    assert_not_nil( ribitData )
+    assert_not_nil( ribitConfig )
+    
+    @ribitData = ribitData
+    @ribitConfig = ribitConfig
+    @categoryID = categoryID
+    @logger = RibitLogger.new( EditPage )
+    @hiddenFormFields = Array.new
+    @formActionParams = PropertyList.new
+    
+    template = ribitData.get_page_by_full_name( 'core::edit-category-template' )
+    super( template.data )
+  end
+  
+  # Always text/html
+  def get_content_type
+    return 'text/html'
+  end
+  
+  #
+  def add_hidden_form_field( hiddenFieldTag )
+    @hiddenFormFields.push( hiddenFieldTag )
+  end
+  
+  #
+  def add_form_action_params( key, value )
+    @formActionParams.put( key, value )
+  end
+  
+  #
+  def handle_element( id, element )
+    
+    case id
+    when 'text:title'
+      if ( @categoryID == Constants::NEW_PAGE_ID )
+        insert_html_text( element, get_localized( TITLE_NEW_CATEGORY ) )
+      else
+        insert_html_text( element,  @ribitData.get_category_by_id( @categoryID ).name )
+      end
+      
+    when 'set:category-name'
+      if ( @categoryID == Constants::NEW_PAGE_ID )
+        element.attributes['value'] = @formActionParams.get( Constants::CATEGORY_NAME_REQUEST_PARAM_NAME )
+      else
+        element.attributes['value'] = @ribitData.get_category_by_id( @categoryID ).name
+      end
+      element.text = nil
+      
+    when 'set:category-main-page'
+      # TODO: new category not implemented yet
+      
+      # we know main-page is selected by combobox
+      category =  @ribitData.get_category_by_id( @categoryID )
+      
+      pages = category.get_pages
+      mainPageFullID = category.get_main_page_full_id
+      
+      pages.sort! { |a,b| a.name<=>b.name }
+      
+      # in template there might be example opton tags => remove those
+      element.children.each do |child|
+        element.delete( child )
+      end
+      
+      # next create new option tags
+      pages.each do |page|
+        optionTag = SelectOptionTag.new( page.id, page.name )
+        
+        if ( page.full_id == mainPageFullID )
+          optionTag.set_selected
+        end
+        
+        element.add( optionTag )
+      end
+      
+      element.text = nil
+      
+    when "set:category-parent"
+      set_category_parent( element )
+      
+    when 'link:validator'
+      if ( element.name != 'a' )
+        raise RibitException, "link:validator is not suitable for element #{element.name}", caller
+      end
+      
+      # NOTE: this could be nicer but should work (we know too many details)
+      if ( @categoryID == Constants::NEW_CATEGORY_ID )
+        
+        viewUrl = EditNewCategoryActionAdapter.new(
+                                                   @formActionParams.get( Constants::PAGE_NAME_REQUEST_PARAM_NAME ),
+        @formActionParams.get( Constants::CATEGORY_REQUEST_PARAM_NAME ) ).get_url
+        
+      else
+        viewUrl = EditCategoryActionAdapter.new( @categoryID ).get_url
+      end
+      baseUrlStr = @ribitConfig.get_base_url
+      
+      validator = W3CValidatorLinkActionAdapter.new( baseUrlStr + '/' + viewUrl.to_s )
+      
+      actionEle = LinkActionElement.new( id, element )
+      actionEle.url = validator.get_url
+      
+    when 'action:form'
+      adapter = CategoryFormActionAdapter.new( @categoryID )
+      
+      # add action parameters
+      @formActionParams.keys.each do |key|
+        adapter.add_param( key, @formActionParams.get( key ) )
+      end
+      
+      actionEle = FormActionElement.new( id, element )
+      # NOTE: prevent double encoding (could be nicer)
+      actionEle.url = adapter.get_url( false )
+      
+      # NOTE: here we rely on that 'action' is FormActionElement
+      @hiddenFormFields.each do |fieldTag|
+        actionEle.insert_to_top( fieldTag )
+      end
+      
+    else
+      super( id, element )
+    end
+    
+  end
+  
+  #
+  def set_category_parent( element )
+    # TODO: new category not implemented yet
+    
+    currentCategory = @ribitData.get_category_by_id( @categoryID )
+    parentCategory = currentCategory.get_parent_category
+    childCategoryIDs = get_child_category_ids( currentCategory )
+    
+    # in template there might be example opton tags => remove those
+    element.children.each do |child|
+      element.delete( child )
+    end
+    
+    allCategories = @ribitData.get_all_categories
+    
+    # - 'no parent' option included
+    # - can't select itself
+    # - can't select any if its childs
+    # - can't select unvisible categories
+    
+    # add 'no parent tag'
+    noParentOptionTag = SelectOptionTag.new( 
+                                            Constants::CATEGORY_NO_PARENT_FORM_VALUE, 
+                                            get_localized( NO_PARENT_OPTION ) )
+    
+    element.add( noParentOptionTag )
+    selectionSet = false
+    
+    allCategories.each do |category|
+      if ( category.id != currentCategory.id and category.visible? and not childCategoryIDs.include?( category.id ) )
+        optionTag = SelectOptionTag.new( category.id, category.name )
+        
+        if ( parentCategory != nil and parentCategory.id == category.id )
+          optionTag.set_selected
+          selectionSet == true
+        end
+        
+        element.add( optionTag )
+      end
+      
+    end
+    
+    noParentOptionTag.set_selected if not selectionSet
+    
+    element.text = nil
+  end
+  
+  #
+  def get_child_category_ids( category )
+    
+    if ( category == nil )
+      return Set.new
+    end
+    
+    ids = Set.new
+    category.get_child_categories().each do |childCategory|
+      ids.add( childCategory.id )
+      ids.merge( get_child_category_ids( childCategory ) )
+    end
+    
+    return ids
+  end
+  
+end