ribit 0.3.0

data/lib/ribit/main.rb

@@ -0,0 +1,114 @@
+#!/usr/local/bin/ruby
+
+#--
+#    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 'webrick'
+require 'ribit/ribit'
+require 'ribit/config'
+require 'ribit/contentstore'
+require 'ribit/ribitlogger'
+require 'common/pid'
+
+include WEBrick
+
+# default value for config file
+configFileName = '/opt/ribit/ribitconfig.xml'
+
+if ( ARGV[0] != nil )
+	configFileName = ARGV[0]
+end
+
+configParser = RibitConfigParser.new
+ribitConfig = configParser.parse( configFileName )
+
+# kickup HTTP server
+port = ribitConfig[RibitConfig::HTTP_PORT].to_i
+host = ribitConfig[RibitConfig::HTTP_HOST]
+mountPoint = ribitConfig[RibitConfig::MOUNT_POINT]
+
+logger = RibitLogger.new( 'main' )
+accesslog = RibitLoggerWrapper.new( logger, RibitLoggerWrapper::INFO, 'accesslog: ' )
+referer   = RibitLoggerWrapper.new( logger, RibitLoggerWrapper::INFO, 'referer: ' )
+agent     = RibitLoggerWrapper.new( logger, RibitLoggerWrapper::INFO, 'agent: '  )
+customlog = RibitLoggerWrapper.new( logger, RibitLoggerWrapper::INFO, 'customlog: ' )
+
+logger.info( "Starting Ribit servlet to #{host}:#{port}#{mountPoint}" )
+
+# :BindAddress forces to use IPv4 instead of IPv6, I think.
+# Anyway with :BindAddress Webrick doesn't output:
+#   TCPServer Error: Address family not supported by protocol - socket(2)
+server = HTTPServer.new( 
+  :Port => port, 
+  :Logger => logger, 
+  :BindAddress => "0.0.0.0",
+  :AccessLog      => [
+	  [ accesslog, WEBrick::AccessLog::COMMON_LOG_FORMAT  ],
+	  [ referer,   WEBrick::AccessLog::REFERER_LOG_FORMAT ],
+	  [ agent,     WEBrick::AccessLog::AGENT_LOG_FORMAT   ],
+	  [ customlog, "%a %U %T" ]  # peeraddr, Request-URI, process time
+    ] )
+
+# ContentStore handles filesystem
+store = Ribit::ContentStore.new( ribitConfig, Ribit::CVSRepository.new )
+
+logger.info( "Loading Ribit page data..." )
+ribitData = store.get_ribit_data
+logger.info( "Ribit page data loaded" )
+
+# RibitConfig is passed to servlet
+server.mount( mountPoint, RibitServlet, ribitConfig, store, ribitData )
+trap("INT") { server.shutdown }
+
+# write the current pid to the file if a file is defined
+pid = Pid.new
+logger.info( 'The current pid is ' + pid.to_s )
+pidFile = ribitConfig[RibitConfig::PID_FILE]
+
+if ( pidFile != nil )
+  logger.info( 'Writing the current pid to ' + pidFile )
+  pid.write_to_file( pidFile )
+end
+
+# now everything is up and running we can change the used uid and gid
+# (if needed). Works for Linux/Unix only.
+
+uid = ribitConfig[RibitConfig::USER_ID]
+gid = ribitConfig[RibitConfig::GROUP_ID]
+
+# NOTE: we have set group first because after setting uid 
+#       we lose rights to change gid
+
+if ( gid != nil )
+	Process::egid = gid.to_i
+    Process::gid = gid.to_i
+end
+
+if ( uid != nil )
+	Process::euid = uid.to_i
+ 	Process::uid = uid.to_i
+end
+
+logger.info( "Using uid=#{Process::euid.to_s}, euid=#{Process::uid.to_s}" )
+logger.info( "Using gid=#{Process::egid.to_s}, egid=#{Process::gid.to_s}" )
+
+# start() call will never return
+server.start
+
+
+

data/lib/ribit/ribit.rb

