ribit 0.3.0

data/lib/ribit/actionelement.rb

@@ -0,0 +1,152 @@
+#--
+#    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 'rexml/document'
+
+# Models actions in xhtml document
+class ActionElement
+	attr_reader :id
+	# def url
+	# def data
+	
+	# Constructor taking action ID and element
+	def initialize( id, element )
+		@id = id
+		@element = element
+	end
+	
+	# Removes the element from the document
+	def remove
+		@element.remove
+	end 
+end
+
+#
+class LinkActionElement < ActionElement
+	
+	#
+	def url=( newUrl )
+		@element.attributes['href'] = newUrl.to_s
+	end
+	
+	#
+	def url
+	  return @element.attributes['href']
+	end
+	
+	#
+	def data=( newData )
+		@element.text = newData
+    end
+    
+    #
+    def data
+      return @element.text
+    end
+	
+end
+
+##
+#
+class FormActionElement < ActionElement
+
+	#
+	def url=( newUrl )
+		@element.attributes['action'] = newUrl.to_s
+	end
+
+	#
+	def data=( newData )
+		# do nothing
+    end
+    
+    #
+    def insert_to_top( element )
+    	firstElement = @element[0]
+		if ( firstElement == nil )
+			@element.add_element( element )
+		else
+			@element.insert_before( firstElement, element )
+		end
+    end
+    	
+end
+
+##
+#
+class CompositeLinkActionElement < ActionElement
+    
+    #
+    def initialize( id, element, delimiter, appendDelimiterAlsoToEnd )
+      super( id, element )
+      @delimiter = delimiter
+      @appendDelimiterAlsoToEnd = appendDelimiterAlsoToEnd
+	end
+	
+    #
+    def replace_link_elements( linkAdapters )
+        # just remove this link if no adapters
+        if ( linkAdapters.size == 0 )
+          @element.remove
+          return
+        end
+        
+        # there has to be at least one adapter => replace the original element with that
+        parent = @element.parent
+        parent.replace_child( @element, linkAdapters[0].to_ele )
+        @element = linkAdapters[0].to_ele
+        
+        if ( linkAdapters.size() > 1 or @appendDelimiterAlsoToEnd )
+          parent.insert_after( @element, REXML::Text.new( @delimiter ) )
+        end
+        
+        index = 1;
+        linkAdapters[1..linkAdapters.size].each do |adapter|
+          parent.insert_after( @element, adapter.to_ele )
+          index = index + 1
+          if ( @appendDelimiterAlsoToEnd or index <= linkAdapters.size - 1 )
+            parent.insert_after( @element, REXML::Text.new( @delimiter ) )
+          end
+        end
+
+    end
+    	
+end
+
+##
+#
+class CategoryBarActionElement < CompositeLinkActionElement
+
+    #
+    def initialize( id, element )
+      super( id, element, ' / ', true )
+	end
+    	
+end
+
+
+##
+#
+class CategoryBarNextLevelActionElement < CompositeLinkActionElement
+
+    #
+    def initialize( id, element )
+      super( id, element, ' - ', false )
+	end
+    	
+end

data/lib/ribit/common.rb

@@ -0,0 +1,34 @@
+#--
+#    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.
+#++
+
+##
+# Thrown if an error occurs
+class RibitException < RuntimeError
+end
+
+# Format the exception msg (includes the backtrace)
+def format_exception( exp )
+    # 8 spaces
+    spaces = "        "
+    
+	msg = "Exception: #{exp.class.to_s} => #{exp.to_s}\n"
+	msg << spaces
+	msg << exp.backtrace.join( "\n#{spaces}" )
+	
+	return msg
+end

data/lib/ribit/config.rb

