docgenerator 2.1.0 → 2.1.1

data/lib/creole/creole2doc.rb

@@ -1,4 +1,4 @@
-#encoding: cp1252
+#encoding: utf-8
 =begin rdoc
 This is a Creole-to-Docgenerator converter.
 The Docgenerator-data can be exported as
@@ -24,45 +24,46 @@ Collect the classes to handle Creole-input.
 
 More about creole at http://www.wikicreole.org/
 =end
-module Creole
+  module Creole
 
 =begin rdoc
 Some class definitions for the Creole-class.
 =end
-class Creole
-
-  #Little structure to store the parsing result.
-  Creole_line = Struct.new('Creole_line', :type, :content, :add_info)
-  
-  #Hash with Characters. 
-  #This characters will be converted into elements.
-  CHARACTERS = {
-    '%' => element(:'%'),
-    '$' => element(:'$'),
-    '&' => element(:ampersand),
-    '->' => element(:rightarrow),
-    '=>' => element(:Rightarrow),
-    '<-' => element(:leftarrow),
-    '<=' => element(:Leftarrow),
-    '_' => element(:underscore),
-    '�' => element(:ldots),  
-    '�' => element(:sbquo),   #	einfaches low-9-Zeichen, U+201A , &#8218;
-    '�' => element(:rsquo),   #'zu &#8217;
-    '�' => element(:bdquo),   #"auf  &#8222;
-    '�' => element(:ldquo),    #"zu 	&#8220;
-    '�' => element(:ndash),  #	&#8211;
-    '�' => element(:mdash),  #	&#8211;
-  }
+    class Creole
+
+      #Little structure to store the parsing result.
+      Creole_line = Struct.new('Creole_line', :type, :content, :add_info)
+      
+      #Hash with Characters. 
+      #This characters will be converted into elements.
+      CHARACTERS = {
+        '%' => element(:'%'),
+        '$' => element(:'$'),
+        '&' => element(:ampersand),
+        '->' => element(:rightarrow),
+        '=>' => element(:Rightarrow),
+        '<-' => element(:leftarrow),
+        '<=' => element(:Leftarrow),
+        '_' => element(:underscore),
+        '…' => element(:ldots),  
+        '‚' => element(:sbquo),   #	einfaches low-9-Zeichen, U+201A , &#8218;
+        '’' => element(:rsquo),   #'zu &#8217;
+        '„' => element(:bdquo),   #"auf  &#8222;  #bottom double quote
+        '“' => element(:ldquo),    #"zu 	&#8220; #left double quote
+        '”' => element(:rdquo),    #right double quote
+        '–' => element(:ndash),  #	&#8211;
+        '—' => element(:mdash),  #	&#8211;
+      }
   
 =begin rdoc
 Add a quick online-help.
 =end
-  def self.help( option = :syntax)
-    hlp = []
-    hlp << "==Creole help #{option}"
-    case option
-      when :syntax
-        hlp << <<Syntax
+      def self.help( option = :syntax)
+        hlp = []
+        hlp << "==Creole help #{option}"
+        case option
+          when :syntax
+            hlp << <<Syntax
 Headings:
   = Level 1 (largest) =
   == Level 2 ==
@@ -75,18 +76,18 @@ You can close them. If not, the markup end with the paragraph.
 
 Links: See Creole.help(:links)
 
-Comming from Wikimedia/wiki2docgenerator? Check Creole.help(:wikimedia)
+Coming from Wikimedia/wiki2docgenerator? Check Creole.help(:wikimedia)
 Familiar with Creole? Check Creole.help(:creole) for differences.
 Syntax
-      when :creole
-        hlp << <<creole
+          when :creole
+            hlp << <<creole
 creole2doc has some special features:
 *headings allows labels ([key] direct after the =)
 *line breaks are ignored, the text is wrapped.
   (you can set it off with option :wrap_at => 0)
 creole
-            when :wikimedia
-        hlp << <<tripfalls
+                when :wikimedia
+            hlp << <<tripfalls
 Main Trippfalls when you used wiki2docgenerator before:
 
 Lists:  You need an empty line after a list.
@@ -94,8 +95,8 @@ Lists:  You need an empty line after a list.
 
   Text afterwords
 tripfalls
-     when :headings
-        hlp << <<headings
+         when :headings
+            hlp << <<headings
 Headings:
   = Level 1 (largest) =
   == Level 2 ==
@@ -114,8 +115,8 @@ Headings with label:
 The content is not parsed.
 Details see http://www.wikicreole.org/wiki/Headings
 headings