@@ -0,0 +1,319 @@
+#--
+#    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'
+require 'webrick'
+require 'ribit/ribitdata'
+require 'ribit/action'
+require 'ribit/config'
+require 'ribit/common'
+require 'ribit/constants'
+require 'common/assert'
+require 'common/datastorage'
+
+include WEBrick
+
+##
+#
+class RibitServlet < HTTPServlet::AbstractServlet
+    include Assert
+    
+  # The singleton instance of this servlet
+  @@instance = nil
+  
+  # Return the one and only instanceof RibitServlet. WEBrick calls
+  # this method every time when request is made.
+  def self.get_instance( config, *options )
+    
+    # 'config' is instance of WEBrick::HTTPServer, stored to @server
+    # config[:Logger] contains ref to WEBrick::Log, stored to @logger
+    # 'options' is Array
+    if ( @@instance == nil )
+      logger = config[:Logger]
+       logger.info( 'Creating a new servlet instance' )
+    
+      begin
+        @@instance = self.new(config, options)
+      rescue Exception => error
+        logger.fatal( "Got error during servlet creation. No Servlet created" )
+        logger.fatal( format_exception( error ) )
+
+        # throw upwards, don't know what to do
+        raise error
+      end
+    end
+    
+    return @@instance
+  end
+  
+  #  
+  def initialize( server, options )
+    super( server, options ) 
+
+    # RibitConfig and ContentStore are required, 
+    # we can't proceed if it is missing
+    
+    if ( @options[0] == nil )
+      raise RibitException, "No RibitConfig (1) found from servlet options", caller
+    end
+    @ribitConfig = options[0]
+    
+    if ( options[1] == nil )
+      raise RibitException, "No ContentStore (2) found from servlet options", caller
+    end
+    @contentStore = options[1]
+    @ribitData = options[2]
+    
+    # TODO: servlet should be changed that all actions are initialized only once => reload is not currently realible with caching
+    if ( @ribitConfig[RibitConfig::PAGE_CACHE_DIR] != nil )
+      dir = @ribitConfig[RibitConfig::PAGE_CACHE_DIR]
+      @logger.info( 'Cache path defined => page caching is enabled' )
+      
+      # make sure dir exists
+      FileUtils.mkdir( dir ) unless File.exist?( dir )
+      storageHandler = FilePersistentStorageHandler.new( dir )
+      
+      # TODO: pages in memory should be configurable
+      @pageCache = DataStorage.new( 10, -1, storageHandler )
+    else
+      # no cache path defined => no cache
+      @logger.info( 'No cache path defined => page caching is disabled' )
+      @pageCache = nil
+    end
+    
+    # create all data structures  
+    init
+    
+  end
+  
+  #
+  def do_GET(req, res)
+    
+    begin
+      @logger.debug( "Processing GET" )
+    
+      pageRequest = PageRequest.new( req )
+      pageResponse = PageResponse.new( res )
+      
+      buildPage( pageRequest, pageResponse )
+
+      # used only for debugging
+      #@logger.debug( "Page=" + res.body )      
+    rescue Exception => error
+      @logger.fatal( 'Got error during service request' )
+      @logger.fatal( format_exception( error ) )
+
+      # throw upwards, don't know what to do
+      raise error, error.message, error.backtrace
+    end
+    
+    #@logger.debug( "content type = " + res['Content-Type'] )
+    #@logger.debug( "body = " + res.body )
+
+  end
+  
+  #
+  def do_POST( req, res )
+    # forward call
+    return do_GET( req, res )
+  end
+
+private
+
+  #
+  def buildPage( pageRequest, pageResponse )    
+    @logger.debug( "Querying page by pageID #{pageRequest.get_requested_page_id}" )
+    action = @actionManager.get_action( pageRequest.get_action_id )
+    action.run( pageRequest, pageResponse )
+  end
+    
+  #
+  def init
+      assert_not_nil( @ribitConfig )
+      
+      if ( @ribitData == nil )   
+        @ribitData = @contentStore.get_ribit_data
+      end  
+      ribitData = @ribitData
+      
+      @actionManager = ActionManager.new
+      @actionManager.register_action( ViewAction.new( ribitData, @ribitConfig, @pageCache ) )
+      @actionManager.register_action( StyleSheetAction.new( ribitData ) )
+      @actionManager.register_action( EditAction.new( ribitData, @ribitConfig ) )
+      @actionManager.register_action( ViewCategoriesAction.new( ribitData, @ribitConfig, @pageCache ) )
+      @actionManager.register_action( EditCategoryAction.new( ribitData, @ribitConfig ) )
+      
+      formAction = FormAction.new( ribitData )
+
+      formAction.add_action( SaveAction.new( 
+          ribitData, 
+          @ribitConfig, 
+          @pageCache ) )
+      
+      formAction.add_action( CancelAction.new( ribitData, @ribitConfig ) )
+      @actionManager.register_action( formAction  )
+      
+      categoryFormAction = CategoryFormAction.new( ribitData )
+
+      categoryFormAction.add_action( SaveCategoryAction.new( 
+          ribitData, 
+          @ribitConfig, 
+          @pageCache ) )
+      
+      categoryFormAction.add_action( CancelCategoryAction.new( ribitData, @ribitConfig ) )
+      @actionManager.register_action( categoryFormAction  )
+      
+      default = DefaultAction.new( ribitData, @ribitConfig, @pageCache )
+      @actionManager.register_action( default )
+      @actionManager.set_default_action( default.id )
+      
+    end    
+end
+
+##
+#
+class PageRequest
+  
+  #
+  def initialize( servletRequest )
+    @servletRequest = servletRequest
+    @requestParams = parse_query_params( servletRequest.query_string)
+    @logger = RibitLogger.new( PageRequest )
+  end
+  
+  #
+  def get_requested_page_id()
+    return @requestParams[Constants::PAGE_ID_REQUEST_PARAM_NAME]
+  end
+  
+  #
+  def get_query_data
+    return @servletRequest.query
+  end
+  #
+  def get_base_path
+    return @servletRequest.script_name
+  end
+  
+  #
+  def get_request_param( name )
+  return @requestParams[name]
+    return URI.unescape( @requestParams[name] )
+  end
+  
+  #
+  def get_action_id
+    match = /^\/([^\/?]+)/.match( @servletRequest.path_info )
+    if ( match == nil )
+      return nil
+    end
+    
+    return match[1]
+  end
+  
+  #
+  def get_host
+    match = /^((http:\/\/)?[^\/:]+(:[0-9]+)?)/.match( @servletRequest.request_uri.to_s )
+    if ( match == nil )
+      return '/'
+    end
+    
+    return match[1]    
+  end
+  
+  #
+  def get_base_url
+      # last '/' is needed otherwise url doesn't work correctly
+    return get_host + get_base_path + '/'
+  end
+  
+  #
+  def get_header_field( name )
+    @servletRequest[name]
+  end
+  
+private  
+  # Parses query parameters and return map containing key-value pairs
+  def parse_query_params( queryString )
+    # if nothing to parse, return empty hash
+    if ( queryString == nil )
+      return Hash.new
+    end
+    
+    queryString = URI.unescape( queryString )
+    
+    pairs = Array.new
+    queryString.each( "&" ) {|s| pairs.push( s ) }
+      
+    map = Hash.new
+    pairs.each do |s| 
+        match = /([^=]+)=([^&]*)/.match( s )
+        key = match[1]
+        value = match[2]
+        map[key] = value
+    end
+    
+    return map
+  end
+  
+end
+
+##
+# Wrapper for response object used by Webrick
+class PageResponse
+  
+  #
+  def initialize( servletResponse )
+    @servletResponse = servletResponse
+  end
+  
+  #
+  def set_body( data )
+    @servletResponse.body = data
+  end
+  
+  #
+  def get_body
+    @servletResponse.body
+  end
+  
+  #
+  def set_content_type( type )
+    @servletResponse['Content-Type'] = type
+  end
+  
+  #
+  def get_content_type
+    @servletResponse['Content-Type']
+  end
+  
+  #
+  def get_servlet_response
+    return @servletResponse
+  end
+  
+  #
+  def set_header_field( name, value )
+    @servletResponse[name] = value
+  end
+  
+  #
+  def status=(s)
+    @servletResponse.status = s
+  end
+end

