docgenerator 1.0.4 → 1.1.1

data/lib/creole/creole2doc.rb

@@ -0,0 +1,777 @@
+#
+#This is a Creole-to-Docgenerator converter.
+#The Docgenerator-data can be exported as
+#- HTML
+#- LaTeX
+#- Creole
+#- Wikimedia-like wiki
+#- Plain text
+#
+#For another Creole-to-XHTML converter see 
+#https://rubyforge.org/projects/wikicreole/
+#
+#More about creole at http://www.wikicreole.org/
+#
+
+require 'docgenerator'
+
+#
+#Some class definitions for the Creole-class.
+#
+class Creole
+  #Little structure to store the parsing result.
+  Creole_line = Struct.new('Creole_line', :type, :content, :add_info)
+  #Define Placeholders
+  #Placeholders are used via <<<...>>>
+  #Default: Creole_dummy_placeholder (set in class definition Creole_dummy_placeholder)
+  Placeholders = Hash.new()
+  #Define Inclusions
+  #Inclusions are used via {{...}}
+  #Default: Creole_inclusion_img (defined in class definition Creole_inclusion_img)
+  Inclusions = Hash.new()
+  #Define Plugins
+  #Plugins are used via <<...>>
+  Plugins = Hash.new()
+  
+  #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),  . maskieren?
+  }
+  
+  #Add a quick online-help.
+  def self.help( option = :syntax)
+    hlp = []
+    hlp << "==Creole help #{option}"
+    case option
+      when :syntax
+        hlp << <<Syntax
+Headings:
+  = Level 1 (largest) =
+  == Level 2 ==
+see also Creole.help(:headings)
+
+Bold And Italics:
+** Bold
+// Italics
+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)
+Familiar with Creole? Check Creole.help(:creole) for differences.
+Syntax
+      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
+Main Trippfalls when you used wiki2docgenerator before:
+
+Lists:  You need an empty line after a list.
+  #Listentry 2
+
+  Text afterwords
+tripfalls
+     when :headings
+        hlp << <<headings
+Headings:
+  = Level 1 (largest) =
+  == Level 2 ==
+  === Level 3 ===
+  ==== Level 4 ====
+  ===== Level 5 =====
+  ====== Level 6 ======
+  === Also level 3
+  === Also level 3 =
+  === Also level 3 ==
+  === **not** //parsed// ===
+Headings with label:  
+  =[lev1] Level 1 (largest) =
+  ==[lev1.1] Level 2 ==
+
+The content is not parsed.
+Details see http://www.wikicreole.org/wiki/Headings
+headings
+    when :links
+      hlp << <<links
+Explicit:
+* [[http://ruby.lickert.net/docgenerator]]
+* [[http://ruby.lickert.net/docgenerator|Details on docgenerator.rb]]
+
+Implicit:
+* http://ruby.lickert.net/docgenerator
+links
+    when :tabular
+      hlp << <<tabular
+Wikimedia-like syntax:
+  <<<tabular
+  |!columns=3
+  |!columndescription=ccc
+  |=1
+  |=2
+  |=3
+  |-
+  |eins
+  |zwei
+  |drei
+  |-
+  |one
+  |two
+  |three
+  >>>
+tabular
+      else
+        hlp << "Undefined help for #{option.inspect}"
+    end
+    return hlp.join("\n")
+  end
+end #Creole
+
+#Load sub-classes.
+Dir.chdir(File.dirname(__FILE__)){
+require 'creole_placeholder.rb'
+require 'creole_tabular.rb'
+require 'creole_inclusion_and_plugins.rb'
+#~ begin require '../../privat/creole_privat.rb'; rescue LoadError; end #fixme
+begin require 'creole_privat.rb'; rescue LoadError; end #Just some privat extension
+}
+
+Dir.chdir('..'){
+  require 'docgenerator'
+}
+require 'log4r'
+
+#
+#Build a document.
+#This is just a little combination of the classes Document and Creole.
+#
+#For the future: This class could allow features t build one TeX-file and
+#multiple HTML (corresponding to pages).
+#
+#HTML-pagebreak could be forced with ======== or something similar.
+class Creole_document
+  #Define a creole document. The settings are forwarded to Document#new()
+  #
+  #Some settings are used only directly in Creole_document.
+  #- :with_toc: Add a table of contents at the beginning of the document.
+  #- :content: Wiki-text. Same as Creole_document#<<
+  def initialize( settings = {} )
+    @with_toc  = settings[:with_toc ]
+    settings.delete(:with_toc)  #Avoid error message in Document.new
+    
+    @creole = Creole.new( 
+        #Get content if available and delete setting to avoid error message in Document.new
+        :content  => settings.delete(:content),
+        :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)
+    @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
+  #Save the creole document
+  def save( filename, options = {} )
+    if @with_toc 
+      @doc.body.insertbefore(creole, creole.toc)
+      @with_toc  = false #Add it only once
+    end
+    
+    @doc.save(filename, options )
+  end
+  #Use runtex if available.
+  def runtex=(option)
+    @doc.runtex = option
+  end
+end
+#Creole is a standard wiki-syntax for wikitexts.
+#Definition see http://www.wikicreole.org
+#
+#I liked this definition.
+#When you look at the website, you get a definition and 
+#you get an explanation, why it is like this. - great!
+#
+#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
+# puts wiki.to_latex()
+class Creole  
+  #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.
+  def initialize( options = {} )
+    @options = {
+      :name => '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,
+      },
+    }.update(options)
+    @placeholders = Placeholders.dup
+    @inclusions     = Inclusions.dup
+    @plugins        = Plugins.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]
+    @log  = @options[:log]
+    @log = Log4r::Logger.new(@options[:name], Log4r::INFO) unless @log
+    @log.outputters = Log4r::StdoutOutputter.new('log_stdout') if  @log.outputters.empty?
+    
+    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 
+
+  #Get some content.
+  #Strings are taken like strings.
+  #
+  #It is possible to add the content of a file. Just add the open file handle.
+  #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...
+  def << ( input )
+    if input.is_a?(String)
+      source = input
+    elsif input.is_a?(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.to_s
+    end
+    
+    @source << source
+    #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: optional sofort bei << oder sp�ter.
+    #immediate_parse => true...
+    @normsource.push( *parse( source ) )
+  end #<< ( input )
+  
+  #Parse the given creole code and build a "normalized source"
+  def parse( source = @source )
+    
+    normsource = []
+    statusflag = nil  #Variable to store the actual status. nil = nothing special.
+    normsource << Creole_line.new(:dummy)
+    #
+    #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
+          else
+            normsource.last.content << line
+          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
+        #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
+        #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_creoletab)
+          normsource.last.content << line
+        #http://www.wikicreole.org/wiki/PreformattedAndNowiki
+        when /^\{\{\{\s*$/
+          normsource << Creole_line.new(:pre, [], :start => lineno )
+          statusflag = :pre
+        #~ when /^<<<(.*)\|?(.*?)/ #fixme optionen f�r placeholder?
+        when /^<<<(.*)/
+          placeholder = @placeholders[$1].new(self)
+          if placeholder.is_a?(Creole_dummy_placeholder)
+            @log.warn("Unknown placeholder #{$1.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
+              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
+        @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
+  #
+  
+  #
+  #Return a table of contents.
+  #
+  def toc( i_options = {})
+    options = {
+      :listtype  => :ul,
+      :level    => 4,
+      #~ :startlevel  => 1,
+      }.update(i_options)
+    toclist = []
+    toclabel = [0] #help variable to construct labels
+    listtype = '*'
+    case options[:listtype]
+      when '*', :ul, :itemize
+        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]
+        
+        #Build the label
+        if level > toclabel.size
+          toclabel << 0
+        elsif level < toclabel.size
+          toclabel.pop
+        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
+        #Skip deeper levels then wanted.
+        next if level > options[:level]
+        
+        #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}]]"
+      }
+    return Creole.new( :content => toclist.join("\n") )
+  end #toc
+  
+  #Don't do anything, if line_width is 0.
+  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
+  #
+  #Prepare document.
+  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
+  #Take the given normsource and build a list of elements.
+  #Used by
+  #- Creole#to_doc
+  #-  Creole_ruby#to_doc
+  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
+          #~ puts line[:add_info].inspect
+          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
+          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(:pre, {}, 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
+  #
+  #Parse the inline text.
+  def inline( text,  options )
+
+    res = []  #result
+    stack = []  #
+    
+    #~ http_regex  = 
+    #fixme: Only once to reduce runtime
+    splitregex = Regexp.new(
+      '(' + [
+            '\[\[.+?\]\]',  # [[...links]]
+            'http:\/\/.+?\s', #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
+            when /^\./  #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}>") 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?
+        when /^http/ #implicit link
+          href = element(:a, {:href=>el.strip}, el.strip )
+          if stack.last  
+            stack.last << href
+            stack.last << ' ' #add again the end-space
+          else
+            res << href
+            res << ' '  #add again the end-space
+          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, @inclusions)
+          else
+            res << inclusion_or_plugin($1, $2, @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, @plugins)
+          else
+            res << inclusion_or_plugin($1, $2, @plugins)
+          end
+        #No special wiki command. The text is "normal" text.
+        else  #text to add
+          #Replace characters.
+          if CHARACTERS[el]
+            insertion = CHARACTERS[el] if 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
+  #Inclusion or Plugin.
+  #creole2doc implements a general inclusion.
+  #Main usage are pictures/images ({{picname|alt}}),
+  #but it can be more...
+  #
+  #The last paramter contains a hash with the supported inclusions/plugins.
+  #
+  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
+      @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
+  
+  #Check for linkes and pictures if the target exist.
+  def check_link_existence( filename, log )
+    path = "#{@options[:targetdir]}/#{filename}"    
+    if ! File.exist?(path)
+      log.warn("Reference not found: <#{filename}> (looking at #{@options[:targetdir]})") 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
+end #Creole 
+
+if [__FILE__, 'creole_tabular.rb'].include?($0)
+  
+  #~ [
+  #~ :syntax,
+  #~ :creole,
+  #~ :wikimedia,
+  #~ :trippfall,
+  #~ :headings,
+  #~ :links,
+  #~ ].each{|key| 
+    #~ puts '='*50
+    #~ puts Creole.help(key) 
+    #~ puts '='*50
+  #~ }
+  
+  #~ puts `call "../../unittest/unittest_creole2doc.rb"`
+  require 'quicktest'
+end