ribit 0.3.0

data/lib/common/loggerfactory.rb

@@ -0,0 +1,56 @@
+#--
+#    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 'logger'
+
+##
+#
+class LoggerFactory
+  # singleton
+  @@instance = nil
+  
+  #
+  def LoggerFactory.get_logger( loggerName )
+    if ( @@instance == nil )
+      create_default_instance
+    end
+    
+    return @@instance.get_logger( loggerName )
+  end
+  
+  #
+  def LoggerFactory.set_instance( newLogFactory )
+    @@instance = newLogFactory
+  end
+  
+  private
+  # 
+  def LoggerFactory.create_default_instance
+    @@instance = DefaultLoggerFactory.new
+  end
+end
+
+##
+#
+class DefaultLoggerFactory 
+  # Returns a new logger named 'loggerName'
+  def get_logger( loggerName )
+    # by default return
+    return Logger.new( STDOUT )
+  end
+end

data/lib/common/pid.rb

@@ -0,0 +1,44 @@
+#--
+#    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.
+#++
+
+##
+#
+class Pid
+  attr_reader :pid
+  
+  #
+  def initialize
+    @pid = Process.pid
+  end
+  
+  #
+  def write_to_file( fileName )
+    if ( fileName == nil ) 
+      raise IOException( 'File name is nil' )
+    end
+    
+    pidHandle = File.new( fileName, 'w' )
+    pidHandle.print( pid )
+    pidHandle.close
+  end
+  
+  #
+  def to_s
+    @pid.to_s
+  end
+end

data/lib/common/properties.rb