-    when :links
-      hlp << <<links
+        when :links
+          hlp << <<links
 Explicit:
 * [[http://ruby.lickert.net/docgenerator]]
 * [[http://ruby.lickert.net/docgenerator|Details on docgenerator.rb]]
@@ -123,8 +124,8 @@ Explicit:
 Implicit:
 * http://ruby.lickert.net/docgenerator
 links
-    when :tabular
-      hlp << <<tabular
+        when :tabular
+          hlp << <<tabular
 Wikimedia-like syntax:
   <<<tabular
   |!columns=3
@@ -142,21 +143,21 @@ Wikimedia-like syntax:
   |three
   >>>
 tabular
-      else
-        hlp << "Undefined help for #{option.inspect}"
-    end
-    return hlp.join("\n")
-  end
-end #Creole
+          else
+            hlp << "Undefined help for #{option.inspect}"
+        end
+        return hlp.join("\n")
+      end
+    end #Creole
 
-#Load sub-classes.
-#~ Dir.chdir(File.dirname(__FILE__)){
-require_relative 'creole_placeholder.rb'
-require_relative 'creole_tabular.rb'
-require_relative 'creole_inclusion_and_plugins.rb'
-#~ begin require 'privat/creole_affiliate.rb'; rescue LoadError; end #Just some privat extension
+    #Load sub-classes.
+    #~ Dir.chdir(File.dirname(__FILE__)){
+    require_relative 'creole_placeholder.rb'
+    require_relative 'creole_tabular.rb'
+    require_relative 'creole_inclusion_and_plugins.rb'
+    #~ begin require 'privat/creole_affiliate.rb'; rescue LoadError; end #Just some privat extension
 
-require 'log4r'
+    require 'log4r'
 
 =begin rdoc
 Build a document.
@@ -167,7 +168,7 @@ multiple HTML (corresponding to pages).
 
 HTML-pagebreak could be forced with ======== or something similar.
 =end
-class Creole_document
+    class Creole_document
 
 =begin rdoc
 Define a creole document. The settings are forwarded to Document#new()
@@ -177,65 +178,63 @@ Some settings are used only directly in Creole_document.
 - :content: Wiki-text. Same as Creole_document#<<
 - :logname: Name for Creole#log
 =end
-  def initialize( settings = {} )
-    @with_toc  = settings[:with_toc ]
-    settings.delete(:with_toc)  #Avoid error message in Document.new
-    settings[:logname] ||= 'CreoleDoc'  #Just a name for easier debugging/logging
-    
-    @creole = Creole.new( 
-        #Get content if available and delete setting to avoid error message in Document.new
-        :logname      => settings.delete(:logname), #for logger
-        :content  => settings.delete(:content),
-        :ignore     => settings.delete(:ignore),
-        :targetdir => settings.delete(:targetdir)
-    )
-    #fixme/ideen parameter
-    #preamble -> vor wiki-texten
-    #post -> nach wiki-texten
-    #plugins/inclusions
-    #replacements (schon teil von document?)
-
-    @doc = Document.new(settings)
-    
-    @doc.runtex = settings[:runtex] if settings[:runtex]
-    
-    @log  = @doc.log
-    
-    @doc.body << creole
-    
-  end
-  #The related document
-  attr_reader :doc
-  #The related creole-object
-  attr_reader :creole
-  #Add content to the wiki.
-  def << (content)
-    @creole << content
-  end
+      def initialize( settings = {} )
+        @with_toc  = settings[:with_toc ]
+        settings.delete(:with_toc)  #Avoid error message in Document.new
+        settings[:logname] ||= 'CreoleDoc'  #Just a name for easier debugging/logging
+        
+        @creole = Creole.new( 
+            #Get content if available and delete setting to avoid error message in Document.new
+            :logname      => settings.delete(:logname), #for logger
+            :content  => settings.delete(:content),
+            :ignore     => settings.delete(:ignore),
+            :targetdir => settings.delete(:targetdir)
+        )
+        #fixme/ideen parameter
+        #preamble -> vor wiki-texten
+        #post -> nach wiki-texten
+
+        @doc = Document.new(settings)
+        
+        @doc.runtex = settings[:runtex] if settings[:runtex]
+        
+        @log  = @doc.log
+        
+        @doc.body << creole
+        
+      end
+      #The related document
+      attr_reader :doc
+      #The related creole-object
+      attr_reader :creole
+      #Add content to the wiki.
+      def << (content)
+        @creole << content
+      end
 =begin rdoc
 Save the creole document.
 
 If requested, the tableofcontents is added.
 The first Creole_document#save decides, which variant is added (html/tex)
 =end
-  def save( filename, options = {} )
-    if @with_toc
-        @doc.body.insertbefore(creole, element(:htmlonly,{}, creole.toc(:level => @with_toc )))
-        @doc.body.insertbefore(creole, element(:latexonly,{},element(:tableofcontents).cr))
-        case @with_toc
-          when Numeric
-            @doc.head << element(:latexonly,{},"\\setcounter{tocdepth}{#{@with_toc}}\n")
-          end 
-        @with_toc  = false #Add it only once
-    end #@with_toc
-    
-    @doc.save(filename, options )
-  end
-  #Use runtex if available.
-  def runtex=(option)
-    @doc.runtex = option
-  end
-end
+      def save( filename, options = {} )
+        if @with_toc
+            @doc.body.insertbefore(creole, element(:htmlonly,{}, creole.toc(:level => @with_toc )))
+            @doc.body.insertbefore(creole, element(:latexonly,{},element(:tableofcontents).cr))
+            case @with_toc
+              when Numeric
+                @doc.head << element(:latexonly,{},"\\setcounter{tocdepth}{#{@with_toc}}\n")
+              end 
+            @with_toc  = false #Add it only once
+        end #@with_toc
+        
+        @doc.save(filename, options )
+      end
+      #Use runtex if available.
+      def runtex=(option)
+        @doc.runtex = option
+      end
+    end
 =begin rdoc
 Creole is a standard wiki-syntax for wikitexts.
 Definition see http://www.wikicreole.org
@@ -248,98 +247,112 @@ This class gets a creole-text and translate it to elements of the docgenerator,
 they can be used by Document or directly like Element#to_doc.
 
 Example:
- wiki = Creole.new()
- wiki << <<txt
- =Test document
- This is a little test text with **bold** and //italic// text.
- txt
- wiki.to_latex()
+  wiki = Creole.new()
+  wiki << <<txt
+  =Test document
+  This is a little test text with **bold** and //italic// text.
+  txt
+  wiki.to_latex()
  
 Often I use it in combination with "Here"-Documents with __END__:
 
- require 'creole/creole2doc'
-
- doc = Creole_document.new()
- doc << DATA
- doc.save('test.html')
- __END__
- Content
+  require 'creole/creole2doc'
+
+  doc = Creole_document.new()
+  doc << DATA
+  doc.save('test.html')
+  __ END__
+  Content
+--
+Im  Code beispiel steht __<space>END__ 
+Würde dort __END__ stehen, hätte rdoc einen Fehler.
+++
 =end
-class Creole  
+    class Creole  
+      class << Creole  
+        #Define a default for targetdir-option in Creole.new. 
+        attr_accessor :targetdir
+      end
+      
 =begin rdoc
 Define the Creole-object.
 
 Options:
-- :log => Logger to catch information.
-   Alternativ you have access to the default logger via Creole#log
-- :targetdir => directory, where you want to save the result.
-   This directory is important for checks for internal links.
-- :ignore: A regex describing parts to be ignored during text parsing. e.g. /^#~.*$/ for usage with scite.
-- :encoding: The encoding used for creole.
+* :log => Logger to catch information.
+
+  Alternativ you have access to the default logger via Creole#log
+* :targetdir => directory, where you want to save the result.
+
+  This directory is important for checks for internal links.
+  
+  You may change the default '.' with 
+    Docgenerator::Creole::Creole.targetdir = 'mysubdir'
+* :ignore: A regex describing parts to be ignored during text parsing. e.g. /^#~.*$/ for usage with scite.
+* :encoding: The encoding used for creole.
   Default is UTF-8
 =end
-  def initialize( options = {} )
-    @options = {
-      :logname => 'Creole',  #Just a name for easier debugging/logging
-      :targetdir  => '.',
-      :wrap_at  => 75,    #Default line wrapping
-      #~ :parsetest             => false  #Make an immediate test for parsing #fixme
-      #~ :placeholders = 
-      #Definition how to handle the sectioning.
-      :title_levels => {
-        0 => nil,
-        1 => :h1,
-        2 => :h2,
-        3 => :h3,
-        4 => :h4,
-        5 => :h5,
-        6 => :h6,
-      },
-      :ignore => nil, #Define a "local" comment, e.g /^#~.*$/ 
-      :encoding => __ENCODING__,
-    }.update(options)
-    @placeholders = Placeholders::Collection.dup
-    @inclusions     = Inclusions::Collection.dup
-    @plugins        = Plugins::Collection.dup
-    
-    #Store the given source text
-    @source  = []
-    #Store the pre-parsed content
-    @normsource  = []
-    @toc  = []  #Collection of all heading lines
-    @footnotegroups = {}  #Collection of footnote groups
-    
-    @targetdir  = @options[:targetdir] if @options[:targetdir]
-    
-    @log  = @options[:log]
-    @log = Log4r::Logger.new(@options[:logname], Log4r::INFO) unless @log
-    @log.outputters = Log4r::StdoutOutputter.new('log_stdout') if  @log.outputters.empty?
-
-    @creation_caller = caller.first
-    self  <<  @options[:content]  if @options[:content]
-  end
-  
-  #Hash with placeholders.
-  #
-  #Placeholders are used with <<<'name'.
-  #This accessor is needed to add more placeholders for specific wikis.
-  #Default: Creole::Placeholders
-  attr_reader :placeholders
-  attr_reader :options
-  
-  #Hash with inclusions.
-  #This accessor is needed to add more inclusions for specific wikis.
-  #Default: Creole::Inclusions
-  attr_reader :inclusions
-  #Hash with all plugins
-  #This accessor is needed to add more plugins for specific wikis.
-  #Default: Creole::Plugins
-  attr_reader :plugins
-  #All footnotegroups of the wiki
-  attr_reader :footnotegroups 
-
-  #Error Class
-  class InputError < ArgumentError; end
+      def initialize( options = {} )
+        @options = {
+          :logname => 'Creole',  #Just a name for easier debugging/logging
+          :targetdir  => self.class.targetdir || '.',
+          :wrap_at  => 75,    #Default line wrapping
+          #~ :parsetest             => false  #Make an immediate test for parsing #fixme
+          #~ :placeholders = 
+          #Definition how to handle the sectioning.
+          :title_levels => {
+            0 => nil,
+            1 => :h1,
+            2 => :h2,
+            3 => :h3,
+            4 => :h4,
+            5 => :h5,
+            6 => :h6,
+          },
+          :ignore => nil, #Define a "local" comment, e.g /^#~.*$/ 
+          :encoding => __ENCODING__,
+        }.update(options)
+        @placeholders = Placeholders::Collection.dup
+        @inclusions     = Inclusions::Collection.dup
+        @plugins        = Plugins::Collection.dup
+        
+        #Store the given source text
+        @source  = []
+        #Store the pre-parsed content
+        @normsource  = []
+        @toc  = []  #Collection of all heading lines
+        @footnotegroups = {}  #Collection of footnote groups
+        
+        @targetdir  = @options[:targetdir] if @options[:targetdir]
+        
+        @log  = @options[:log]
+        @log = Log4r::Logger.new(@options[:logname], Log4r::INFO) unless @log
+        @log.outputters = Log4r::StdoutOutputter.new('log_stdout') if  @log.outputters.empty?
+
+        @creation_caller = caller.first
+        self  <<  @options[:content]  if @options[:content]
+      end
+      
+      #Hash with placeholders.
+      #
+      #Placeholders are used with <<<'name'.
+      #This accessor is needed to add more placeholders for specific wikis.
+      #Default: Creole::Placeholders
+      attr_reader :placeholders
+      attr_reader :options
+      
+      #Hash with inclusions.
+      #This accessor is needed to add more inclusions for specific wikis.
+      #Default: Creole::Inclusions
+      attr_reader :inclusions
+      #Hash with all plugins
+      #This accessor is needed to add more plugins for specific wikis.
+      #Default: Creole::Plugins
+      attr_reader :plugins
+      #All footnotegroups of the wiki
+      attr_reader :footnotegroups 
+
+      #Error Class
+      class InputError < ArgumentError; end
 =begin rdoc  
 Get some content.
 Strings are taken like strings.
@@ -351,246 +364,248 @@ In case of ruby scripts, the part after __END__ is used as input.
 Content added with << starts always with a new paragraph, but it may contain 
 multiple paragraphs, lists...
 =end
-  def << ( input )
-    case input
-      when String
-      source = input
-    when Array
-      #Items of the array are handled like single lines.
-      #The chomp avoid double \n (the array items may already have their own newlines).
-      source = input.map{|item| item.chomp}.join("\n")  #ohne doppelte xx 
-    when File
-      #If file is a ruby script, then use the wiki-code after __END__
-      #
-      #Often scripts contains there own text content after __END__.
-      #So we have to catch, if << is called with DATA
-      if /\.rb\Z/ =~ input.path and $0 != input.path
-        @log.info("Take content of #{input.inspect} after __END__") if @log.info?
+      def << ( input )
+        case input
+          when String
+          source = input
+        when Array
+          #Items of the array are handled like single lines.
+          #The chomp avoid double \n (the array items may already have their own newlines).
+          source = input.map{|item| item.chomp}.join("\n")  #ohne doppelte xx 
+        when File
+          #If file is a ruby script, then use the wiki-code after __END__
+          #
+          #Often scripts contains there own text content after __END__.
+          #So we have to catch, if << is called with DATA
+          if /\.rb\Z/ =~ input.path and $0 != input.path
+            @log.info("Take content of #{input.inspect} after __END__") if @log.info?
+            begin
+              line = input.readline while line != "__END__\n"
+            rescue EOFError
+              @log.error("No __END__ found in #{input.inspect}") if @log.error?
+            end  
+          end
+          #Read the code
+          source = input.readlines.join
+        else
+          raise InputError, "Don't know, how to handle #{input.class} in Creole#<<"      
+        end
         begin
-          line = input.readline while line != "__END__\n"
-        rescue EOFError
-          @log.error("No __END__ found in #{input.inspect}") if @log.error?
-        end  
-      end
-      #Read the code
-      source = input.readlines.join
-    else
-      raise InputError, "Don't know, how to handle #{input.class} in Creole#<<"      
-    end
-    begin
-      source_enc = source.encode(@options[:encoding])
-    rescue Encoding::UndefinedConversionError => err
-      @log.warn("Encoding conversion error <#{err}>") if @log.warn?
-      source_enc = source.encode(@options[:encoding], :undef => :replace)
-    end
-    @source << source_enc 
-    #Parse the given source.
-    #This is done immediate, so you have a chance to localize the line, where an error occurs.
-    #(Some errors are reported later during to_doc).
-    #fixme: option to parse immediate at << or later
-    #immediate_parse => true...
-    @normsource.push( *parse( source_enc  ) )
-  end #<< ( input )
+          source_enc = source.encode(@options[:encoding])
+        rescue Encoding::UndefinedConversionError => err
+          @log.warn("Encoding conversion error <#{err}>") if @log.warn?
+          source_enc = source.encode(@options[:encoding], :undef => :replace)
+        end
+        @source << source_enc 
+        #Parse the given source.
+        #This is done immediate, so you have a chance to localize the line, where an error occurs.
+        #(Some errors are reported later during to_doc).
+        #fixme: option to parse immediate at << or later
+        #immediate_parse => true...
+        @normsource.push( *parse( source_enc  ) )
+      end #<< ( input )
 =begin rdoc
 Parse the given creole code and build a "normalized source"
 =end
-  def parse( source = @source )
-    
-    normsource = []    
-    statusflag = nil  #Variable to store the actual status. nil = nothing special.
-    normsource << Creole_line.new(:dummy)
-
-    if ! source.respond_to?(:each_with_index)
-      #Ruby 1.9 removed each from String
-      if source.respond_to? :each_line
-        source = source.each_line 
-      else
-        @log.fatal("Unable to parse #{source.class}: #{source.inspect}" ) if @log.fatal?
-        return normsource
-      end
-    end
-
-
-    #
-    #Check code line by line
-    #
-    source.each_with_index{|line, lineno|
-      #Check special status
-      case statusflag
-        when nil  #Nothing to do
-        when :pre
-          line =~ /\}\}\}/ ? statusflag = nil : normsource.last.content << line
-          next
-        when :placeholder
-          if line =~ /^>>>$/
-            statusflag = nil 
-            normsource.last.content.close
+      def parse( source = @source )
+        
+        normsource = []    
+        statusflag = nil  #Variable to store the actual status. nil = nothing special.
+        normsource << Creole_line.new(:dummy)
+
+        if ! source.respond_to?(:each_with_index)
+          #Ruby 1.9 removed each from String
+          if source.respond_to? :each_line
+            source = source.each_line 
           else
-            normsource.last.content << line
+            @log.fatal("Unable to parse #{source.class}: #{source.inspect}" ) if @log.fatal?
+            return normsource
           end
-          next
-        else
-          @log.fatal("Undefind status #{statusflag}: #{line.inspect}" ) if @log.fatal?
-        end #statusflag
-        
-      #
-      #Parse the wiki text on line level (main structure)
-      case line
-        #Skip this line, if it correspond to a special comment-pattern.
-        #Can be used for application-specific comments.
+        end
+
+
         #
-        #Example: 
-        #   :ignore => /^#~.*$/
-        #This comment is created by scite using Ctrl-Q (for ruby-scripts).
-        when @options[:ignore]
-            @log.info("Found comment #{$1} : #{line.inspect}" ) if @log.info?
-        #Headings
-        #http://www.wikicreole.org/wiki/Headings
+        #Check code line by line
         #
-        #Modification of standard: Labels are possible.
-        when /^(=+)(?:\[(.*)\])?(.+?)(=*)\s*$/
-          normsource << Creole_line.new(:title, $3, :level => $1.size, :label => $2 )
-          @toc << normsource.last
-          #Creole doesn't need a trailing ===, but when it is ther, it should be correct
-          if $1.size != $4.size and $4.size > 0
-            @log.warn("Heading problem #{$1} doesn't match <#{$4}>: #{line.inspect}" ) if @log.warn?
-          end
-          if $~.post_match !~ /\s*/
-            @log.warn("Ignore text #{$~.post_match.inspect} after title  <#{line.inspect}>" ) if @log.warn?
-          end
-          #And close the actual level
-          #See unit test test_creole_mix_titles_list
-          normsource << Creole_line.new(:dummy )
-        #Empty line
-        when /^\s*$/
-          normsource << Creole_line.new(:dummy )
-        when /^----\s*$/
-          normsource << Creole_line.new(:hr )
-        #List entry
-        when /^\s*((\*|\#)+)/
-          normsource << Creole_line.new(:list, $~.post_match, :listtype => $1 )
-        #Tabular
-        when /^\|/
-          #fixme tab soll in par...
-          #~ normsource.last << Creole_line.new(:placeholder, 
-          #~ ... unless anpassen...
-          normsource << Creole_line.new(:placeholder, 
-                                        @placeholders['creole_tabular'].new(self),
-                                        :start => lineno
-                                      ) unless normsource.last.content.is_a?(Creole_tab)
-          normsource.last.content << line
-        #http://www.wikicreole.org/wiki/PreformattedAndNowiki
-        when /^\{\{\{\s*$/  #Kind of verbatim
-          normsource << Creole_line.new(:pre, [], :start => lineno )
-          statusflag = :pre
-        #~ when /^<<<(.*)\|?(.*?)/ #fixme options for placeholders?
-        when /^<<<(.*)/
-          ph, par = $1.split(/\|/,2)
-          placeholder = @placeholders[ph].new(self, par)
-          if placeholder.instance_of?(Placeholders::Dummy)
-            @log.warn("Unknown placeholder #{ph.inspect} used in line #{lineno}" ) if @log.warn?
-          end
-          normsource << Creole_line.new(:placeholder, placeholder, :start => lineno )
-          statusflag = :placeholder
-        else
-          case normsource.last.type
-            when :par, :list
+        source.each_with_index{|line, lineno|
+          #Check special status
+          case statusflag
+            when nil  #Nothing to do
+            when :pre
+              line =~ /\}\}\}/ ? statusflag = nil : normsource.last.content << line
+              next
+            when :placeholder
+              #~ if line =~ /^>>>$/ #did not catch each system specific line end.
+              if line =~ /^>>>(\r\n?|\n)/
+                statusflag = nil 
+                normsource.last.content.close
+              else
+                normsource.last.content << line
+              end
+              next
+            else
+              @log.fatal("Undefinded status #{statusflag}: #{line.inspect}" ) if @log.fatal?
+            end #statusflag
+            
+          #
+          #Parse the wiki text on line level (main structure)
+          case line
+            #Skip this line, if it correspond to a special comment-pattern.
+            #Can be used for application-specific comments.
+            #
+            #Example: 
+            #   :ignore => /^(#~.*)$/
+            #This comment is created by scite using Ctrl-Q (for ruby-scripts).
+            when @options[:ignore]
+                @log.info("Found comment in line %2i: %s" % [
+                  lineno, #line.inspect
+                  [$~.pre_match, '<<', $1, '>>', $~.post_match].join.strip,
+                ]) if @log.info?
+            #Headings
+            #http://www.wikicreole.org/wiki/Headings
+            #
+            #Modification of standard: Labels are possible.
+            when /^(=+)(?:\[(.*)\])?(.+?)(=*)\s*$/
+              normsource << Creole_line.new(:title, $3, :level => $1.size, :label => $2 )
+              @toc << normsource.last
+              #Creole doesn't need a trailing ===, but when it is ther, it should be correct
+              if $1.size != $4.size and $4.size > 0
+                @log.warn("Heading problem #{$1} doesn't match <#{$4}>: #{line.inspect}" ) if @log.warn?
+              end
+              if $~.post_match !~ /\s*/
+                @log.warn("Ignore text #{$~.post_match.inspect} after title  <#{line.inspect}>" ) if @log.warn?
+              end
+              #And close the actual level
+              #See unit test test_creole_mix_titles_list
+              normsource << Creole_line.new(:dummy )
+            #Empty line
+            when /^\s*$/
+              normsource << Creole_line.new(:dummy )
+            when /^----\s*$/
+              normsource << Creole_line.new(:hr )
+            #List entry
+            when /^\s*((\*|\#)+)/
+              normsource << Creole_line.new(:list, $~.post_match, :listtype => $1 )
+            #Tabular
+            when /^\|/
+              #fixme tab soll in par...
+              #~ normsource.last << Creole_line.new(:placeholder, 
+              #~ ... unless anpassen...
+              normsource << Creole_line.new(:placeholder, 
+                                            @placeholders['creole_tabular'].new(self),
+                                            :start => lineno
+                                          ) unless normsource.last.content.is_a?(Creole_tab)
               normsource.last.content << line
+            #http://www.wikicreole.org/wiki/PreformattedAndNowiki
+            when /^\{\{\{\s*$/  #Kind of verbatim
+              normsource << Creole_line.new(:pre, [], :start => lineno )
+              statusflag = :pre
+            #~ when /^<<<(.*)\|?(.*?)/ #fixme options for placeholders?
+            when /^<<<(.*)/
+              ph, par = $1.split(/\|/,2)
+              placeholder = @placeholders[ph].new(self, par)
+              if placeholder.instance_of?(Placeholders::Dummy)
+                @log.warn("Unknown placeholder #{ph.inspect} used in line #{lineno}" ) if @log.warn?
+              end
+              normsource << Creole_line.new(:placeholder, placeholder, :start => lineno )
+              statusflag = :placeholder
             else
-              normsource << Creole_line.new(:par, line )
-            end
-      end
-    }
-    case statusflag
-      when nil  #ok
-      when :pre
-        @log.warn("Unclosed verbatim found (start at #{normsource.last.add_info[:start]})" ) if @log.warn?
-        #~ raise ''
-      when :placeholder
-        @log.warn("Unclosed placeholder #{normsource.last.type} (start at #{normsource.last.add_info[:start]})" ) if @log.warn?
-      else
-        @log.warn("Wiki ends with status #{statusflag.inspect}" ) if @log.warn?
-    end
-    return normsource
-  end #parse
-  #Logger to collect messages.
-  attr_reader :log
-  #Returns the source as it was received
-  attr_reader :source
-  #The pre-parsed content. 
-  attr_reader :normsource
-  #Directory for the target.
-  #Can be used to check internal links (images, local files...)
-  attr_reader :targetdir
-  #Wrap some text after this lines.
-  #See http://forum.ruby-portal.de/viewtopic.php?t=3844
-  #
+              case normsource.last.type
+                when :par, :list
+                  normsource.last.content << line
+                else
+                  normsource << Creole_line.new(:par, line )
+                end
+          end
+        }
+        case statusflag
+          when nil  #ok
+          when :pre
+            @log.warn("Unclosed verbatim found (start at #{normsource.last.add_info[:start]})" ) if @log.warn?
+            #~ raise ''
+          when :placeholder
+            #One possible source: Regexp $ is system specific.
+            @log.warn("Unclosed placeholder #{normsource.last.type} (start at #{normsource.last.add_info[:start]})" ) if @log.warn?
+          else
+            @log.warn("Wiki ends with status #{statusflag.inspect}" ) if @log.warn?
+        end
+        return normsource
+      end #parse
+      #Logger to collect messages.
+      attr_reader :log
+      #Returns the source as it was received
+      attr_reader :source
+      #The pre-parsed content. 
+      attr_reader :normsource
+      #Directory for the target.
+      #Can be used to check internal links (images, local files...)
+      attr_reader :targetdir
   
 =begin rdoc
 Return a table of contents as a list.
 =end
-  def toc( i_options = {})
-    options = {
-      :listtype  => :ul,
-      :level    => 4,
-      #~ :startlevel  => 1,
-      }.update(i_options)
-
-    if ! options[:level].is_a?(Fixnum)
-      @log.error("Toc: toclevel is no number but '#{options[:level].inspect}'. Set 4") if @log.error?
-      options[:level] = 4
-    end
+      def toc( i_options = {})
+        options = {
+          :listtype  => :ul,
+          :level    => 4,
+          #~ :startlevel  => 1,
+          }.update(i_options)
+
+        if ! options[:level].is_a?(Fixnum)
+          @log.error("Toc: toclevel is no number but '#{options[:level].inspect}'. Set 4") if @log.error?
+          options[:level] = 4
+        end
 
 
-    toclist = []
-    toclabel = [0] #help variable to construct labels
-    listtype = '*'
-    case options[:listtype]
-      when '*', :ul, :itemize
+        toclist = []
+        toclabel = [0] #help variable to construct labels
         listtype = '*'
-      when '#', :ol, :enumerate
-        listtype = '#'
-      else
-        @log.error("Toc: Unknown listtype #{options[:listtype]}") if @log.error?
-    end
-    
-    @toc.each{|tocentry|
-        level = tocentry.add_info[:level]
-        #Skip deeper levels then wanted.
-        next if level > options[:level]
-
-        #Build the label
-        if level > toclabel.size
-          toclabel << 0
-        elsif level < toclabel.size
-          toclabel.pop
-        end
-        #Happens if there is a jump gap on section levels (subsubsection inside section without subsection)
-        if ! toclabel[level-1]
-          @log.warn("Missing toclevel for <#{tocentry.content}> #{tocentry.add_info.inspect}")
-          #add dummy level 
-          toclabel << 0
-          toclist << "#{listtype * ( level - 1)} ---"
-        end
-        toclabel[level-1] = toclabel[level-1] + 1 
-
-        #Check if there was already a label.
-        #If yes: use it. If not: build a new one with the help of toclabel.
-        if tocentry.add_info[:label]
-          label = tocentry.add_info[:label]
-        else
-          label = tocentry.add_info[:label] = toclabel.join('-')
+        case options[:listtype]
+          when '*', :ul, :itemize
+            listtype = '*'
+          when '#', :ol, :enumerate
+            listtype = '#'
+          else
+            @log.error("Toc: Unknown listtype #{options[:listtype]}") if @log.error?
         end
         
-        #Feature to create the toc if higher levels are missing /start at h3...)
-        #~ if level < options[:startlevel]
-          #~ @log.warn( "toc: TOC starts not at #{options[:startlevel]}, but level #{level}" ) if @log.warn?
-          #~ next 
-        #~ end
-        
-        toclist << "#{listtype * level}[[##{label}|#{tocentry.content}]]"
-      }
-      toclist = <<toc
+        @toc.each{|tocentry|
+            level = tocentry.add_info[:level]
+            #Skip deeper levels then wanted.
+            next if level > options[:level]
+
+            #Build the label
+            if level > toclabel.size
+              toclabel << 0
+            elsif level < toclabel.size
+              toclabel.pop
+            end
+            #Happens if there is a jump gap on section levels (subsubsection inside section without subsection)
+            if ! toclabel[level-1]
+              @log.warn("Missing toclevel for <#{tocentry.content}> #{tocentry.add_info.inspect}")
+              #add dummy level 
+              toclabel << 0
+              toclist << "#{listtype * ( level - 1)} ---"
+            end
+            toclabel[level-1] = toclabel[level-1] + 1 
+
+            #Check if there was already a label.
+            #If yes: use it. If not: build a new one with the help of toclabel.
+            if tocentry.add_info[:label]
+              label = tocentry.add_info[:label]
+            else
+              label = tocentry.add_info[:label] = toclabel.join('-')
+            end
+            
+            #Feature to create the toc if higher levels are missing /start at h3...)
+            #~ if level < options[:startlevel]
+              #~ @log.warn( "toc: TOC starts not at #{options[:startlevel]}, but level #{level}" ) if @log.warn?
+              #~ next 
+            #~ end
+            
+            toclist << "#{listtype * level}[[##{label}|#{tocentry.content}]]"
+          }
+          toclist = <<toc
 <<<html
 <div class = 'toc'>
 >>>
@@ -600,8 +615,8 @@ Return a table of contents as a list.
 >>>
 toc
 
-    return Creole.new( :content => toclist, :log => @log )
-  end #toc
+        return Creole.new( :content => toclist, :log => @log )
+      end #toc
 =begin rdoc
 Wrapping mechanism for texts.
 
@@ -610,251 +625,253 @@ Don't do anything, if line_width is 0.
 See also http://stackoverflow.com/questions/7548968/format-output-to-40-characters-long-per-line/7549032#7549032
 and http://forum.ruby-portal.de/viewtopic.php?t=3844&p=24578
 =end
-  def word_wrap(text, line_width = @options[:wrap_at] ) 
-    return text if line_width <= 0
-    text.gsub(/\n/, ' ').gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip
-  end
+      def word_wrap(text, line_width = @options[:wrap_at] ) 
+        return text if line_width <= 0
+        text.gsub(/\n/, ' ').gsub(/(.{1,#{line_width}})(\s+|$)/, "\\1\n").strip
+      end
 =begin rdoc
 Prepare document.
 =end
-  def to_doc( target, options = {} )
-    options[:log] = @log unless options[:log]
-    #
-    #Delete again all footnotegroups.
-    #Else you get footnotes doubled.
-    @footnotegroups = {}  #Collection of footnote groups
-    return normsource2elements( @normsource, options ).to_doc(target, options)
-  end #to_doc
+      def to_doc( target, options = {} )
+        options[:log] = @log unless options[:log]
+        #
+        #Delete again all footnotegroups.
+        #Else you get footnotes doubled.
+        @footnotegroups = {}  #Collection of footnote groups
+        return normsource2elements( @normsource, options ).to_doc(target, options)
+      end #to_doc
 =begin rdoc
 Take the given normsource and build a list of elements.
 Used by
 - Creole#to_doc
 -  Creole_ruby#to_doc
 =end
-  def normsource2elements( normsource, options )
-    doc = []    
-    elements = {} #little collector for lists
-    normsource.each{|line|
-      case line.type
-        when :dummy
-          elements  = {}
-        #Here we define the sectioning.
-        #line.add_info[:level] contains the number of = from the wiki.
-        #
-        when :title
-        
-          doc << element(@options[:title_levels][line.add_info[:level]], {
-                                :id => line.add_info[:label]
-                              #inline or not? 
-                              #Required for filenames with _ 
-                              #But: http://www.wikicreole.org/wiki/Headings says no.
-                              #Make decision depending on a setting?
-                              }, line.content ).cr          
-                              #~ }, inline(line.content, options ) ).cr          
-        when :list
-          key = line.add_info[:listtype]
-          if ! elements[key]
-            case key[-1,1]
-            when '*';  elements[key] = element(:ul).cR
-            when '#';  elements[key] = element(:ol).cR
-            else
-              options[:log].error("Undefined listtype #{key[-1,1]}") if options[:log].error?
-            end
-            if key.size == 1  #new list, add to document
-              doc << elements[key] 
-            elsif parent_list = elements[key[0,key.size-1]] #new sublist, add to "parent"
-              parent_list << element(:li).cr unless parent_list.content.last.is_a?(:li)
-              parent_list.content.last << elements[key] 
-            else  #sublist without parent.
-              options[:log].error("List #{key} with missing sublist") if options[:log].error?
-            end
+      def normsource2elements( normsource, options )
+        doc = []    
+        elements = {} #little collector for lists
+        normsource.each{|line|
+          case line.type
+            when :dummy
+              elements  = {}
+            #Here we define the sectioning.
+            #line.add_info[:level] contains the number of = from the wiki.
+            #
+            when :title
+            
+              doc << element(@options[:title_levels][line.add_info[:level]], {
+                                    :id => line.add_info[:label]
+                                  #inline or not? 
+                                  #Required for filenames with _ 
+                                  #But: http://www.wikicreole.org/wiki/Headings says no.
+                                  #Make decision depending on a setting?
+                                  }, line.content ).cr          
+                                  #~ }, inline(line.content, options ) ).cr          
+            when :list
+              key = line.add_info[:listtype]
+              if ! elements[key]
+                case key[-1,1]
+                when '*';  elements[key] = element(:ul).cR
+                when '#';  elements[key] = element(:ol).cR
+                else
+                  options[:log].error("Undefined listtype #{key[-1,1]}") if options[:log].error?
+                end
+                if key.size == 1  #new list, add to document
+                  doc << elements[key] 
+                elsif parent_list = elements[key[0,key.size-1]] #new sublist, add to "parent"
+                  parent_list << element(:li).cr unless parent_list.content.last.is_a?(:li)
+                  parent_list.content.last << elements[key] 
+                else  #sublist without parent.
+                  options[:log].error("List #{key} with missing superlist") if options[:log].error?
+                  doc << element(:comment,{},'Sublist without superlist - move on top level').cr #add pending list on top level.
+                  doc << elements[key] #add pending list on top level.
+                end
+              end
+              elements.each{|ekey, list|
+                case ekey
+                  when key
+                    list << element(:li,{}, inline(line.content, options) ).cr
+                  else
+                    elements.delete(ekey) if ekey.size >= key.size
+                end
+              }
+          when :pre
+            doc << element(:verbatim, {}, line.content ).cR
+          when :hr
+            doc << element(:hr).cr
+          when :placeholder
+            doc << line.content
+          when :par
+            doc << element(:par, {}, inline(line.content, options)).cR
+          else
+            options[:log].error("Wrong line type #{ line.type.inspect }") if options[:log].error?
           end
-          elements.each{|ekey, list|
-            case ekey
-              when key
-                list << element(:li,{}, inline(line.content, options) ).cr
-              else
-                elements.delete(ekey) if ekey.size >= key.size
-            end
-          }
-      when :pre
-        doc << element(:verbatim, {}, line.content ).cR
-      when :hr
-        doc << element(:hr).cr
-      when :placeholder
-        doc << line.content
-      when :par
-        doc << element(:par, {}, inline(line.content, options)).cR
-      else
-        options[:log].error("Wrong line type #{ line.type.inspect }") if options[:log].error?
-      end
-    }
-    
-    return doc
-  end #to_doc_internal
+        }
+        
+        return doc
+      end #to_doc_internal
 =begin rdoc
 Parse the inline text.
 
 Options is a Hash and may contain:
 * :log (default: @log)
 =end
-  def inline( text,  options )
-    
-    raise ArgumentError, "Creole#inline: Options no Hash" unless options.is_a?(Hash)
-    options[:log]           = @log unless options[:log]
-    options[:plugins]      = @plugins unless options[:plugins]
-    options[:inclusions]  = @inclusions unless options[:inclusions]
-    
-    res = []  #result
-    stack = []  #
-
-    #~ http_regex  = 
-    #fixme: Only once to reduce runtime
-    splitregex = Regexp.new(
-      '(' + [
-            '\[\[.+?\]\]',  # [[...links]]
-            'http:\/\/.+?(\s|\Z)', #including the next space!!
-            '\*\*', #bold
-            '\/\/', #emph
-            '\\\\\\\\', #newline
-            '\{\{\{.*?\}\}\}', #inline verbatim
-            '\{\{.*?\}\}', #images/inclusion
-            '<<.*?>>',   #Plugins
-            CHARACTERS.keys.join('|')
-            ].join('|')  + ')'
-    )
-    #Splitt along 'active' elements.
-    #~ @options[:wrap_at]
-    #~ text.gsub(/\n/, ' ').split(splitregex).each{|el|
-    text.split(splitregex).each{|el|
-      case el
-        when '**' #bold
-          if stack.last.is_a?(:textbf)
-              stack.pop #leave bold area
-          else 
-            stack << newel = element(:textbf) #enter bold area
-            if stack.size > 1
-              stack[-2] << newel
-            else
-              res << newel 
-            end
-          end
-        when '//' #italic
-          if stack.last.is_a?(:emph)
-            stack.pop #leave italic area
-          else
-            stack << newel = element(:emph) #enter italic area
-            if stack.size > 1
-              stack[-2] << newel 
-            else
-              res << newel 
+      def inline( text,  options )
+        
+        raise ArgumentError, "Creole#inline: Options no Hash" unless options.is_a?(Hash)
+        options[:log]           = @log unless options[:log]
+        options[:plugins]      = @plugins unless options[:plugins]
+        options[:inclusions]  = @inclusions unless options[:inclusions]
+        
+        res = []  #result
+        stack = []  #
+
+        #~ http_regex  = 
+        #fixme: Only once to reduce runtime
+        splitregex = Regexp.new(
+          '(' + [
+                '\[\[.+?\]\]',  # [[...links]]
+                'https?:\/\/.+?(\s|\Z)', #including the next space!!
+                '\*\*', #bold
+                '\/\/', #emph
+                '\\\\\\\\', #newline
+                '\{\{\{.*?\}\}\}', #inline verbatim
+                '\{\{.*?\}\}', #images/inclusion
+                '<<.*?>>',   #Plugins
+                CHARACTERS.keys.join('|')
+                ].join('|')  + ')'
+        )
+        #Splitt along 'active' elements.
+        #~ @options[:wrap_at]
+        #~ text.gsub(/\n/, ' ').split(splitregex).each{|el|
+        text.split(splitregex).each{|el|
+          case el
+            when '**' #bold
+              if stack.last.is_a?(:textbf)
+                  stack.pop #leave bold area
+              else 
+                stack << newel = element(:textbf) #enter bold area
+                if stack.size > 1
+                  stack[-2] << newel
+                else
+                  res << newel 
+                end
+              end
+            when '//' #italic
+              if stack.last.is_a?(:emph)
+                stack.pop #leave italic area
+              else
+                stack << newel = element(:emph) #enter italic area
+                if stack.size > 1
+                  stack[-2] << newel 
+                else
+                  res << newel 
+                end
+              end
+            when '\\\\' #newline
+              ( stack.last ? stack.last  : res ) << element(:newline).cr
+            #Something like [[http:...]]
+            when %r{^\[\[(.+?)(?:\|(.*?))?\]\]}  #Link
+              link = $1
+              linktext = $2 ? $2 : $1
+              case link
+                when /^(https?|ftp):\/\/.+?/
+                  link = link
+                #local file via file://...
+                when /^(file):\/\/(.+)/
+                  link = link
+                  check_link_existence( $2, options[:log] )
+                when /^\./, /\S:[\\\/]/  #lokal file
+                  link = link
+                  check_link_existence( link, options[:log] )
+                when /^#/   #internal link
+                  link = link
+                  #fixme tex?
+                else  #internal link
+                  #This is normally the wiki-links.
+                  #But this is no wiki, it's a documentgenerator with wiki syntax.
+                  options[:log].warn("Unclear link <#{el}> #{self.inspect}") if options[:log].warn?
+                  link = link
+              end
+              if link == linktext #Avoid replacement of // inside linktext
+                href = element(:a, {:href=>link}, linktext )
+              else
+                href = element(:a, {:href=>link}, inline(linktext, options) )
+              end
+              if stack.last  
+                stack.last << href 
+              else
+                res << href
+              end
+            #All links should be catched before
+            when %r{\[\[(.*)\]\]}
+              options[:log].error("Lost link <#{el}>") if options[:log].error?
+            #fixme: there are obsolete 2 additional spaces in the result.
+            when /^http/ #implicit link
+              #~ href = element(:a, {:href=>el.strip}, el.strip ) #This makes problems with TeX (unmasked _,%...)
+              href = element(:url, {}, el.strip )
+              el =~ /(\s|\Z)$/  #get the end-space/newline if available
+              endspace = ( $1.empty? ? nil : $1 )
+              if stack.last  
+                stack.last << href
+                #~ stack.last << last_char #add again the 
+              else
+                res << href
+                #~ res << last_char  #add again the end-space/newline
+              end
+            #No-wiki inline: {{{text}}}
+            when /\{\{\{(.*)\}\}\}/
+              if stack.last  
+                stack.last << element(:verb,{},$1)
+              else
+                res << element(:verb,{},$1)
+              end
+            #Inclusion 
+            #creole2doc implements a general inclusion.
+            #Main usage are pictures/images ({{picname|alt}}),
+            #but it can be more...
+            #
+            #Available inclusions are defined in Creole::Inclusions resp. Creole#inclusions,
+            when /\{\{(.+?)(?:\|(.*))?\}\}/
+              if stack.last  
+                stack.last << inclusion_or_plugin($1, $2, options[:inclusions])
+              else
+                res << inclusion_or_plugin($1, $2, options[:inclusions])
+              end
+            #Plugin
+            #Used like Inclusions.
+            #
+            #available plugins are defined in Creole::Plugins resp. Creole#plugins
+            when /<<(.+?)(?:\|(.*))?>>/
+              if stack.last  
+                stack.last << inclusion_or_plugin($1, $2, options[:plugins])
+              else
+                res << inclusion_or_plugin($1, $2, options[:plugins])
+              end
+            #No special wiki command. The text is "normal" text.
+            else  #text to add
+              #Replace characters.
+              if CHARACTERS[el]
+                insertion = CHARACTERS[el]
+                startspace = endspace = nil
+              else
+                startspace = ( el[0,1] =~ /\s/ )
+                endspace = ( el[-1,1] =~ /\s/ )
+                insertion = word_wrap( el )         #wrap content
+              end
+              if stack.last 
+                stack.last << insertion
+                #This adds some obsolete spaces in case of newlines at the end.
+                #But if I compare with ' ', then words will be concatenated without separator.
+                stack.last << ' ' if endspace
+              else  #Just some text without any format
+                res << ' ' if startspace #Keep space
+                res << insertion
+                res << ' ' if endspace #Keep space
+              end
             end
-          end
-        when '\\\\' #newline
-          ( stack.last ? stack.last  : res ) << element(:newline).cr
-        #Something like [[http:...]]
-        when %r{^\[\[(.+?)(?:\|(.*?))?\]\]}  #Link
-          link = $1
-          linktext = $2 ? $2 : $1
-          case link
-            when /^(https?|ftp):\/\/.+?/
-              link = link
-            #local file via file://...
-            when /^(file):\/\/(.+)/
-              link = link
-              check_link_existence( $2, options[:log] )
-            when /^\./, /\S:[\\\/]/  #lokal file
-              link = link
-              check_link_existence( link, options[:log] )
-            when /^#/   #internal link
-              link = link
-              #fixme tex?
-            else  #internal link
-              #This is normally the wiki-links.
-              #But this is no wiki, it's a documentgenerator with wiki syntax.
-              options[:log].warn("Unclear link <#{el}> #{self.inspect}") if options[:log].warn?
-              link = link
-          end
-          if link == linktext #Avoid replacement of // inside linktext
-            href = element(:a, {:href=>link}, linktext )
-          else
-            href = element(:a, {:href=>link}, inline(linktext, options) )
-          end
-          if stack.last  
-            stack.last << href 
-          else
-            res << href
-          end
-        #All links should be catched before
-        when %r{\[\[(.*)\]\]}
-          options[:log].error("Lost link <#{el}>") if options[:log].error?
-        #fixme: there are obsolete 2 additional spaces in the result.
-        when /^http/ #implicit link
-          #~ href = element(:a, {:href=>el.strip}, el.strip ) #This makes problems with TeX (unmasked _,%...)
-          href = element(:url, {}, el.strip )
-          el =~ /(\s|\Z)$/  #get the end-space/newline if available
-          endspace = ( $1.empty? ? nil : $1 )
-          if stack.last  
-            stack.last << href
-            #~ stack.last << last_char #add again the 
-          else
-            res << href
-            #~ res << last_char  #add again the end-space/newline
-          end
-        #No-wiki inline: {{{text}}}
-        when /\{\{\{(.*)\}\}\}/
-          if stack.last  
-            stack.last << element(:verb,{},$1)
-          else
-            res << element(:verb,{},$1)
-          end
-        #Inclusion 
-        #creole2doc implements a general inclusion.
-        #Main usage are pictures/images ({{picname|alt}}),
-        #but it can be more...
-        #
-        #Available inclusions are defined in Creole::Inclusions resp. Creole#inclusions,
-        when /\{\{(.+?)(?:\|(.*))?\}\}/
-          if stack.last  
-            stack.last << inclusion_or_plugin($1, $2, options[:inclusions])
-          else
-            res << inclusion_or_plugin($1, $2, options[:inclusions])
-          end
-        #Plugin
-        #Used like Inclusions.
-        #
-        #available plugins are defined in Creole::Plugins resp. Creole#plugins
-        when /<<(.+?)(?:\|(.*))?>>/
-          if stack.last  
-            stack.last << inclusion_or_plugin($1, $2, options[:plugins])
-          else
-            res << inclusion_or_plugin($1, $2, options[:plugins])
-          end
-        #No special wiki command. The text is "normal" text.
-        else  #text to add
-          #Replace characters.
-          if CHARACTERS[el]
-            insertion = CHARACTERS[el]
-            startspace = endspace = nil
-          else
-            startspace = ( el[0,1] =~ /\s/ )
-            endspace = ( el[-1,1] =~ /\s/ )
-            insertion = word_wrap( el )         #wrap content
-          end
-          if stack.last 
-            stack.last << insertion
-            #This adds some obsolete spaces in case of newlines at the end.
-            #But if I compare with ' ', then words will be concatenated without separator.
-            stack.last << ' ' if endspace
-          else  #Just some text without any format
-            res << ' ' if startspace #Keep space
-            res << insertion
-            res << ' ' if endspace #Keep space
-          end
-        end
-    }
-    res
-  end #inline
+        }
+        res
+      end #inline
 =begin rdoc
 Inclusion or Plugin.
 creole2doc implements a general inclusion.
@@ -863,24 +880,24 @@ but it can be more...
 
 The last paramter contains a hash with the supported inclusions/plugins.
 =end
-  def inclusion_or_plugin( link, p_additions, inclusions )
-    
-    addition, additions = nil
-    #Splitt additions at | 
-    if p_additions
-      addition, *additions = p_additions.split(/\|/)
-    end
+      def inclusion_or_plugin( link, p_additions, inclusions )
+        
+        addition, additions = nil
+        #Splitt additions at | 
+        if p_additions
+          addition, *additions = p_additions.split(/\|/)
+        end
 
-    inclusion = inclusions[link]
-    #check inclusion.ancestors?
-    #~ if inclusion.superclass != Creole_inclusion_and_plugin
-    if inclusion.is_a?(Creole_inclusion_and_plugin)
-      @log.error( "Wrong inclusion/plugin definition for #{link} (#{inclusion.inspect}, expected #{inclusions.default.superclass})") if @log.error?
-      return nil
-    end
-    ip = inclusion.new( link, addition, additions, self )
-    return ip
-  end #inclusion
+        inclusion = inclusions[link]
+        #check inclusion.ancestors?
+        #~ if inclusion.superclass != Creole_inclusion_and_plugin
+        if inclusion.is_a?(Creole_inclusion_and_plugin)
+          @log.error( "Wrong inclusion/plugin definition for #{link} (#{inclusion.inspect}, expected #{inclusions.default.superclass})") if @log.error?
+          return nil
+        end
+        ip = inclusion.new( link, addition, additions, self )
+        return ip
+      end #inclusion
 =begin rdoc
 Check for links and pictures if the target exist.
 
@@ -889,27 +906,27 @@ Relative pathes are searched from @options[:targetdir] (default '.').
 
 Different locations are not supported (e.g. to implement LaTeXs \graphicspath)
 =end
-  def check_link_existence( filename, log )
-    case filename
-      when /^.:/#absolute DOS-path (e.g. c:\...)
-        path = filename.dup
-      else  #relative path
-        path = "#{@options[:targetdir]}/#{filename}".sub(/^\//, '')
-      end
-    path.sub!(/(\.html?)#.*$/, '\1') #Don't check anchor inside html
-    if ! File.exist?(path)
-      log.warn("Reference not found: <#{filename}> (looking at <#{path}>)") if log.warn?
-      #~ log.debug("Reference not found: <#{path}>") if log.debug?
-      fpath = File.expand_path("#{Dir.pwd}/#{path}")
-      log.debug("Reference not found: <#{fpath}>") if log.debug?
-    end
-  end #check_link_existence
+      def check_link_existence( filename, log )
+        case filename
+          when /^.:/#absolute DOS-path (e.g. c:\...)
+            path = filename.dup
+          else  #relative path
+            path = "#{@options[:targetdir]}/#{filename}".sub(/^\//, '')
+          end
+        path.sub!(/(\.html?)#.*$/, '\1') #Don't check anchor inside html
+        if ! File.exist?(path)
+          log.warn("Reference not found: <#{filename}> (looking at <#{path}>)") if log.warn?
+          #~ log.debug("Reference not found: <#{path}>") if log.debug?
+          fpath = File.expand_path("#{Dir.pwd}/#{path}")
+          log.debug("Reference not found: <#{fpath}>") if log.debug?
+        end
+      end #check_link_existence
 
-  def inspect()
-    "<#{self.class} (created #{@creation_caller})>"
-  end
-end #Creole 
-end #module Creole
+      def inspect()
+        "<#{self.class} (created #{@creation_caller})>"
+      end
+    end #Creole 
+  end #module Creole
 end #module Docgenerator