@@ -0,0 +1,123 @@
+#--
+#    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 'rexml/document'
+require 'ribit/ribitlogger'
+
+include Ribit
+
+##
+#
+class RibitConfig
+  HTTP_PORT = 'http-port'
+  HTTP_HOST = 'http-host'
+  
+  MOUNT_POINT = 'ribit-mount-point'
+  DATA_PATH = 'ribit-data-path'
+  DATA_RELOAD = 'ribit-data-reload'
+  USER_ID = 'uid'
+  GROUP_ID = 'gid'
+  PID_FILE = 'pid-file'
+  MAIN_PAGE = 'ribit-main-page'
+  CVSROOT = 'ribit-cvsroot'
+  PAGE_CACHE_DIR = 'ribit-page-cache-path'
+  
+  #
+  def initialize
+    @props = Hash.new
+    @props[HTTP_PORT] = '8080'
+    @props[HTTP_HOST] = 'localhost'
+    @props[MOUNT_POINT] = '/ribit'
+    @props[DATA_PATH] = './data'
+    @props[DATA_RELOAD] = 'false'
+    @props[CVSROOT] = nil
+    
+    @props[USER_ID] = nil
+    @props[GROUP_ID] = nil
+    @props[PID_FILE] = nil
+    
+    @props[MAIN_PAGE] = 'main::main'
+    
+    @props[PAGE_CACHE_DIR] = nil
+  end
+  
+  #
+  def []( key )
+    return @props[key]
+  end
+
+  #
+  def []=( key, value )
+    @props[key] = value
+  end
+  
+  #
+  def get_base_url
+    return 'http://' + @props[HTTP_HOST] + ':' + @props[HTTP_PORT] + @props[MOUNT_POINT]
+  end
+end
+
+##
+#
+class RibitConfigParser
+
+  # Parses an XML file and returns instance of RibitPage
+  def parse( fileName )
+    file = File.new( fileName )
+    begin    
+       doc = REXML::Document.new file
+      @ribitConfig = RibitConfig.new
+      
+      config = doc.elements['ribitconfig']
+      if ( config != nil )
+        read_prop( config, RibitConfig::HTTP_PORT )
+        read_prop( config, RibitConfig::HTTP_HOST )
+        read_prop( config, RibitConfig::MOUNT_POINT )
+        read_prop( config, RibitConfig::DATA_PATH )
+        read_prop( config, RibitConfig::DATA_RELOAD )
+        read_prop( config, RibitConfig::USER_ID )
+        read_prop( config, RibitConfig::GROUP_ID )
+        read_prop( config, RibitConfig::PID_FILE )
+        read_prop( config, RibitConfig::MAIN_PAGE )
+        read_prop( config, RibitConfig::CVSROOT )
+        read_prop( config, RibitConfig::PAGE_CACHE_DIR )
+      end
+      
+    ensure
+      file.close
+    end
+    
+    # read logging properties
+    RibitLoggerConfig.init_from_file( fileName )
+      
+    return @ribitConfig
+  end
+
+private
+  #
+  def read_prop( configEle, propName )
+    ele = configEle.elements[propName]
+    if ( ele != nil )
+      value = ele.text
+      if ( value != nil )
+        @ribitConfig[propName] = value
+      end
+    end
+  end
+  
+end

data/lib/ribit/constants.rb

@@ -0,0 +1,50 @@
+#--
+#    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.
+#++
+
+##
+# 
+module Constants
+
+  PREV_REQUEST_PARAM_NAME = 'prev'
+  PREV_FORM_PARAM_NAME = 'previous-page-id'
+  
+  PAGE_NAME_REQUEST_PARAM_NAME = 'name'
+  PAGE_NAME_FORM_PARAM_NAME = 'page-name'
+  
+  PAGE_ID_REQUEST_PARAM_NAME = 'pageid'
+  
+  PAGE_DATA_FORM_PARAM_NAME = 'data'
+  
+  CATEGORY_REQUEST_PARAM_NAME = 'category'
+  CATEGORY_FORM_PARAM_NAME = 'category'
+  
+  CATEGORY_NAME_FORM_PARAM_NAME = 'category-name'
+  CATEGORY_MAIN_PAGE_ID_FORM_PARAM_NAME = 'category-main-page'
+  CATEGORY_PARENT_ID_FORM_PARAM_NAME = 'category-parent'
+  
+  CATEGORY_ID_REQUEST_PARAM_NAME = 'catid'
+  
+  CATEGORY_NO_PARENT_FORM_VALUE = '-1'
+  
+  
+  # TODO: make platform independent!
+  PATH_SEPARATOR = '/'
+  
+  NEW_PAGE_ID = 'new'
+  NEW_CATEGORY_ID = 'new'
+end

data/lib/ribit/contentparser.rb