@@ -0,0 +1,89 @@
+#--
+#    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.
+#++
+
+##
+#
+class Properties
+
+  #
+  def initialize
+    @props = Hash.new
+  end
+  
+  #
+  def get( key )
+    return @props[key]
+  end
+  
+  #
+  def put( key, value )
+    @props[key] = value
+  end
+  
+  #
+  def load( inputStream )
+    inputStream.each_line do |line|
+        if ( /^[ \t]*#/.match( line ) != nil or /^[ \t]*$/.match( line ) != nil )
+          # it is a comment line or empty line => skip it
+        else
+        match = /([^=]+)=(.*)/.match( line )
+            key = match[1].strip
+            value = match[2].strip
+           @props[key] = value
+      end
+    end
+  end
+
+end
+
+##
+#
+class PropertyList
+  
+  #
+  def initialize
+    @keys = Array.new
+    @values = Array.new
+  end
+  
+  #
+  def put( key, value )
+    if ( get( key ) != nil )
+      raise 'Key is already used'
+    end
+    
+    @keys.push( key )
+    @values.push( value )
+  end
+  
+  #
+  def get( key )
+    i = @keys.index( key )
+    if ( i == nil )
+      return nil
+    end
+    
+    return @values[i]
+  end
+   
+  # Keeps the order where key-value pairs were inserted
+  def keys
+    return @keys
+  end
+  
+end

data/lib/common/url.rb

@@ -0,0 +1,64 @@
+#--
+#    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 'uri'
+
+##
+# 
+class URL
+  attr_reader :pid
+  
+  #
+  def initialize( protocol, address, path )
+    @protocol = protocol
+    @address = address
+    @path = path
+    
+    # params are stored to list so that we can keep order they have been added
+    @paramNames = []
+    @paramValuesByName = {}
+  end
+  
+  #
+  def add_param( name, value )
+    @paramNames.push( name )
+    @paramValuesByName[name] = value
+  end
+  
+  #
+  def to_s
+    url = ''
+    url << @protocol + '://' if @protocol != nil
+    url << @address if @address != nil
+    url << '/' if not url.empty?
+    
+    # path always exists
+    url << @path
+    url << '?'
+    
+    @paramNames.each do |name|
+      value = @paramValuesByName[name]
+      value = URI.escape( value )
+      url << "#{name}=#{value}"
+      url << '&'
+    end
+    
+    # last char away (? or & character)
+    url.chop
+  end
+end

data/lib/log4r/outputter/extendedrollingfileoutputter.rb

@@ -0,0 +1,73 @@
+#--
+#    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/logger'
+require 'log4r/outputter/rollingfileoutputter'
+require 'date'
+
+module Log4r
+  ##
+  # ExtendedRollingFileOutputter - subclass of RollingFileOutputter that takes
+  # date pattern what is used to build the log file name.
+  #
+  # Example: Default pattern '-%d%m%Y-%H%H%S' creates log files like
+  # myapp-01082004-123150.log.
+  #
+  # Additional hash arguments are:
+  #
+  # [<tt>:datepattern</tt>]   Pattern used in build log file name
+  #
+  class ExtendedRollingFileOutputter < Log4r::RollingFileOutputter
+  
+    #
+    def initialize( _name, hash={} )
+      
+      if ( hash['datepattern'] != nil )
+        @datePattern = hash['datepattern']
+      else
+        @datePattern = '-%d%m%Y-%H%H%S'
+      end
+      
+      super( _name, hash )
+    end
+  
+    # construct a new filename from the count and baseFileName
+    def makeNewFilename( counter=nil )
+      pad = Time.now.strftime( @datePattern )
+      pad << '-' + counter.to_s if counter != nil
+      newbase = @baseFilename.sub(/(\.\w*)$/, pad + '\1')
+      @filename = File.join(File.dirname(@filename), newbase)
+      
+      if ( File.exist?( @filename ) )
+        puts "exists " + @filename
+        counter = 0 unless counter != nil
+        counter = counter + 1
+        
+        return makeNewFilename( counter )
+      end
+        
+      Logger.log_internal {"File #{@filename} created"}
+      
+      return @filename
+    end
+  
+  end
+
+end

data/lib/ribit/action.rb

@@ -0,0 +1,1106 @@
+#--
+#    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/common'
+require 'ribit/localization'
+require 'ribit/webpage'
+require 'ribit/xhtmltag'
+require 'ribit/ribitdata'
+require 'ribit/constants'
+require 'common/assert'
+require 'common/url'
+require 'rexml/document'
+
+#
+class WebAction
+  attr_reader :id
+  
+  #
+  def run( pageRequest, pageResponse )
+    @pageRequest = pageRequest
+  end
+  
+  #
+  def add_headers( page )
+    baseUrlTag = BaseTag.new( @pageRequest.get_base_url )
+    page.add_head_element( baseUrlTag )
+  end
+  
+end
+
+#
+class ActionManager
+
+  #
+  def initialize()
+    @actions = Hash.new
+    @defaultAction = nil
+  end
+  
+  #
+  def register_action( webAction )
+    if ( @actions[webAction.id] != nil )
+      raise "ID #{webAction.id} already registered"
+    end
+    
+    @actions[webAction.id] = webAction
+  end
+  
+  # 
+  def set_default_action( id )
+    if ( @actions[id] == nil )
+      raise "No action registered for ID=#{id}"
+    end
+    
+    @defaultAction = @actions[id]
+  end
+  
+  # Returns default action if action not found
+  def get_action( id )
+    if ( id == nil )
+      # return default action
+      return @defaultAction
+    end
+    
+    return @actions[id]
+  end
+  
+end
+
+##
+#
+class CompositeAction < WebAction
+
+  #
+  def initialize( id )
+    @id = id
+    @actions = Hash.new
+  end
+  
+  #
+  def add_action( webAction )
+    @actions[webAction.id] = webAction
+  end
+  
+  #
+  def run( pageRequest, pageResponse )
+    super( pageRequest, pageResponse )
+    
+    actionID = get_child_action_id( pageRequest )
+    @actions[actionID].run( pageRequest, pageResponse )
+  end
+  
+  #
+  def get_child_action_id( pageRequest )
+    raise 'should be implemented in child classes'
+  end
+end
+
+##
+#
+class FormAction < CompositeAction
+  ID = 'form'
+  #
+  def initialize( ribitData )
+    super( ID )
+  end
+
+  #
+  def get_child_action_id( pageRequest )
+    query = pageRequest.get_query_data
+    
+    # Only that name has a value that is attached
+    # to pressed button
+
+      @actions.each_key do |key|
+        if ( query[key] != nil )
+          return key
+        end
+      end
+
+    # no action found    
+    return nil
+  end
+    
+end
+
+##
+#
+class CategoryFormAction < CompositeAction
+  ID = 'category-form'
+  #
+  def initialize( ribitData )
+    super( ID )
+  end
+
+  #
+  def get_child_action_id( pageRequest )
+    query = pageRequest.get_query_data
+    
+    # Only that name has a value that is attached
+    # to pressed button
+
+      @actions.each_key do |key|
+        if ( query[key] != nil )
+          return key
+        end
+      end
+
+    # no action found    
+    return nil
+  end
+    
+end
+
+##
+#
+class SaveAction < WebAction
+  include Assert
+  include Localization
+  
+  #
+  def initialize( ribitData, ribitConfig, pageCache )
+    assert_not_nil( ribitData, 'RibitData is nil' )
+    
+    @id = 'form:save'
+    @ribitData = ribitData
+    @ribitConfig = ribitConfig
+    @pageCache = pageCache
+    @logger = RibitLogger.new( SaveAction )
+  end
+
+    #
+  def run( pageRequest, pageResponse )
+    super( pageRequest, pageResponse )
+  
+    pageID = pageRequest.get_requested_page_id
+    message = ''
+    
+    if ( pageID == nil )
+      raise RibitException, 'No page ID defined for save action', caller
+    end
+    
+    query = pageRequest.get_query_data
+    data = query[Constants::PAGE_DATA_FORM_PARAM_NAME]
+    name = query[Constants::PAGE_NAME_FORM_PARAM_NAME]
+      
+    if ( pageID == Constants::NEW_PAGE_ID )
+      categoryName = pageRequest.get_request_param( Constants::CATEGORY_FORM_PARAM_NAME )
+      category = @ribitData.get_category_by_full_name( categoryName )
+      
+      if ( category == nil )
+        @logger.debug( "Category #{categoryName} doesn't exists => will be created" )
+        # might be short reference or totally new (several levels too)
+        # no easy way to make difference => assuming always full ref
+        #  => use of :: at the beginning for toplevel
+        
+        categoryParts = categoryName.split( '::' )
+        if ( categoryParts[0] == '' )
+          categoryParts.delete_at( 0 )
+        end
+        cat = ''
+        parentCategory = nil
+        categoryParts.each do |part|
+          cat << part
+          @logger.debug( "Checking category #{cat} existance" )
+          tmpCategory = @ribitData.get_category_by_full_name( cat )
+          if ( tmpCategory == nil )
+            @logger.debug( "Creating category #{cat}" )
+            tmpCategory = @ribitData.create_category( part, '', parentCategory )
+          end
+          cat << '::'
+          parentCategory = tmpCategory
+        end
+        
+        # now every category should have been created and 
+        # parentCategory contains the last one = the current category
+        category = parentCategory
+      end
+      
+      # create a new page
+      newPageID = category.get_next_free_page_id
+      @logger.debug( "creating a new page for ID=#{newPageID}" )
+      
+      # category should already exists in RibitData => page gets recorded
+      page = RibitData::Page.new( newPageID, name, category )
+      page.data = data
+      
+      message = get_localized( ACTION_NEW_PAGE_OK )
+      pageID = page.full_id
+      
+      # NOTE: this is a new page
+      #   => categories and all pages linking to this have changed 
+      #   => delete all pages
+
+      # TODO: later we could know where pages are referenced
+      
+      if ( @pageCache != nil )
+        @pageCache.delete_all
+      end
+      
+    # check that there exists a page
+    elsif ( @ribitData.get_page_by_id( pageID ) == nil )
+      raise RibitException, "No page for ID=#{pageID}", caller
+    else
+      @logger.debug( "saving page for ID=#{pageID}" )
+
+      page = @ribitData.get_page_by_id( pageID )
+      page.data = data
+      
+      # if name has changed then contents of categories page will change
+      if ( page.name != name and @pageCache != nil )
+        @pageCache.delete( ViewCategoriesAction::PAGE_CACHE_ID )
+      end
+      
+      page.name = name
+      
+      message = get_localized( ACTION_SAVE_OK )
+      @pageCache.delete( page.full_id ) unless @pageCache == nil
+    end
+    
+    @ribitData.save_page( page )
+    
+    # show the saved page
+    page = TextPage.new( @ribitData, page, @ribitConfig )
+    page.set_message( message )
+     
+    # set the base url for whole page (all links are relative to this)
+    add_headers( page )
+
+      # finally build the page      
+    page.output_page( pageResponse )
+    
+  end
+    
+end
+
+##
+#
+class SaveCategoryAction < WebAction
+  include Assert
+  include Localization
+  
+  #
+  def initialize( ribitData, ribitConfig, pageCache )
+    assert_not_nil( ribitData, 'RibitData is nil' )
+    
+    @id = 'form:save'
+    @ribitData = ribitData
+    @ribitConfig = ribitConfig
+    @logger = RibitLogger.new( SaveAction )
+    @pageCache = pageCache
+  end
+
+    #
+  def run( pageRequest, pageResponse )
+    super( pageRequest, pageResponse )
+    
+    catID = pageRequest.get_request_param( Constants::CATEGORY_ID_REQUEST_PARAM_NAME )
+    
+    if ( catID == nil )
+      raise RibitException, 'No category ID defined for EditCategoryAction', caller
+    end
+    
+    category = @ribitData.get_category_by_id( catID )
+    if ( category == nil )
+      raise RibitException, "No category for ID=#{catID}", caller
+    end
+    message = ''
+
+    query = pageRequest.get_query_data
+    categoryName = query[Constants::CATEGORY_NAME_FORM_PARAM_NAME]
+    mainPageID = query[Constants::CATEGORY_MAIN_PAGE_ID_FORM_PARAM_NAME]
+    parentCategoryID = query[Constants::CATEGORY_PARENT_ID_FORM_PARAM_NAME]
+    @logger.debug( "New properties for category #{category.id}: name=#{categoryName}, mainPageID=#{mainPageID}, parentCategoryID=#{parentCategoryID}" )
+    
+    categoryDataChanged = false
+    
+    if ( categoryName != category.name )
+      @logger.debug( "Changing category name from #{category.name} to #{categoryName}" )
+      category.name = categoryName
+      categoryDataChanged = true
+    end
+    @logger.debug( "Current mainPageID=#{category.get_main_page_id}" )
+    if ( mainPageID != category.get_main_page_id )
+      @logger.debug( "Changing main page id from #{category.get_main_page_id} to #{mainPageID}" )
+      category.set_main_page_id( mainPageID )
+      categoryDataChanged = true
+    end
+
+    # in form special string marked nil ie. no parent
+    parentCategoryID = nil if parentCategoryID == Constants::CATEGORY_NO_PARENT_FORM_VALUE
+    currentParentCategoryID = nil
+    currentParentCategoryID = category.get_parent_category.id unless category.toplevel_category?
+    
+    categoriesHierarchyChanged = false
+    if ( parentCategoryID != currentParentCategoryID )
+      @logger.debug( "Changing parent category id to #{parentCategoryID}" )
+      category.set_parent_category( @ribitData.get_category_by_id( parentCategoryID ) )
+      categoriesHierarchyChanged = true
+    end
+    
+    # TODO: new category feature is not yet implemented
+
+    @logger.debug( "saving category for ID=#{catID}" )
+
+    message = get_localized( ACTION_SAVE_CATEGORY_OK )
+    
+    # saving data depending on what changed
+    if ( categoryDataChanged )
+      @ribitData.save_category( category )
+      
+      # delete all child pages from cache, their content might have been changed
+      if ( @pageCache != nil )
+        category.get_pages.each do |childPage|
+          @pageCache.delete( childPage.full_id )
+        end
+        
+        @pageCache.delete( ViewCategoriesAction::PAGE_CACHE_ID )
+      end
+    end
+    
+    if ( categoriesHierarchyChanged )
+      @ribitData.save_categories_hierarchy
+      @pageCache.delete_all unless @pageCache == nil
+    end
+
+    # show the categories page
+    page = CategoriesPage.new( @ribitData, @ribitConfig )
+    page.set_message( message )
+    
+    # set the base url for whole page (all links are relative to this)
+    add_headers( page )
+      
+    page.output_page( pageResponse )
+    
+  end
+    
+end
+
+##
+#
+class ViewAction < WebAction
+  include Assert
+  
+  ID = 'view'
+  
+  def initialize( ribitData, ribitConfig, pageCache )
+    assert_not_nil( ribitData, 'RibitData is nil' )
+    assert_not_nil( ribitConfig )
+    
+    @id = ID
+    @ribitData = ribitData
+    @ribitConfig = ribitConfig
+    @pageCache = pageCache
+    @logger = RibitLogger.new( ViewAction )
+  end
+  
+  #
+  def decorate_page( page )
+    # set the base url for whole page (all links are relative to this)
+    add_headers( page )
+    return false
+  end
+  
+  #
+  def run( pageRequest, pageResponse )
+    super( pageRequest, pageResponse )
+    
+    # get page id and show the page
+    pageID = get_page_id( pageRequest )
+    
+    if ( pageID == nil )
+      raise "No page ID defined"
+    end
+    
+    page = @ribitData.get_page_by_id( pageID )
+    # check that there exists a page
+    if ( page == nil )
+      raise "No page for ID=#{pageID}"
+    end
+    
+    # check first from cache
+    cachedPage = get_cached_page( page.full_id )
+    
+    if ( cachedPage != nil )
+      @logger.debug( 'Found page from cache for pageId=' + page.full_id )
+      
+      lastModified = pageRequest.get_header_field( 'If-Modified-Since' )
+      if ( lastModified != nil )
+        @logger.debug( "Found If-Modified-Since field from HTTP headers" )
+        time = Time.httpdate( lastModified )
+        
+        # NOTE: MODIFIED time contains also fraction of seconds but httpdate
+        #       doesn't have them => we have to compare full seconds
+        if ( cachedPage.is_time_same_or_after( lastModified ) )
+          @logger.debug( "Cached page is up to date" )
+          pageResponse.status = 304
+          return
+        end
+      end
+    
+      pageResponse.set_body( cachedPage.data )
+      pageResponse.set_content_type( cachedPage.contentType )
+      
+      pageResponse.set_header_field( 'Cache-Control', 'public, must-revalidate, proxy-revalidate' )
+      pageResponse.set_header_field( 'Last-Modified', cachedPage.lastModfiedHttpdate )
+    
+    else
+      @logger.debug( "Building page for ID=#{page.full_id}" )
+      textPage = TextPage.new( @ribitData, page, @ribitConfig )
+      messagesInserted = decorate_page( textPage )
+        
+      textPage.output_page( pageResponse )
+      
+      # store page to cache if there wasn't any messages
+      if ( @pageCache != nil and not messagesInserted )
+        # we can safely insert data to cache
+        @logger.debug( "Inserting page #{page.full_id} data to cache" )
+    
+        cachedPage = CachedPage.new( pageResponse.get_body, pageResponse.get_content_type )       
+        @pageCache.add( page.full_id, cachedPage )
+        
+        pageResponse.set_header_field( 'Cache-Control', 'public, must-revalidate, proxy-revalidate' )
+        pageResponse.set_header_field( 'Last-Modified', cachedPage.lastModfiedHttpdate )
+      end
+    end
+  end
+  
+  # 
+  def get_page_id( pageRequest )
+     return pageRequest.get_requested_page_id
+  end
+  
+  #
+  def get_cached_page( pageFullId )
+    if ( @pageCache == nil )
+      return nil
+    end
+    
+    return @pageCache.get( pageFullId )
+  end
+  
+  
+end
+
+##
+#
+class CachedPage
+  attr_reader :data, :contentType
+  
+  #
+  def initialize( data, contentType )
+    @data = data
+    @contentType = contentType
+    @lastModified = Time.now
+  end
+  
+  #
+  def is_time_same_or_after( lastModifiedHttpDate )
+  
+    time = Time.httpdate( lastModifiedHttpDate )
+      
+    # NOTE: @lastModified time contains also fraction of seconds but httpdate
+    #       doesn't have them => we have to compare full seconds
+    if ( ( time.to_i <=> @lastModified.to_i ) >= 0 )
+      return true
+    end
+    
+    return false
+  end
+  
+  #
+  def lastModfiedHttpdate
+    @lastModified.httpdate
+  end
+end
+
+
+##
+# This action is the default action that is responsible for creating
+# a page when no specific action is defined by request URL. The action
+# views the main page defined in Ribit configuration file.
+class DefaultAction < ViewAction
+  include Localization
+  
+  #
+  def initialize( ribitData, ribitConfig, pageCache )
+    super( ribitData, ribitConfig, pageCache )
+    @id = 'default'
+    @logger = RibitLogger.new( DefaultAction )
+    @ribitData = ribitData  
+    @defaultPageID = nil 
+  
+  end
+  
+  #
+  def run( pageRequest, pageResponse )
+    begin
+      super( pageRequest, pageResponse )
+    rescue RibitException => exception
+      @logger.error( 'Showing default page failed' )
+      @logger.error( format_exception( exception ) )
+      
+      # probable reason was that default page was not found
+      #  => show categories page 
+      #  => if that throws error too then upper level takes care of it
+
+      # TODO: caching of this page ?? should reuse view categories action ??
+      @logger.info( 'Because default page failed showing Categories page' );
+      
+      page = CategoriesPage.new( @ribitData, @ribitConfig )
+      page.set_message( get_localized( ACTION_DEFAULT_PAGE_FAILED, { 'message' => exception.message } ) )
+      decorate_page( page )
+        
+      page.output_page( pageResponse ) 
+    end
+  end
+  
+  # 
+  def get_page_id( pageRequest )
+    if ( @defaultPageID == nil )
+      mainPageRef = @ribitConfig[RibitConfig::MAIN_PAGE]
+      
+      # first we try by name
+      page = @ribitData.get_page_by_full_name( mainPageRef )
+      
+      if ( page == nil )
+        page = @ribitData.get_page_by_id( mainPageRef )
+      end
+      
+      if ( page == nil )
+        raise RibitException, "No default page found: #{mainPageRef}", caller
+      end
+         
+      @defaultPageID = page.full_id
+      
+      @logger.debug( 
+          "The default page is: name=#{page.full_name}, pageID=#{@defaultPageID}" )  
+    end  
+    
+    return @defaultPageID
+  end
+  
+end
+
+
+#
+class EditAction < WebAction
+  include Assert
+  include Localization
+  
+  ID = 'edit'
+  
+  def initialize( ribitData, ribitConfig )
+    assert_not_nil( ribitData, 'RibitData is nil' )
+    assert_not_nil( ribitConfig, 'RibitConfig' )
+    
+    @id = ID
+    @ribitData = ribitData
+    @ribitConfig = ribitConfig
+    @logger = RibitLogger.new( EditAction )
+  end
+  
+  #
+  def run( pageRequest, pageResponse )
+    super( pageRequest, pageResponse )
+    
+    # get page id and show the edit page
+    pageID = pageRequest.get_requested_page_id
+    
+    if ( pageID == nil )
+      raise RibitException, 'No page ID defined for EditAction', caller
+    end
+    
+    if ( pageID == Constants::NEW_PAGE_ID )
+      # we don't have data in ribitData, so we need add necessary stuff form
+      # - name
+      # - category
+      @logger.debug( 'building edit page for non-existent page' )
+      
+      # build empty page
+      previousPageID = pageRequest.get_request_param( Constants::PREV_REQUEST_PARAM_NAME )
+      page = EditPage.new( @ribitData, pageID, previousPageID, @ribitConfig )
+      
+      # add name + category info
+      name = pageRequest.get_request_param( Constants::PAGE_NAME_REQUEST_PARAM_NAME )
+      if ( name == nil )
+        raise RibitException, 'No \'name\' defined in request', caller
+      end
+      
+      category = pageRequest.get_request_param( Constants::CATEGORY_REQUEST_PARAM_NAME )
+      if ( category == nil )
+        raise RibitException, 'No \'category\' defined in request', caller
+      end
+      
+      page.add_form_action_params( Constants::PAGE_NAME_REQUEST_PARAM_NAME, name  );
+      page.add_form_action_params( Constants::CATEGORY_REQUEST_PARAM_NAME, category );
+      
+      if ( @ribitData.get_category_by_full_name( category ) == nil )
+        page.set_message( get_localized( ACTION_CATEGORY_CREATION_NOTICE, {'category' => category } ) )
+      end
+    
+    elsif ( @ribitData.get_page_by_id( pageID ) == nil )
+      raise RibitException, "No page for ID=#{pageID}", caller
+    else
+      @logger.debug( "building edit page for ID=#{pageID}" )
+      page = EditPage.new( @ribitData, pageID, pageID, @ribitConfig )  
+    end
+    
+    add_headers( page )
+    page.output_page( pageResponse )
+    
+  end
+  
+end
+
+## 
+#
+class CancelAction < ViewAction
+  include Assert
+  include Localization
+  
+  def initialize( ribitData, ribitConfig )
+    # cancel contains message => can't cache the page
+    super( ribitData, ribitConfig, nil )
+      
+    @id = 'form:cancel'
+    @logger = RibitLogger.new( CancelAction )
+  end
+  
+  #
+  def decorate_page( page )
+    super( page )
+    page.set_message( get_localized( ACTION_EDIT_CANCELED ) )
+    return true
+  end
+  
+    # 
+  def get_page_id( pageRequest )
+      query = pageRequest.get_query_data
+      prevPageID = query[Constants::PREV_FORM_PARAM_NAME]
+      assert_not_nil( prevPageID, "No #{Constants::PREV_FORM_PARAM_NAME} found from form data" )
+      return prevPageID
+  end
+  
+end
+
+
+##
+#
+class StyleSheetAction < ViewAction
+  include Assert
+  # CSS is not modified (not possible currently, so last modified time is time of start up
+  MODIFIED = Time.new
+  
+  def initialize( ribitData )
+    assert_not_nil( ribitData, 'RibitData is nil' )
+    
+    @id = 'stylesheet'
+    @ribitData = ribitData
+    @logger = RibitLogger.new( StyleSheetAction )
+    cssPage = ribitData.get_page_by_full_name( "core::css" )
+    
+    if ( cssPage != nil )
+      @cssPageData = cssPage.data
+    else
+        # page not found, it is not mandatory
+      @logger.warn( 'No CSS page found by name core::css' )
+      @cssPageData = '# No CSS page found by name core::css'
+    end
+  end
+  
+  #
+  def run( pageRequest, pageResponse )
+    lastModified = pageRequest.get_header_field( 'If-Modified-Since' )
+    if ( lastModified != nil )
+      @logger.debug( "Found If-Modified-Since field from HTTP headers" )
+      time = Time.httpdate( lastModified )
+      
+      # NOTE: MODIFIED time contains also fraction of seconds but httpdate
+      #       doesn't have them => we have to compare full seconds
+      if ( ( time.to_i <=> MODIFIED.to_i ) >= 0 )
+        @logger.debug( "Cached copy is up to date" )
+        pageResponse.status = 304
+        return
+      end
+    end
+    
+    page = RawPage.new( @cssPageData, 'text/css' )
+    page.output_page( pageResponse )
+    
+    pageResponse.set_header_field( 'Cache-Control', 'public, must-revalidate, proxy-revalidate' )
+    pageResponse.set_header_field( 'Last-Modified', MODIFIED.httpdate )
+  end
+  
+end
+
+##
+#
+class ViewCategoriesAction < WebAction
+  include Assert
+  
+  ID = 'categories'
+  PAGE_CACHE_ID = 'categories'
+  
+  def initialize( ribitData, ribitConfig, pageCache )
+    assert_not_nil( ribitData, 'RibitData is nil' )
+    assert_not_nil( ribitConfig )
+    
+    @id = ID
+    @ribitData = ribitData
+    @ribitConfig = ribitConfig
+    @pageCache = pageCache
+    @logger = RibitLogger.new( ViewCategoriesAction )
+  end
+  
+  #
+  def decorate_page( page )
+    # set baseUrl etc.
+    add_headers( page )
+    return false
+  end
+  
+  #
+  def run( pageRequest, pageResponse )
+    super( pageRequest, pageResponse )
+    
+    cachedPage = get_cached_page
+    if ( cachedPage != nil )
+      @logger.debug( 'Found categories page from cache' )
+      
+      lastModified = pageRequest.get_header_field( 'If-Modified-Since' )
+      if ( lastModified != nil )
+        @logger.debug( "Found If-Modified-Since field from HTTP headers" )
+        time = Time.httpdate( lastModified )
+        
+        # NOTE: MODIFIED time contains also fraction of seconds but httpdate
+        #       doesn't have them => we have to compare full seconds
+        if ( cachedPage.is_time_same_or_after( lastModified ) )
+          @logger.debug( "Cached page is up to date" )
+          pageResponse.status = 304
+          return
+        end
+      end
+      
+      pageResponse.set_body( cachedPage.data )
+      pageResponse.set_content_type( cachedPage.contentType )
+      
+      pageResponse.set_header_field( 'Cache-Control', 'public, must-revalidate, proxy-revalidate' )
+      pageResponse.set_header_field( 'Last-Modified', cachedPage.lastModfiedHttpdate )
+    
+    else
+      page = CategoriesPage.new( @ribitData, @ribitConfig )
+      decorate_page( page )
+        
+      page.output_page( pageResponse )
+      
+      if ( @pageCache != nil  )
+        # we can safely insert data to cache
+        @logger.debug( "Inserting categories page data to cache" )
+        
+        cachedPage = CachedPage.new( pageResponse.get_body, pageResponse.get_content_type )       
+        @pageCache.add( PAGE_CACHE_ID, cachedPage )
+        
+        pageResponse.set_header_field( 'Cache-Control', 'public, must-revalidate, proxy-revalidate' )
+        pageResponse.set_header_field( 'Last-Modified', cachedPage.lastModfiedHttpdate )
+      end
+    end
+    
+  end
+  
+  #
+  def get_cached_page
+    if ( @pageCache == nil )
+      return nil
+    end
+    
+    return @pageCache.get( PAGE_CACHE_ID )
+  end
+  
+end
+
+## 
+#
+class CancelCategoryAction < ViewCategoriesAction
+  include Assert
+  include Localization
+  
+  def initialize( ribitData, ribitConfig )
+    # never use page cache because there will be a message
+    super( ribitData, ribitConfig, nil )
+      
+    @id = 'form:cancel'
+    @logger = RibitLogger.new( CancelAction )
+  end
+  
+  #
+  def decorate_page( page )
+    super( page )
+    page.set_message( get_localized( ACTION_EDIT_CANCELED ) )
+    return true
+  end
+  
+end
+
+#
+class EditCategoryAction < WebAction
+  include Assert
+  
+  ID = 'edit-category'
+  
+  def initialize( ribitData, ribitConfig )
+    assert_not_nil( ribitData, 'RibitData is nil' )
+    assert_not_nil( ribitConfig, 'RibitConfig' )
+    
+    @id = ID
+    @ribitData = ribitData
+    @ribitConfig = ribitConfig
+    @logger = RibitLogger.new( EditAction )
+  end
+  
+  #
+  def run( pageRequest, pageResponse )
+    super( pageRequest, pageResponse )
+    
+    catID = pageRequest.get_request_param( Constants::CATEGORY_ID_REQUEST_PARAM_NAME )
+    
+    if ( catID == nil )
+      raise RibitException, 'No category ID defined for EditCategoryAction', caller
+    end
+    
+    if ( catID == Constants::NEW_CATEGORY_ID )
+      # TODO: new category functionality is not yet supported
+    elsif ( @ribitData.get_category_by_id( catID ) == nil )
+      raise RibitException, "No category for ID=#{catID}", caller
+    else
+      @logger.debug( "building edit category page for ID=#{catID}" )
+      page = EditCategoryPage.new( @ribitData, catID, @ribitConfig )  
+    end
+    
+    # set the base url for whole page (all links are relative to this)
+    add_headers( page )
+      
+    page.output_page( pageResponse )
+    
+  end
+  
+end
+
+
+###########################################################################
+
+##
+#
+class ActionAdapter
+
+  #
+  def build_url( actionID, propertyList=nil, encode=true )
+    url = URL.new( nil, nil, "#{actionID}" )
+    
+    if ( propertyList != nil )
+      propertyList.keys.each do |key|
+        url.add_param( key, propertyList.get( key ) )
+      end
+    end
+    
+    return url
+  end
+    
+end
+
+
+##
+#
+class ViewActionAdapter < ActionAdapter
+  
+  #
+  def initialize( targetID, text=nil )
+      # id might be number
+    @targetID = targetID.to_s
+    @linkText = text
+  end
+  
+  #
+  def process( element )
+    # build url
+    element.attributes['href'] = get_url()
+    
+    # change link text only if specified so
+    if ( @linkText != nil )
+      element.text = @linkText
+    end
+  end
+  
+  #
+  def get_url
+      propertyList = PropertyList.new
+      propertyList.put( Constants::PAGE_ID_REQUEST_PARAM_NAME, @targetID )
+    return build_url( ViewAction::ID, propertyList )
+  end
+  
+  #
+  def to_ele
+    element = REXML::Element.new( 'a' )
+    element.attributes['href'] = get_url()
+    element.text = @linkText
+    return element
+  end
+end
+
+##
+#
+class ViewCategoriesActionAdapter < ActionAdapter
+  
+  #
+  def initialize( text=nil )
+    @linkText = text
+  end
+  
+  #
+  def process( element )
+    # build url
+    element.attributes['href'] = get_url()
+    
+    # change link text only if specified so
+    if ( @linkText != nil )
+      element.text = @linkText
+    end
+  end
+  
+  #
+  def get_url
+    return build_url( ViewCategoriesAction::ID )
+  end
+  
+end
+
+##
+#
+class EditActionAdapter < ViewActionAdapter
+
+  #
+  def get_url
+    propertyList = PropertyList.new
+    propertyList.put( Constants::PAGE_ID_REQUEST_PARAM_NAME, @targetID )
+    return build_url( EditAction::ID, propertyList )
+  end
+  
+end
+
+##
+#
+class EditNewActionAdapter < ActionAdapter
+  
+  #
+  def initialize( category, name, prevPageID )
+    @category = category
+    @name = name
+    @prevPageID = prevPageID
+  end
+  
+  #
+  def get_url
+    propertyList = PropertyList.new
+    propertyList.put( Constants::PAGE_ID_REQUEST_PARAM_NAME, Constants::NEW_PAGE_ID )
+    propertyList.put( Constants::CATEGORY_REQUEST_PARAM_NAME, @category )
+    propertyList.put( Constants::PAGE_NAME_REQUEST_PARAM_NAME, @name )
+    propertyList.put( Constants::PREV_REQUEST_PARAM_NAME, @prevPageID )
+    return build_url( EditAction::ID, propertyList )
+  end
+  
+end
+
+##
+#
+class EditCategoryActionAdapter < ViewActionAdapter
+
+  #
+  def get_url
+    propertyList = PropertyList.new
+    propertyList.put( Constants::CATEGORY_ID_REQUEST_PARAM_NAME, @targetID )
+    return build_url( EditCategoryAction::ID, propertyList )
+  end
+  
+end
+
+##
+#
+class FormActionAdapter < ActionAdapter
+  
+  #
+  def initialize( pageID )
+    @propertyList = PropertyList.new
+    @propertyList.put( Constants::PAGE_ID_REQUEST_PARAM_NAME, pageID )
+  end
+  
+  #
+  def add_param( key, value )
+    @propertyList.put( key, value )
+  end
+  
+  #
+  def get_url( encode=true )
+    return build_url( FormAction::ID, @propertyList, encode )
+  end
+  
+end
+
+##
+#
+class CategoryFormActionAdapter < ActionAdapter
+  
+  #
+  def initialize( pageID )
+    @propertyList = PropertyList.new
+    @propertyList.put( Constants::CATEGORY_ID_REQUEST_PARAM_NAME, pageID )
+  end
+  
+  #
+  def add_param( key, value )
+    @propertyList.put( key, value )
+  end
+  
+  #
+  def get_url( encode=true )
+    return build_url( CategoryFormAction::ID, @propertyList, encode )
+  end
+  
+end
+
+##
+#
+class W3CValidatorLinkActionAdapter < ActionAdapter
+  #
+  def initialize( url )
+    @url = url
+   
+    @url = URI.escape( @url )
+    
+    # replace some char that may confuse (url is value of one parameter, not many parameters)
+    @url.gsub!( /&/, '%26' )
+    @url.gsub!( /:/, '%3A' )
+    @url.gsub!( /\//, '%2F' )
+    @url.gsub!( /=/, '%3D' )
+  end
+
+  #
+  def get_url
+    return "http://validator.w3.org/check?uri=#{@url}"
+  end
+end