data/lib/ribit/ribitdata.rb

@@ -0,0 +1,909 @@
+#--
+#    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 'common/assert'
+require 'common/properties'
+require "rexml/document"
+
+require 'observer'
+
+#
+# Class RibitData contains
+#  * all pages
+#  * all categories
+
+#  * pages has links to parent categories
+#  * categories has links to childs and vice versa
+#
+module RibitData
+  
+  #
+  class RibitDataException < RibitException
+  end
+  
+  ##
+  # This stores categories and individual pages.
+  # Pages has unique ID inside one category.
+  class Category
+    include Observable
+    
+    attr_reader :id, :name, :longName
+    
+    #
+    def initialize( id, name, longName )
+      @id = id
+      @name = name
+      @longName = longName
+      @pages = Hash.new
+      @childCategories = Array.new
+      @nextFreePageID = 0
+      @parentCategory = nil
+      @fullName = '::' + @name
+      @properties = Hash.new
+      @mainID = nil
+    end
+    
+    #
+    def add_page( page )
+      # check for duplicates
+      @pages.values.each do |existingPage|
+        if ( page.name == existingPage.name )
+          raise RibitDataException, "Page with fullname #{page.full_name} already exists", caller
+        end
+        
+        if ( page.id == existingPage.id )
+          raise RibitDataException, "Page with ID #{page.full_id} already exists", caller
+        end
+      end
+      
+      @pages[page.id.to_s] = page
+      
+      if ( page.id.to_i >= @nextFreePageID )
+        @nextFreePageID = page.id.to_i + 1
+      end
+      
+      changed
+      notify_observers( self, 'newPage' )
+    end
+    
+    #
+    def remove_page( pageID )
+      page = @pages.delete( pageID.to_s )
+      if ( page != nil )
+        changed
+        notify_observers( self, 'deletePage', page.full_id )
+      end
+    end
+    
+    #
+    def get_next_free_page_id
+      return @nextFreePageID
+    end
+    
+    #
+    def get_page( pageID )
+      return @pages[pageID.to_s]
+    end
+    
+    #
+    def get_pages
+      return @pages.values
+    end
+    
+    #
+    def get_child_categories
+      return @childCategories
+    end
+    
+    # 
+    def toplevel_category?
+      return @parentCategory == nil
+    end
+    
+    #
+    def full_name
+      return @fullName
+    end
+    
+    #
+    def get_parent_category
+      return @parentCategory
+    end
+    
+    #
+    def visible?
+      return @properties['visibility'] != 'false'
+    end
+    
+    #
+    def set_visibility( b )
+      @properties['visibility'] = b
+    end
+    
+    #
+    def set_property( name, value )
+      @properties[name] = value
+    end
+    
+    # Note: doesn't check does page exists with a id
+    def get_main_page_id
+      @mainPageID
+    end
+    
+    #
+    def get_main_page_full_id
+    
+      if ( @mainPageID != nil )
+        # check that page exists
+        page = get_page( @mainPageID )
+        if ( page != nil )
+          return page.full_id
+        end
+      end
+      
+      # main page was not found => select one of pages
+
+      # if category has no pages we can't return one
+      if ( @pages.size == 0 )
+        return nil
+      end
+      
+      # just take one
+
+      return get_pages[0].full_id
+    end
+    
+    #
+    def set_main_page_id( newMainPageID )      
+      @mainPageID = newMainPageID
+    end
+    
+    #
+    def to_document
+      element = REXML::Element.new( 'category' )
+      
+      shortName = REXML::Element.new( 'short-name' )
+      shortName.text = @name
+      
+      longName = REXML::Element.new( 'long-name' )
+      longName.text = @longName
+      
+      element.add_element( shortName )
+      element.add_element( longName )
+      
+      if ( @mainPageID != nil )
+        idEle = REXML::Element.new( 'main-page-id' )
+        idEle.text = @mainPageID
+        element.add_element( idEle )
+      end
+      
+      propertiesEle = REXML::Element.new( 'properties' )
+      @properties.each do |key, value|
+        propEle = REXML::Element.new( 'property' )
+        propEle.attributes['name'] = key
+        propEle.attributes['value'] = value
+        propertiesEle.add_element( propEle )
+      end
+      
+      # Add 'properties' element only if there is data
+      if ( propertiesEle.size() > 0 )
+        element.add_element( propertiesEle )
+      end
+      
+      return element
+    end
+
+    # If category is changed observers are called.
+    def set_parent_category( newParentCategory )
+      if ( @parentCategory == newParentCategory )
+        return
+      end
+      
+      # newParentCategory can be nil if there will be no parent (top level category)
+
+      # check that child can't be set as parent
+      if ( newParentCategory != nil and is_descendant( newParentCategory ) )
+        raise RibitException, "The category #{newParentCategory.id} can't be parent of #{self.id} because #{newParentCategory.id} is already a child", caller
+      end
+
+      # first remove old ref
+      currentParent = self.get_parent_category
+      if ( currentParent != nil )
+        currentParent.remove_child_category( self )
+      end
+      
+      @parentCategory = newParentCategory
+      refresh_full_name
+      
+      # then set new one (can be nil)
+      if ( newParentCategory != nil )
+        newParentCategory.add_child_category( self )
+      end
+      
+      changed
+      notify_observers( self, 'parentCategory' )
+          
+    end
+    
+    #
+    def is_descendant( category )
+      @childCategories.each do |childCategory|
+        if ( childCategory.id == category.id )
+          return true
+        end
+        
+        result = childCategory.is_descendant( category )
+        if ( result )
+          return true
+        end
+      end
+      
+      # not found => no relationship
+      return false
+    end
+    
+    # If name changes then Observers are triggered.
+    def name=( newName )
+      if ( @name == newName )
+        return @name
+      end
+      
+      @name = newName
+      refresh_full_name
+      changed
+      notify_observers( self, ['name'] )
+    end
+    
+    #
+    def to_s
+      "Category [id=#{@id},name=#{name}]"
+    end
+  
+  protected
+  
+    #
+    def add_child_category( category )
+      @childCategories.push( category )
+    end
+    
+    #
+    def remove_child_category( category )
+      @childCategories.delete( category )
+    end
+
+    # Rebuilds the full_name and calls also childs to do it
+    def refresh_full_name
+      @fullName = '::' + get_parent_full_name( self )
+      
+      # child also so cache full name => they need to refresh it too
+      @childCategories.each do |category|
+        category.refresh_full_name
+      end
+    end
+    
+  private
+  
+    def get_parent_full_name( category )
+      if ( category.get_parent_category != nil )
+        return get_parent_full_name( category.get_parent_category ) + '::' + category.name
+      end
+      
+      return category.name
+    end
+    
+
+  end
+
+  ##
+  # This class models one page.
+  #
+  # NOTE:
+  #  - page id is unique only inside one category
+  #
+  class Page
+    include Assert
+    include Observable
+    
+    attr_reader :id, :name, :title, :data, :metadata, :category
+    
+    # TODO: currently title is not different from name
+    attr_writer :title
+    
+    #
+    def initialize( id, name, category)
+      assert_not_nil( id, "id was nil for a page" )
+      assert_not_nil( name, "name was nil for page #{id}" )
+      assert_not_nil( category, "category was nil for page #{id}" )
+      
+      # allow to use Fixnum (decimal number) as a ID => convert to String
+      @id = id.to_s
+      @name = name
+      @title = name
+      
+      @data = ''
+    
+      # metadata is empty by default
+      @metadata = Hash.new
+      
+      @category = category
+      @category.add_page( self )
+    end
+  
+    # special writer
+    def data=( newData )
+      if ( !@metadata['modifiable'].to_s == 'false' )
+        raise RibitException, "The page #{id} is not modifiable", caller
+      end
+    
+      @data = newData
+    end
+  
+    # Returns the fullname, category + name separated by ::
+    def full_name
+      return @category.full_name + "::" + @name
+    end
+    
+    # Returns the full id, category.id + page.id separated by ::
+    def full_id
+      return @category.id.to_s + "::" + @id.to_s
+    end
+    
+    # Adds MetaData key-value pair
+    def add_metadata( key, value )
+      @metadata[key] = value
+    end
+    
+    # Returns page data in XML format = REXML::Element
+    def to_document
+      element = REXML::Element.new( 'page' )
+      
+      # TODO: handle case where data-ref
+      name = REXML::Element.new( 'name' )
+      title = REXML::Element.new( 'title' )
+      data = REXML::Element.new( 'data' )
+
+      REXML::CData.new( @name, true, name )
+      REXML::CData.new( @title, true, title )
+      REXML::CData.new( @data, true, data ) 
+      
+      element.add_element( name )
+      element.add_element( title )
+      element.add_element( data )  
+      
+      metaDataEle = REXML::Element.new( 'metadata' )
+      @metadata.each do |key, value|
+        propEle = REXML::Element.new( 'property' )
+        propEle.attributes['name'] = key
+        propEle.attributes['value'] = value
+        metaDataEle.add_element( propEle )
+      end
+      
+      # Add metadata element only if there is data
+      if ( metaDataEle.size() > 0 )
+        element.add_element( metaDataEle )
+      end
+           
+      return element
+    end
+    
+    # This method triggers observer if name is actually different
+    def name=( newName )
+      # if name is exactly same => do not change
+      if ( @name == newName )
+        return @name
+      end
+      
+      @name = newName
+      @title = newName
+      changed
+      notify_observers( self, ['name' ,'title'] )
+    end
+    
+  end # of Page
+
+
+  ##
+  # RibitData is toplevel store of page data.
+  class RibitData
+    include Assert
+     
+    #
+    def initialize( dataStorage=nil )
+      @pages = Hash.new
+      @pagesByName = Hash.new
+      @localization = nil
+      
+      @categories = Hash.new
+      @categoriesByName = Hash.new
+      @nextFreeCategoryID = 0
+      
+      @dataStorage = dataStorage
+    end
+     
+    # Getter for page by page fullname (category::name)
+    def get_page_by_full_name( fullName )
+      # add root mark if needed
+      if ( fullName.index( '::' ) != 0 )
+        fullName = '::' + fullName
+      end
+      return @pagesByName[fullName]
+    end
+    
+    #
+    def get_page_by_id( fullID )
+      return @pages[fullID]
+    end
+    
+    #
+    def add_category( category )
+      assert_not_nil( category, 'tried to add nil category' )
+
+      @categories[category.id] = category
+      
+      if ( @categoriesByName[category.full_name] != nil )
+        raise RibitException, "Category with full_name=#{category.full_name} already exists", caller
+      end
+           
+      @categoriesByName[category.full_name] = category
+      # record pages
+      category.get_pages.each do |page|
+        add_page( page )
+      end
+      
+      if ( category.id.to_i >= @nextFreeCategoryID )
+        @nextFreeCategoryID = category.id.to_i + 1
+      end
+      
+      category.add_observer( self )
+    end
+    
+    #
+    def get_all_categories
+      @categories.values
+    end
+    
+    #
+    def get_visible_root_categories
+      rootCategories = []
+      @categories.values.each do |category|
+        if ( category.toplevel_category? and category.visible? )
+          rootCategories.push( category )
+        end
+      end
+      
+      return rootCategories
+    end
+    
+    #
+    def get_category_by_id( id )
+      return @categories[id]
+    end
+    
+    #
+    def get_category_by_full_name( name )
+      # add root mark if needed
+      if ( name.index( '::' ) != 0 )
+        name = '::' + name
+      end 
+      return @categoriesByName[name]
+    end
+    
+    #
+    def get_next_free_category_id
+      return @nextFreeCategoryID
+    end
+    
+    # Returns the Properties object that contain localization key-value pairs.
+    def get_localization
+      if ( @localization == nil )
+        page = get_page_by_full_name( '::core::localizationdata' )
+        if ( page == nil )
+          raise RibitDataException, 'No localization data found', caller
+        end
+      
+        prop = Properties.new
+        prop.load( page.data )
+      
+        @localization = prop
+      end
+    
+      return @localization
+    end
+    
+    # Returns true if 'data' is fullName of a page. If 'data' 
+    # contains string '::' then it is considered to be full name.
+    def RibitData.fullname?( data )
+      return data.to_s.index( '::' ) != nil
+    end
+    
+    #
+    def update( obj, namesOfChangedProperties, id=nil )
+      if ( obj.kind_of?( Page ) )
+        # what have changed, for pages we are interested: name
+        
+        if ( namesOfChangedProperties.include?( 'name' ) )
+          refresh_maps_by_name
+        end
+      
+      elsif ( obj.kind_of?( Category ) )
+        
+        if ( namesOfChangedProperties.include?( 'name' ) )
+          refresh_maps_by_name
+        
+        elsif ( namesOfChangedProperties.include?( 'parentCategory' ) )
+          refresh_maps_by_name
+          
+        elsif ( namesOfChangedProperties.include?( 'newPage' ) )
+          
+          obj.get_pages.each do |page|
+            if ( get_page_by_id( page.full_id ) == nil )
+              # this page has not been recorded before => record it
+              add_page( page )
+            end
+          end
+        elsif ( namesOfChangedProperties.include?( 'deletePage' ) )
+          assert_not_nil( id )
+          page = @pages[id]
+          @pagesByName.delete( page.full_name )
+          @pages.delete( page.full_id )
+        end
+      end
+    
+    end
+    
+    #
+    def create_category( name, longName, parentCategory )
+      catID = get_next_free_category_id()
+      category = Category.new( catID, name, longName )
+      category.set_parent_category( parentCategory ) unless parentCategory == nil
+      
+      # ribitData throws exception if we try to add duplicates
+      add_category( category )
+      
+      # next create category specific files
+      @dataStorage.save_category( category )
+      
+      @dataStorage.save_categories_hierarchy( self )
+      
+      return category
+    end
+    
+    #
+    def save_page( page )
+      if ( @dataStorage == nil )
+        raise RibitException, 'dataStorage has not been defined', caller
+      end
+      
+      @dataStorage.save_page( page )
+    end
+    
+    #
+    def save_category( category )
+      if ( @dataStorage == nil )
+        raise RibitException, 'dataStorage has not been defined', caller
+      end
+      
+      @dataStorage.save_category( category )
+    end
+    
+    #
+    def save_categories_hierarchy
+       if ( @dataStorage == nil )
+        raise RibitException, 'dataStorage has not been defined', caller
+      end
+      
+      @dataStorage.save_categories_hierarchy( self )
+    end
+    
+protected
+    
+    #
+    def refresh_maps_by_name
+      @pagesByName.clear
+      @categoriesByName.clear
+      
+      @categories.values.each do |category| 
+        @categoriesByName[category.full_name] = category
+      end
+      #print( "\nall cats by name: " + @categoriesByName.to_s )
+      @pages.values.each do |page|
+        @pagesByName[page.full_name] = page
+      end
+      
+    end
+    
+    # Adds a new page, raises if ID or fullname is already used
+    def add_page( page )
+      fullName = page.full_name
+      if ( @pagesByName[fullName] != nil )
+        raise RibitDataException, "Page with fullname #{fullName} already exists", caller
+      end    
+      @pagesByName[fullName] = page
+        
+      fullID = page.full_id
+      if ( @pages[fullID] != nil )
+        raise RibitDataException, "Page with ID #{fullID} already exists", caller
+      end
+      @pages[fullID] = page
+      
+      # we like to know from changes (name is used in maps)
+      page.add_observer( self )
+    end
+    
+  end
+
+  
+  ##
+  #
+  class CategoryParser
+    CATEGORIES_XML_FILE = 'categories.xml'
+    CATEGORY_XML_FILE = 'category.xml'
+    
+    #
+    def initialize( contentDirectory )
+      @contentDir = contentDirectory
+    end
+    
+    #
+    def parse_categories
+      categoriesXML = File.new( File.join( @contentDir, CATEGORIES_XML_FILE ) )
+      categories = Array.new
+      begin
+        doc = REXML::Document.new( categoriesXML )
+        doc.elements.each( 'categories/category' ) do |topLevelCategory|
+          categories.push( process_category_ele( topLevelCategory ) )
+        end
+        
+        return categories
+      ensure
+        categoriesXML.close
+      end
+    end
+    
+    #
+    def process_category_ele( categoryElement )
+      #puts '########## ' + categoryElement.to_s
+      catID = categoryElement.attributes['id']
+      #puts '########## ID = ' + catID
+      category = parse_category( catID )
+      
+      # is there subcategories ?
+      if ( categoryElement.elements['category'] != nil )
+        categoryElement.get_elements( 'category' ).each do |subCategoryEle|
+          subCategory = process_category_ele( subCategoryEle )
+          subCategory.set_parent_category( category )
+        end
+      end
+      
+      return category
+    end
+    
+    # 
+    def parse_category( categoryID )
+      categoryDir = File.join( @contentDir, categoryID )
+      
+      # first read category.xml
+      categoryXML = File.new( File.join( categoryDir, CATEGORY_XML_FILE ) )
+      
+      begin    
+        return parse_category_doc( categoryID, categoryXML )
+      ensure
+        categoryXML.close
+      end
+    end
+    
+    #
+    def parse_category_doc( categoryID, categoryXML )
+    doc = REXML::Document.new( categoryXML )
+        shortName = categoryID
+        longName = categoryID
+        
+        doc.elements.each( 'category/short-name' ) do |ele|
+          shortName = ele.text  
+        end
+        
+        doc.elements.each( 'category/long-name' ) do |ele|
+          longName = ele.text
+        end
+        
+        mainPageID = nil
+        doc.elements.each( 'category/main-page-id' ) do |ele|
+          mainPageID = ele.text
+        end
+        
+        category = Category.new( categoryID, shortName, longName )
+        category.set_main_page_id( mainPageID )
+        
+        properties = Hash.new
+        doc.elements.each("category/properties/property" ) do |property|
+            name = property.attributes["name"]
+            value = property.attributes["value"]
+            category.set_property( name, value )
+        end
+          
+        return category 
+      end
+  end
+  
+  #
+  class CategoriesWriter
+  
+    #
+    def initialize( ribitData )
+      @ribitData = ribitData
+    end
+    
+    #
+    def to_document
+      element = REXML::Element.new( 'categories' )
+      
+      @ribitData.get_all_categories.each do |category|
+        # we build hierarchial structure but ribitData contains all categories
+        if ( category.toplevel_category? )
+          element.add_element( get_category_element( category ) )
+        end
+      end
+         
+      return element
+    end
+    
+    #
+    def get_category_element( category )
+      element = REXML::Element.new( 'category' )
+      element.attributes['id'] = category.id
+      
+      category.get_child_categories.each do |child|
+        element.add_element( get_category_element( child ) )
+      end
+      return element
+    end
+  
+  end
+  
+  ##
+  #
+  class PageParser
+    
+    #
+    def initialize( contentDirectory )
+      @contentDir = contentDirectory
+      @logger = RibitLogger.new( PageParser )
+    end
+  
+    #
+    def parse_pages( category )
+      @logger.debug( "Parsing pages for category #{category.name}" )
+      categoryDir = File.join( @contentDir, category.id )
+      @logger.debug( "Looking *.xml files from #{categoryDir}" )
+      pages = Array.new
+      # under category dir all those files with <number>.xml are page files
+      Dir[File.join( categoryDir, '*.xml')].each do |fileName|
+        @logger.debug( "Found #{fileName}" )
+        if ( /^[0-9]+\.xml$/.match( File.basename( fileName ) ) )
+          # yes, the name matches
+          pages.push( parse_page( category, fileName ) )
+        end
+      
+      end
+      
+      return pages
+    end
+    
+    # Parses an XML file and returns instance of Page
+    def parse_page( category, fileName )
+      @logger.debug( "Parsing page data from file #{fileName}" )
+      @file = File.new( fileName )
+      begin    
+        doc = REXML::Document.new( @file )
+        id = File.basename( fileName, ".xml")
+        #  looped only once
+        doc.elements.each do |pageEle|
+          name = getText( pageEle.elements['name'] )
+          page = Page.new( id, name, category )
+          page.title = getText( pageEle.elements['title'] )
+          page.data = getText( pageEle.elements['data'] )
+          
+          pageEle.elements.each("meta/property" ) do |properties|
+            name = properties.attributes["name"]
+            value = properties.attributes["value"]
+            page.add_metadata( name, value )
+          end
+      
+          @logger.debug( "Read the page ID=#{page.full_id}, name=#{page.full_name}" )
+          return page
+        end
+      ensure
+        @file.close
+      end
+    
+    end
+
+    # Returns true if page can be modified
+    def page_modifiable?( element )
+      dataEle = element.elements['data']
+    
+      # page can't be modified if it refers to a file
+      return dataEle.attributes['file-ref'] == nil
+    end
+  
+    # Returns text data from the provided XML element.
+  private
+    def getText( element )
+      if ( element != nil )
+        if ( element.attributes['file-ref'] != nil )
+          # we have reference to a file
+          fileName = element.attributes['file-ref']
+          
+          # first try if the path is absolute
+          if ( !File.exist?( fileName ) )
+            # wasn't absolute => try relative path
+            relativePath = File.join( File.dirname( @file.path ), fileName )
+            if ( !File.exist?( relativePath ) )
+              errorText = "Error: File not found. Tried #{fileName} and #{relativePath}"
+              raise RibitException, errorText, caller
+            end
+            
+            fileName = relativePath
+          end
+          
+          # -- now we know file exists
+          
+          # read the whole file
+          data = ""
+          File.open( fileName, 'r' ) do |f|
+            data << f.read
+          end
+          
+          if ( data.size == 0 )
+            # this case is legal but still could to log
+            @logger.warn( "No data in file #{fileName}" )
+          end
+          
+          return data
+        else
+          return element.text
+         end
+      end
+      # return nil if there is no data to return
+      return nil
+    end
+    
+  end # of PageParser
+  
+end # end of RibitData module
+
+
+# TODO: better name confuses to datastorage
+module IDataStorage
+  
+  # This method saves the page and does reloading if needed
+  def save_page( page )
+    raise RuntimeError, 'load_page() not implemented', caller
+  end
+  
+  # 
+  def save_category( category )
+    raise RuntimeError, 'load_category() not implemented', caller
+  end
+  
+  #
+  def save_categories_hierarchy( ribitData )
+    raise RuntimeError, 'save_categories_hierarchy() not implemented', caller
+  end
+end