@@ -0,0 +1,1111 @@
+#--
+#    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.
+#++
+
+=begin
+Ribit module contains logic to parse text data from Ribit format (tags)
+and generate basic xhtml.
+
+A challenge is that Ribit format is not so unambigious as XML is. The basic
+idea is to start building so called container tree piece by piece. A container
+models one XHTML element and its contents. When the original data is parsed
+tree nodes are processed recursively. Every node results to XHTML element.
+In a container tree childs of a node (container) are XHTML elements inside 
+other (parent) XHTML elements.
+
+The logic of parsing is divided to several parser that each is responsible for
+certain type of XHTML element. The original document is parsed by every parser
+in turn. The order of parsers is important because format rules aren't very
+ambigious. Every parser gets the tree and every node containg plain text is 
+processed. This plain text is then replaced by containers.
+
+An example:
+
+Our test document contains following line:
+this ''is'' a '''test''', ok ?
+
+First tree is format (data is represented inside parenthesis)
+ Root
+   | 
+  text
+  (this ''is'' a '''test''', ok ?)
+Then BoldParser is applied and it parses text and generates following tree:
+ Root
+   |               \                   \
+ text              BoldContainer      text
+ (this ''is'' a )  (test)             ( ?)
+ 
+Next ItalicParser is applied:
+ Root
+   |               \                   \                   \
+ text      ItalicContainer   text      BoldContainer      text
+ (this )   (is)              (a )      (test)             ( ?)
+ 
+The text data under ItalicContainer and BoldContainer might still contain
+some other formatting and then those nodes would get child container handling
+that formatting.
+
+=end
+
+require 'ribit/action'
+require 'ribit/constants'
+require 'ribit/xhtmltag'
+require 'ribit/ribitlogger'
+require 'common/assert'
+
+##
+#
+class ContentParser
+  include Assert
+  
+  #
+  def initialize( ribitData )
+    @parsers = [
+    SectionParser.new,   
+    ListParser.new,
+    UnformattedContentParser.new,
+    ParagraphParser.new,
+    BoldParser.new,
+    ItalicParser.new,
+    RibitLinkParser.new,
+    DirectLinkParser.new,
+    EscapeParser.new ]
+    
+    @ribitData = ribitData
+    @doc = nil
+  end
+  
+  #
+  def parse( page )
+    assert_not_nil( page, 'The provided page is nil' )
+    @doc = ContentDoc.new( @ribitData, page )
+    
+    @parsers.each do |parser|
+      #puts "activating parser: " + parser.class.name
+      handle_container( @doc.get_root, parser )
+      
+      #puts "current doc = " + @doc.to_s
+    end
+    
+    return @doc.to_s     
+  end
+  
+  #
+  def handle_container( container, parser )
+    # keeps record the index of currently handled childContainer
+    newChilds = Array.new
+    
+    container.get_childs().each do |childContainer|
+      
+      if ( childContainer.text? )
+        
+        text = childContainer.get_text
+        #puts "handling text element = " + text
+        newContainers = parser.parse( text, @doc )
+        #puts "size of newContainers = " + newContainers.size().to_s
+        
+        if ( newContainers != nil and newContainers.size() > 0 )
+          newChilds.concat( newContainers )
+        else
+          newChilds.push( childContainer )
+        end
+        
+      elsif ( childContainer.childs? )
+        #puts "handling childContainer recursively"
+        # other than text element and it has childs
+        #  => recursive parsing
+
+        # special case (hack!), there are not paragraphs inside List although
+        # format may match. For same reason lists are parsed before paragraphs
+        if ( parser.instance_of?( ParagraphParser ) and childContainer.instance_of?( ListContainer )  )
+          # do not go deeper
+        else
+          handle_container( childContainer, parser )
+        end
+        newChilds.push( childContainer )
+      else
+        newChilds.push( childContainer )
+      end
+      
+    end
+    
+    container.set_childs( newChilds )
+  end
+  
+end
+
+##
+#
+class ParagraphParser
+  
+  #
+  def parse( text, contentDoc )
+    newContainers = Array.new    
+    currentContainer = nil
+    
+    text.each_line do |line|
+      emptyLine = /^[ \r\t]*$/.match( line ) != nil
+      
+      if ( emptyLine == true and currentContainer != nil )
+        # yes, this is empty line => close current paragraph
+        currentContainer = nil
+        
+      elsif ( emptyLine == false and  currentContainer == nil )
+        # start new paragraph
+        currentContainer = ParagraphContainer.new
+        newContainers.push( currentContainer )
+        
+        currentContainer << line
+      elsif ( emptyLine == false and currentContainer != nil )
+        # record line
+        currentContainer << line
+      else
+        # empty line => they are not recorded   
+      end
+    end
+    
+    return newContainers
+  end
+  
+end
+
+##
+#
+class EmphasisParser
+  include Assert
+  #
+  def initialize( tag )
+    assert_not_nil( tag )
+    @tag = tag
+  end
+  
+  #
+  def create_emphasis_container()
+    raise 'implement this'
+  end
+  
+  #
+  def parse( text, contentDoc )
+    #puts "em parser handling text = " + text
+    newContainers = Array.new
+    # @tag starts and ends
+    subStrs = text.split( @tag )
+    
+    emOpen = false
+    
+    subStrs.each do |sub|
+      
+      if ( !emOpen )
+        newContainers.push( TextContainer.new( sub ) ) unless sub.size() == 0
+        emOpen = true
+      else
+        # element is open
+        emContainer = create_emphasis_container()
+        emContainer << sub
+        newContainers.push( emContainer  )
+        emOpen = false
+      end
+    end
+    
+    str = ''
+    newContainers.each do |n|
+      str << n.to_s
+    end
+    #puts "newContainer contains = " + str
+    
+    return newContainers
+  end
+  
+end
+
+##
+#
+class BoldParser < EmphasisParser
+  
+  #
+  def initialize
+    super( "'''" )
+  end
+  
+  #
+  def create_emphasis_container()
+    return BoldContainer.new
+  end
+  
+end
+
+##
+#
+class ItalicParser < EmphasisParser
+  
+  #
+  def initialize
+    super( "''" )
+  end
+  
+  #
+  def create_emphasis_container()
+    return ItalicContainer.new
+  end
+  
+end
+
+##
+#
+class EscapeParser
+  
+  #
+  def parse( text, contentDoc )
+    
+    # we need to escape all <,>,',",& 
+    text.gsub!( /&/, '&amp;' )
+    text.gsub!( /</, '&lt;' )
+    text.gsub!( />/, '&gt;' )
+    text.gsub!( /\"/, '&quot;' )
+    text.gsub!( /\'/, '&apos;' )
+    
+    return [ TextContainer.new( text ) ]
+  end
+  
+end
+
+##
+#
+class UnformattedContentParser
+  
+  #
+  def parse( text, contentDoc )
+    preStarted = false
+    newContainers = Array.new
+    
+    currentContainer = TextContainer.new
+    newContainers.push( currentContainer )
+    
+    # NOTE: that lines contain line feeds
+    text.each_line do |line|
+      preLine = /^ /.match( line ) != nil
+      
+      if ( preLine == true and preStarted == false )
+        currentContainer  = UnformattedContentContainer.new
+        newContainers.push( currentContainer )
+        preStarted = true
+        
+      elsif ( preLine == false and  preStarted == true )
+        currentContainer = TextContainer.new
+        newContainers.push( currentContainer )        
+        preStarted = false
+        
+      end
+      
+      if ( preStarted )
+        # drop first character that is space
+        currentContainer << line[1, line.size()]
+      else
+        currentContainer << line
+      end
+      
+    end
+    
+    return newContainers
+  end
+  
+end
+
+##
+#
+class DirectLinkParser
+  
+  #
+  def parse( text, contentDoc )
+    newContainers = Array.new
+    urls = text.scan( /http:\/\/[^ \n]+/ )
+    str = text
+    urls.each do |url|
+      firstIndex = str.index( url )
+      newContainers.push( TextContainer.new( text[0, firstIndex] ) )
+      newContainers.push( DirectLinkContainer.new( url ) )
+      
+      # take the rest of the string
+      str = str[ firstIndex + url.size, str.size]
+    end
+    
+    # take tail
+    if ( str != nil and str.size() > 0 )
+      newContainers.push( TextContainer.new( str ) )
+    end
+    
+    if ( newContainers.size == 0 )
+      return [TextContainer.new( text )]
+    end
+    
+    return newContainers
+  end
+end
+
+##
+#
+class RibitLinkParser
+  
+  #
+  def parse( text, contentDoc )
+    newContainers = Array.new
+    urls = text.scan(  /\[[^\]]+\]/ )
+    str = text
+    urls.each do |url|
+      #puts "*** str = " + str
+      firstIndex = str.index( url )
+      newContainers.push( TextContainer.new( str[0, firstIndex] ) )
+      
+      pageName = url.delete( '[]' )
+      
+      # if reference link like [1]
+      if ( /^http:\/\/.+$/.match( pageName ) != nil )
+        newContainers.push( ReferenceLinkContainer.new( pageName, contentDoc ) )
+      else
+        newContainers.push( RibitLinkContainer.new( pageName, contentDoc ) )
+      end
+      
+      # take the rest of the string
+      str = str[ firstIndex + url.size, str.size]
+    end
+    
+    # take tail
+    if ( str != nil and str.size() > 0 )
+      #puts "*** adding the tail : " + str
+      newContainers.push( TextContainer.new( str ) )
+    end
+    
+    if ( newContainers.size == 0 )
+      #puts "*** adding empty container" 
+      return [TextContainer.new( text )]
+    end
+
+    return newContainers
+  end
+  
+end
+
+##
+# This module contains utility methods shared between several classes.
+module ListParserUtils
+  
+  # Builds regex for matching list item start depending from 
+  # the level of the list. 1 is level for toplevel list.
+  def build_regex( level )
+    regex = '^'
+    level = level * 2 + 1
+    level.times { regex << ' ' }
+    regex << '\* '
+    
+    return regex
+  end
+end
+
+##
+#
+class ListParser
+  include ListParserUtils
+  
+  #
+  def parse( text, contentDoc )
+    @newContainers = Array.new
+    
+    # this is stack of currently active lists (list hierarchy)
+    @activeLists = Array.new
+    @buffer = ''
+    @endConditionFound = false
+    @currentContainer = nil
+    # regex changes depending of a level of the list    
+    @currentListRegex = build_regex( 1 )
+    
+    # NOTE: that lines contain line feeds
+    text.each_line do |line|
+      isListLine = Regexp.new( @currentListRegex ).match( line ) != nil
+      isEmptyLine = ( line.strip.size() == 0 )
+      
+      listStarted = @activeLists.size() > 0
+      isSiblingListLine = (listStarted and Regexp.new( @activeLists.last.get_sibling_regex() ).match( line ) != nil)
+      
+      #      puts "line = '#{line}'"
+      #      puts "siblingregex=" + @activeLists.last.get_sibling_regex() if isSiblingListLine
+      #      puts "empty=" + isEmptyLine.to_s \
+      #        + ",listline=" + isListLine.to_s \
+      #        + ",end=" + @endConditionFound.to_s \
+      #        + ",listStart=" + listStarted.to_s \
+      #        + ",sibling=" + isSiblingListLine.to_s
+      
+      # case: no active list but list item found => create a list 
+      if ( isListLine == true and listStarted == false )
+        create_list_container( 1 )       
+        start_new_item()
+        
+        # case: new item found to the current list  
+      elsif ( isListLine == true and listStarted == true )
+        # new item found => save old data
+        create_list_item( @buffer )
+        start_new_item()
+        
+        # case: sibling line found
+      elsif( isSiblingListLine == true and listStarted == true )
+        # first store previous item 
+        lastItem = create_list_item( @buffer )
+        start_new_item()
+        
+        # then create new list container
+        create_list_container( @activeLists.last.level + 1 )
+        # ... that is child of last list item (inside <li></li>)
+        lastItem.add_child( @currentContainer )     
+        
+        # case: previous line was empty => now empty or text line terminates the current list          
+      elsif ( @endConditionFound == true and isListLine == false and listStarted == true )
+        # first store last item
+        create_list_item( @buffer )
+        start_new_item()
+        
+        # remove the current list from the stack
+        @activeLists.pop
+        
+        # end condition is common for all
+        # => drop first last
+        list = find_matching_parent_list( line )
+        
+        if ( list != nil )
+          @currentContainer = list.container
+          @currentListRegex = list.get_regex
+          # hack!
+          isListLine = true  
+        else      
+          # did we found any list container, if not then create new text
+          @currentContainer = TextContainer.new
+          @newContainers.push( @currentContainer )         
+          @currentListRegex = build_regex( 1 )
+        end
+        
+      elsif ( listStarted == true and isEmptyLine == true )
+        @endConditionFound = true
+        
+      elsif ( listStarted == true )
+        # just go forward adding data to current item
+        @endConditionFound = false
+        
+        # check is data line upper level list item
+        if ( @activeLists.size() > 1 )
+          # yes, there are upper level items
+          
+          # go through all upper level lists
+          endIndex = @activeLists.size() - 2
+          for index in (0..endIndex)
+            list = @activeLists[index]
+            if ( Regexp.new( list.get_regex ).match( line ) != nil )
+              # yes, the current line matches to the upper level item
+              #  => lower level list ends
+              create_list_item( @buffer )
+              start_new_item()
+              
+              # drop all lists that are closed now
+              @activeLists = @activeLists[0,index + 1]
+              @currentContainer = list.container
+              @currentListRegex = list.get_regex
+              
+              # hack! => to handle list item properly
+              isListLine = true
+              
+              break
+            end
+          end # end of for loop
+        end  
+        
+      end
+      
+      # situation might been changed  
+      listStarted = @activeLists.size() > 0
+      
+      if ( listStarted and (isListLine or isSiblingListLine ) )
+        add_list_start_line_to_buffer( line )
+        
+      elsif ( listStarted )
+        add_normal_line_to_buffer( line )
+        
+      else
+        if ( @currentContainer == nil )
+          @currentContainer = TextContainer.new
+          @newContainers.push( @currentContainer )
+        end 
+        add_to_text_container( line )
+      end
+      
+    end
+    
+    # if list line was last item
+    if ( @buffer.size() > 0 )
+      create_list_item( @buffer )
+    end
+    
+    return @newContainers
+  end
+  
+  private
+  
+  #
+  def add_list_start_line_to_buffer( line )
+    # drop leading characters, like '   * '
+    index = @activeLists.last.get_number_of_leading_chars   
+    @buffer << line[index, line.size()]
+  end
+  
+  #
+  def add_normal_line_to_buffer( line )
+    @buffer << line
+  end
+  
+  #
+  def add_to_text_container( line )
+    # normal text line inserted to TextContainer
+    @currentContainer << line
+  end
+  #
+  def create_list_item( data )
+    lastItem = ListItemContainer.new( data )
+    @currentContainer.add_child( lastItem )
+    return lastItem
+  end
+  
+  #
+  def find_matching_parent_list( line )
+    while ( @activeLists.size() > 0 )
+      list = @activeLists.last
+      if ( Regexp.new( list.get_regex ).match( line ) != nil )
+        # yes, the current line matches to the list level
+        return list
+      end
+      
+      # didn't match => drop it
+      @activeLists.pop
+    end
+    
+    return nil    
+  end
+  
+  #
+  def start_new_item 
+    @endConditionFound = false
+    @buffer = ''
+  end
+  
+  #
+  def create_list_container( level )
+    @currentContainer = ListContainer.new
+    
+    # only toplevel containers are added to newContainers list
+    if ( @activeLists.size() == 0 )
+      @newContainers.push( @currentContainer )
+    end
+    @activeLists.push( CurrentList.new( @currentContainer, level ) )
+    @currentListRegex = @activeLists.last.get_regex()
+    
+  end
+end
+
+##
+#
+class CurrentList
+  include ListParserUtils
+  
+  attr_reader :container, :level
+  
+  #
+  def initialize( listContainer, level )
+    @container = listContainer
+    @level = level
+  end
+  
+  #
+  def get_sibling_regex
+    return build_regex( @level + 1 )
+  end
+  
+  #
+  def get_number_of_leading_chars
+    return @level * 2 + 1 + 2
+  end
+  
+  #
+  def get_regex
+    return build_regex( @level )
+  end
+  
+end
+
+##
+#
+class SectionParser
+  
+  #
+  def parse( text, contentDoc )
+    newContainers = Array.new
+    sections = text.scan(  /\n----[^\n]*/ )
+    str = text
+    sections.each do |section|
+      firstIndex = str.index( section )
+      newContainers.push( SectionContainer.new( str[0, firstIndex] ) )
+      
+      # take the rest of the string
+      str = str[ firstIndex + section.size, str.size]
+    end
+    
+    # take tail
+    if ( str != nil and str.size() > 0 and newContainers.size > 0 )
+      #puts "*** adding the tail : " + str
+      newContainers.push( SectionContainer.new( str ) )
+    elsif ( newContainers.size == 0 )
+      # no sections, (if only one then don't use it) 
+      return [TextContainer.new( text )]
+    end
+    
+    #      newContainers.each do |i|
+    #        puts "### i = " + i.to_s
+    #      end
+    return newContainers    
+  end
+  
+end
+
+##
+# 
+class ContentDoc
+  include Assert
+  
+  #
+  def initialize( ribitData, currentPage )
+    assert_not_nil( currentPage, 'The provided currentPage is nil' )
+    @root = RootContainer.new( currentPage.data )
+    @refCounter = 1
+    @currentPage = currentPage
+    @ribitData = ribitData
+  end
+  
+  #
+  def get_root
+    return @root
+  end
+  
+  #
+  def get_next_ref_counter
+    current = @refCounter
+    @refCounter = @refCounter + 1
+    return current
+  end
+  
+  #
+  def get_ribitdata
+    return @ribitData
+  end
+  
+  # 
+  def get_current_category
+    @currentPage.category
+  end
+  
+  #
+  def get_current_page_full_id
+    @currentPage.full_id
+  end
+  
+  #
+  def to_s
+    return @root.to_s
+  end
+  
+  
+end 
+
+##
+#
+class Container
+  include Assert
+  
+  #
+  def initialize( parentContainer )
+    @parent = parentContainer
+    @childs = Array.new
+  end
+  
+  #
+  def get_parent
+    return @parent
+  end
+  
+  #
+  def add_child( container )
+    @childs.push( container )
+  end
+  
+  #
+  def set_childs( newChilds )
+    @childs = newChilds
+  end
+  
+  #
+  def replace( index, replacingContainers )
+    #puts "replacing starting from index = " + index.to_s
+    #puts "size of replacingContainers = " + replacingContainers.size().to_s
+    
+    firstPart = @childs[0, index]
+    lastPart = @childs[index + 1, @childs.length]
+    newChilds = Array.new
+    newChilds.concat( firstPart ) unless firstPart == nil
+    newChilds.concat( replacingContainers ) unless replacingContainers == nil
+    newChilds.concat( lastPart ) unless lastPart == nil
+    @childs = newChilds
+  end
+  
+  #
+  def << ( data )
+    @childs.last << data
+  end
+  
+  #
+  def childs?
+    return @childs.size() > 0
+  end
+  
+  #
+  def text?
+    return false
+  end
+  
+  #
+  def get_childs
+    return @childs  
+  end
+  
+  #
+  def to_s
+    result = ''
+    @childs.each do |item|
+      result << item.to_s
+    end
+    
+    return result
+  end
+  
+end
+
+##
+#
+class TextContainer 
+  
+  #
+  def initialize( data='', modifiable=true )
+    @text = data
+    @modifiable = modifiable
+  end
+  
+  #
+  def text?
+    return @modifiable
+  end
+  
+  #
+  def childs?
+    return false
+  end
+  #
+  def get_text 
+    return @text
+  end
+  
+  #
+  def << ( data )
+    @text << data
+  end
+  
+  #
+  def to_s
+    return @text
+  end
+  
+end
+
+##
+#
+class RootContainer < Container
+  
+  #
+  def initialize( data )
+    super( nil )
+    add_child( TextContainer.new( data ) )
+  end
+  
+end
+
+##
+#
+class ParagraphContainer < Container
+  
+  #
+  def initialize
+    super( nil )
+    add_child( TextContainer.new( '' ) )
+  end
+  
+  #
+  def to_s
+    text = super
+    
+    # remove last line feed if exists
+    if ( text[ text.size - 1 ] == 10 )
+      text.chop!
+    end
+    return '<p>' + text + '</p>'
+  end
+  
+end
+
+##
+#
+class SectionContainer < Container
+  
+  #
+  def initialize( text )
+    super( nil )
+    add_child( TextContainer.new( text ) )
+  end
+  
+  #
+  def to_s
+    text = super
+    
+    return '<div class=\'section\'>' + text + '</div>'
+  end
+  
+end
+
+##
+#
+class EmphasisContainer < Container
+  
+  #
+  def initialize( finalTag )
+    super( nil )
+    add_child( TextContainer.new( '' ) )
+    @finalTag = finalTag
+  end
+  
+  #
+  def to_s
+    text = super
+    return "<#{@finalTag}>#{text}</#{@finalTag}>"
+  end
+  
+end
+
+##
+#
+class BoldContainer < EmphasisContainer
+  
+  #
+  def initialize
+    super( 'strong' )
+  end
+  
+end
+
+##
+#
+class ItalicContainer < EmphasisContainer
+  
+  #
+  def initialize
+    super( 'em' )
+  end
+  
+end
+
+##
+#
+class UnformattedContentContainer < Container
+  
+  #
+  def initialize
+    super( nil )
+    # other parsers shouldn't modify text of this container => pass false
+    add_child( TextContainer.new( '', false ) )
+  end
+  
+  #
+  def to_s
+    text = super
+    
+    return '<pre>' + text + '</pre>'
+  end
+  
+end
+
+##
+#
+class DirectLinkContainer < Container
+  
+  #
+  def initialize( href )
+    super( nil )
+    @href =href
+  end
+  
+  #
+  def to_s
+    return "<a href='#{@href}'>#{@href}</a>"
+  end
+  
+end
+
+##
+#
+class RibitLinkContainer < Container
+  
+  #
+  def initialize( linkData, contentDoc )
+    super( nil )
+    @logger = RibitLogger.new( RibitLinkContainer )
+    
+    if ( /\|/.match( linkData ) )
+      # yes, there is link description
+      splitData = linkData.split( '|' )
+      linkData = splitData[0]
+      linkDescription = splitData[1]
+    else
+      linkDescription = linkData
+    end
+    
+    # does linkData contain category ref ?
+    if ( /::/.match( linkData ) )
+      # yes, it does => split data
+      splitData = linkData.split( '::' )
+      pageName = splitData[ splitData.size - 1 ]
+      categoryFullName = splitData[0..(splitData.size - 2 )].join( '::' )
+      
+      # if link ends to | then we show just page name
+      if ( linkDescription == nil or linkDescription.strip.size == 0 )
+        linkDescription = pageName
+      end
+    else
+      # no category => use default
+      categoryFullName = contentDoc.get_current_category().full_name
+      pageName = linkData
+      
+      if ( linkDescription == nil or linkDescription.strip.size == 0 )
+        linkDescription = pageName
+      end
+    end
+    
+    ribitData = contentDoc.get_ribitdata
+    # first try with full name (assuming categoryFullName is really full name)
+    targetPage = ribitData.get_page_by_full_name( categoryFullName + "::" + pageName )
+    #puts "searching: " + categoryFullName + "::" + pageName
+    # .. then if not found try partial name
+    if ( targetPage == nil )
+      newCategoryFullName = contentDoc.get_current_category().full_name + '::' + categoryFullName
+      
+      newCandinate =  newCategoryFullName + "::" + pageName
+      targetPage = ribitData.get_page_by_full_name( newCandinate )
+      
+      if ( targetPage != nil )
+        categoryFullName = newCategoryFullName
+      end
+    end
+    
+    if ( targetPage == nil )
+      # page doesn't exist => link for creating new
+      
+      action = EditNewActionAdapter.new( categoryFullName, pageName, contentDoc.get_current_page_full_id )
+      
+      url = action.get_url
+      
+      link1 = LinkTag.new( url, '[', false )
+      link2 = LinkTag.new( url, ']', false )
+      @logger.debug( 'link1=' + link1.to_s )
+      @text = link1.to_s + linkDescription + link2.to_s
+      @logger.debug( 'text=' + @text )
+      
+    else
+      # page exists so put just page id
+      action = ViewActionAdapter.new( targetPage.full_id )    
+      @text = LinkTag.new( action.get_url, linkDescription, false ).to_s
+    end
+    
+  end
+  
+  #
+  def to_s
+    return @text
+  end
+  
+end
+
+##
+#
+class ReferenceLinkContainer < Container
+  
+  #
+  def initialize( url, contentDoc )
+    super( nil )
+    @url = url
+    @counter = contentDoc.get_next_ref_counter
+  end
+  
+  #
+  def to_s
+    description = @counter.to_s
+    return '[' + LinkTag.new( @url, description, false ).to_s + ']'
+  end
+  
+end
+
+##
+#
+class ListContainer < Container
+  
+  #
+  def initialize
+    super( nil )
+  end
+  
+  #
+  def to_s
+    text = super
+    return '<ul>' + text + '</ul>'
+  end
+  
+end
+
+##
+#
+class ListItemContainer < Container
+  
+  #
+  def initialize( data ) 
+    super( nil )
+    add_child( TextContainer.new( data.strip ) )
+  end
+  
+  #
+  def to_s
+    text = super
+    return '<li>' + text + '</li>'
+  end
+  
+end