docgenerator 2.1.1 → 3.0.0

data/lib/wiki2doc/plugins/rubycode4wiki.rb

@@ -1,53 +0,0 @@
-#
-#Obsolete script.
-#Replaced by creole/pplugins/rubycode4doc.rb
-#
-#This script is still in the distribution
-#
-
-
-#Only for quick tests
-$:.unshift("../../") if $0 == __FILE__ 
-
-
-require 'wiki2doc/wiki2docgenerator'
-require 'docgenerator/packages/rubycode4doc'
-#Example see examples/rubycode_wiki.rb
-
-#
-module Docgenerator
-module Wikimedia
-
-=begin rdoc
-Define a new Ruby-Type
-=end
-class Rubywiki	<	Wikitext
-	def wiki_macro( macro, argv )
-		case macro
-			when 'rubycode'
-				Rubycode::CodeTest[argv] ? Rubycode::CodeTest[argv].code : "Code '#{argv}' not defined"
-			when 'rubycode_with_evaluation'
-				Rubycode::CodeTest[argv] ? Rubycode::CodeTest[argv].code_evaluation_lstlisting : "Code '#{argv}' not defined"
-			when 'rubycode_in_tab'
-				Rubycode::CodeTest[argv] ? Rubycode::CodeTest[argv].code_in_tab : "Code '#{argv}' not defined"
-			else
-				super
-		end
-	end
-end
-
-#~ end
-end #module Wikimedia
-
-class Rubycode::CodeTest
-  #If used as Wikicollector, just return nothing.
-  #The Collector is just used to define the code
-  def to_doc( target, options = {} ); '';  end
-end
-#if rubycode4wiki.rb is loaded add the class to the WikiCollectors.
-Wikimedia::WikiCollector.add(:rubycode, Rubycode::CodeTest)
-
-end #module Docgenerator
-
-__END__
-Example see examples/rubycode_wiki.rb

data/lib/wiki2doc/plugins/struktex.rb

@@ -1,12 +0,0 @@
-=begin rdoc
-Add struktex-extension as WikiCollector.
-=end
-
-#~ $:.unshift('../..')
-require 'wiki2doc/wiki2docgenerator.rb'
-require 'docgenerator/packages/struktex.rb'
-
-#if wiki2docgenerator is loaded, add the class to the WikiCollectors.
-if defined?( Docgenerator::Wikimedia::WikiCollector)
-Docgenerator::Wikimedia::WikiCollector.add(:structogramm, Docgenerator::Packages::Struktex::Structogramm)
-end

data/lib/wiki2doc/wiki2docgenerator.rb

@@ -1,1276 +0,0 @@
-=begin rdoc
-This small programm reads a text in Wiki-format and 
-transform it to a "docgenerator"-object.
-
-This object can be saved as HTML or TeX (or Wiki again - in preparation).
-
-http://de.wikipedia.org/wiki/WikiSyntax
-http://de.wikipedia.org/wiki/Hilfe:Textgestaltung
-
-For usage: Check test.wiki.rb
-=end
-
-#
-#fixme:
-#-	
-#-	Textbaustein	{{...}}
-#Standard: [[ legt Textbaustein an, {{ nutzt diesen
-#	http://de.wikipedia.org/wiki/Wikipedia:Textbausteine/Schwesterprojekte
-#-	http://de.wikipedia.org/wiki/Wikipedia:Textbausteine
-
-require 'docgenerator'
-require 'log4r'
-#~ begin
-#~ require 'privat/docgenerator_affiliate' 
-#~ rescue LoadError
-#~ end
-
-#
-module Docgenerator
-=begin rdoc
-Collection of classes to handle texts in Wikimedia-Syntax.
-=end
-module Wikimedia
-#Struct for wiki-replacements.
-#The proc contains three block-parameter: The match-element, the Wikitext-object and the logger-object.
-Wikireg = Struct.new( 'WikiReg', :rule, :regex, :proc )
-class Wikireg	
-  @@give_message = true
-  def self.give_message=(val); @@give_message = val; 	end
-  def self.give_message?(); return @@give_message; 	end
-end
-
-#Constant with all Standard-replacemnts of Wikis.
-#Each replacement should also convert the part before and after the match.
-WIKI_INLINE_REPLACEMENTS =	[
-  #[[Bild:Dateiname|Zusatzinfos|Beschreibung]]
-  #Zusatzinfos:
-  #	-left
-  #	-right
-  Wikireg.new(:bild, /\[\[Bild:(.*?)\]\]/,
-                Proc.new{|m, oo, log| 
-                  parameter = m[1].split('|')
-                  [	oo.inline(m.pre_match, log),
-                    oo.wiki_bild( parameter.first, parameter[1..-1], log),
-                    oo.inline(m.post_match, log),
-                  ]
-              } ),
-  Wikireg.new(:file, /\[\[File:(.*)\]\]/,
-                Proc.new{|m, oo, log| 
-                  parameter = m[1].split('|')
-                  filename = parameter[0]
-                  if parameter.size > 1
-                    txt = "#{parameter.last}"
-                  else
-                    txt = File.basename(filename)
-                  end
-                  if  Wikireg.give_message? and ! File.exist?(filename)
-                    log.warn( "Link to unexisting local file #{filename} (from #{Dir.pwd})" ) if log.warn?
-                  end
-                  
-                  css = CSS.new()
-                  parameter[1..-2].each{|p|
-                    case p
-                      when 'size'
-                        txt << " (#{File.size(filename)/1024}KB)"	if File.exist?(filename)
-                      when /(.*)=>(.*)/
-                        css[$1] = $2
-                      else
-                        log.warn( "Wiki-File with unknown setting #{p}" ) if log.warn?
-                    end
-                  }
-                  #Result:
-                  [ 
-                    oo.inline(m.pre_match, log), 
-                    element(:a, { :href => filename, :alt => txt, :style => css  }, oo.inline(txt, log) ),
-                    oo.inline(m.post_match,log)
-                ]} ),
-  Wikireg.new(:label, %r{\[\[label:(.*)\]\]},
-                Proc.new{|m, oo, log| 
-                    [	oo.inline(m.pre_match, log), 
-                      element(:label, { :name => m[1]} ),
-                      oo.inline(m.post_match, log)
-                    ]
-                } ),
-  Wikireg.new(:ref, %r{<ref>(.*)</ref>},
-                Proc.new{|m, oo, log| 
-                puts "<ref> is obsolete, use {{footnote}}. To get footnotes set {{footnotes|ref}}"
-                    [	oo.inline(m.pre_match, log), 
-                      element(:footnote, { :groupid =>  'ref' }, oo.inline(m[1],log) ),
-                      oo.inline(m.post_match, log)
-                    ]
-                } ),
-  Wikireg.new(:bf_it, /''''(.*?)''''/,
-                Proc.new{|m, oo, log| [ oo.inline(m.pre_match, log), 
-                            element(:textbf, {}, element(:emph, {}, oo.inline(m[1], log) )),
-                            oo.inline(m.post_match, log)
-                ]} ),
-  Wikireg.new(:bf, /'''(.*?)'''/,
-                Proc.new{|m, oo, log| [ oo.inline(m.pre_match, log), 
-                            element(:textbf, {}, oo.inline(m[1], log)),
-                            oo.inline(m.post_match, log)
-                ]} ),
-  Wikireg.new(:it, /''(.*?)''/,
-                Proc.new{|m, oo, log| [ oo.inline(m.pre_match, log), 
-                            element(:emph, {}, oo.inline(m[1], log)),
-                            oo.inline(m.post_match, log)
-                ]} ),
-  #Soll in Wikipedia-Artikeln nicht verwendet werden.
-  Wikireg.new(:small, %r{<small>(.*)</small>},
-                Proc.new{|m, oo, log| 
-                    [	oo.inline(m.pre_match, log), 
-                      element(:small, {}, oo.inline(m[1], log )),
-                      oo.inline(m.post_match, log)
-                    ]
-                } ),								
-  Wikireg.new(:stroke, %r{<s>(.*)</s>},
-                Proc.new{|m, oo, log| 
-                    [	oo.inline(m.pre_match, log), 
-                      element(:stroke, {}, oo.inline(m[1], log )),
-                      oo.inline(m.post_match, log)
-                    ]
-                } ),								
-  #-	Textbaustein	{{...}}
-  #Standard: [[ legt Textbaustein an, {{ nutzt diesen
-  #	http://de.wikipedia.org/wiki/Wikipedia:Textbausteine/Schwesterprojekte
-  #-	http://de.wikipedia.org/wiki/Wikipedia:Textbausteine
-  Wikireg.new(:wikidef, /\[\[(.+?):(.*?)\]\]/,		
-                    Proc.new{|m, oo, log| 
-                    puts "wikidef #{m[1].inspect} obsolete, please use macro {{..|"
-                      [	oo.inline(m.pre_match, log), 
-                        oo.wikidef(m[1], m[2] ),
-                        oo.inline(m.post_match, log)
-                      ]}
-                  ),
-  Wikireg.new(:wiki_macro, /\{\{(.+?)(\|(.*?))?\}\}/,		
-                    Proc.new{|m, oo, log| 
-                      [	oo.inline(m.pre_match, log), 
-                        oo.wiki_macro(m[1], m[3] ),
-                        oo.inline(m.post_match, log)
-                      ].delete_if{|e| ! e or e.respond_to?(:to_str) and /\A\s*\Z/m =~ e}
-                      #[].delete(nil) may return nil -> use delete_if
-                    }
-                  ),
-  #Problem: detect end of url without a end-character
-  #[uri text]
-  Wikireg.new(:url1, %r{\[\s*((?:https?://|\.|C:\\|C:\/|ftp:|mailto:|webcal://).*?)\s+(.*?)\s*\]},
-            Proc.new{|m, oo, log| 
-              #Check local files, but without anchor
-              if /\A\./ =~ m[1]	#local file
-                filename = oo.inputsource + m[1].split(/#/).first	
-              else
-                filename = m[1].split(/#/).first	
-              end
-                            if Wikireg.give_message? and /\A(\.|\w:)/ =~ m[1] and ! File.exist?(filename)
-                              log.warn( "Link to unexisting local file #{filename} (from #{Dir.pwd})" ) if log.warn?
-              end
-              link_url = m[1]
-              if /^\w:/	=~	link_url	#local file with absolut path
-                link_url = 'file://' + link_url
-              end
-              if m[2].size > 0
-                linktext = m[2]
-              else
-                linktext = m[1].sub(/http:\/\//, '').sub(/\/$/, '')
-              end
-              [ 		oo.inline(m.pre_match, log), 
-                  element(:a, {:href=> link_url }, oo.inline(linktext, log) ),
-                  oo.inline(m.post_match, log)
-              ]
-            } 
-          ),
-  #uri	http...
-  Wikireg.new(:url2, %r{(https?://.*?)(\s|\Z)},
-                Proc.new{|m, oo, log| 
-                        [ oo.inline(m.pre_match, log), 
-                            #~ element(:a, {:href=> m[1]}, m[1] ),	#hier kein oo.inline
-                            element(:url, {}, m[1] ),	#hier kein oo.inline
-                            m[2],								#Space/CR
-                            oo.inline(m.post_match, log)
-                ]} ),
-  Wikireg.new(:wikilink, /\[\[(.+?)(\|(.*?))?\]\]/,
-  #~ Wikireg.new(:wikilink, /\[\[(.+?)\]\]/,
-                Proc.new{|m, oo, log| 
-                      linktext = m[1]
-                      #m[2] includes the |
-                      if m[3]
-                        linktext = m[3]
-                      end
-                      [ oo.inline(m.pre_match, log), 
-                        element(:a, {:href=> m[1]}, 
-                          oo.inline(linktext, log)
-                        ),
-                        oo.inline(m.post_match, log)
-                      ]
-                } ),
-]
-
-#require 'LotusNotes.rb'
-WIKI_INLINE_REPLACEMENT_NOTES =	
-      Wikireg.new(:notes, /(Notes:.*?)(\s|\Z)/,	Proc.new{|m, oo, log| 
-                    [
-                      oo.inline( m.pre_match, log),
-                      LN_Link.new( m[1] ).to_element,
-                      m[2],
-                      oo.inline( m.post_match, log ),
-                    ]})
-
-WIKI_INLINE_REPLACEMENTS_SYMBOLS = [
-      #Problem: Native LaTeX with beamer and \only...
-      Wikireg.new(:arrow, /->/,
-                Proc.new{|m, oo, log| 
-                  [	oo.inline(m.pre_match, log),
-                    element(:rightarrow),
-                    oo.inline(m.post_match, log),
-                  ]
-              } ),
-      Wikireg.new(:Arrow, /=>/,
-                Proc.new{|m, oo, log| 
-                  [	oo.inline(m.pre_match, log),
-                    element(:Rightarrow),
-                    oo.inline(m.post_match, log),
-                  ]
-              } ),
-      ]
-
-WIKI_INLINE_REPLACEMENTS_UNDERSCORE = Wikireg.new(:underscore, /_/,
-                Proc.new{|m, oo, log| 
-                  [	oo.inline(m.pre_match, log),
-                    "\\_",
-                    oo.inline(m.post_match, log),
-                  ]
-              } )
-              
-#require 'LotusNotes.rb'
-if defined? LN_Link
-  WIKI_INLINE_REPLACEMENTS << WIKI_INLINE_REPLACEMENT_NOTES
-end
-
-module Wiki_helper
-  #Transfer the input to a list.
-  #input can be
-  #-String
-  #-List
-  #-File	(if .rb, then the part after __END__ is taken)
-  #The method returns a list with lines, but no \n
-  def get_input( input,  lineoffset, close_it = false )
-    inputlist	= []
-    if input.is_a?(String)
-      #~ inputlist = input.split("\n")
-      #Convert to Array, but keep the \n
-      inputlist = input.split("\n")
-    elsif input.is_a?(Array)
-      inputlist = input.flatten.map{|l| l.nil? ? '' : l.chomp()}
-    elsif input.is_a?(File)
-      #If file is a ruby scriot, then the wiki-code in after __END__
-      if /\.rb\Z/ =~ input.path and $0 != input.path 
-        line = input.readline while line != "__END__\n"
-      end
-      lineoffset = input.lineno
-      inputlist << input.readlines.map{|l| l.chomp}
-      input.close if close_it
-    end
-    return inputlist, lineoffset
-  end
-end
-#
-#Struct for wiki elements.
-class Wikielements   < Struct.new('Wikielements', :first, :l1,:l2,:l3,:l4, :tab, :row )
-    #Clear all precesssors.
-    def clear( element )
-        if element.is_a?(Integer)
-            element = self.members[element]
-        end
-        self.members.reverse.each{|i|
-            break if i == element.to_s
-            self[i] = nil
-        }
-    end
-end
-
-#
-#Get text in wiki-format and build a docgenerator-version.
-#
-class Wikitext
-  include Docgenerator  #get VERSION
-  
-  #
-  #Make short description for the Wiki-syntax
-  def self.help( version = :syntax)
-    hlp = []
-    hlp << "Wikitext.help #{version.inspect}"
-    hlp << "-------------------------------------"
-    case version
-      when :syntax
-        hlp << <<main
-Sections:
-  ==title==
-  ===subtitle===
-  ====subsubtitle====
-Lists:
-  * unordered
-  # ordered
-  description-like:
-    ;key
-    :entry
-Pictures:
-  [[Bild:path|options]]
-  For options use Wikitext.help(:img)
-Tabulars:
-  Use Wikitext.help(:tab) for details
-Specials:
-  ----  hrule
-main
-      when :img
-        hlp << <<main
-Pictures in Wikitext:
-  [[Bild:path|options]]
-The complete command must be in one line.  
-  Options:
-  - href=
-  - alt=
-  - imgclass=: Used for CSS-class (img)
-  - figureclass=: Used for CSS-class (span/div)
-  - left, right:  CSS: float
-  - aftertitle/beforetitle: Text before/after image
-  - thumb: Add a thumb in the text and link to picture
-  - \d*px: size/width 
-  - width=xx%  define width for img/includegraphics
-  - xx = : Used for CSS in img
-main
-    when :tab
-      hlp << <<tabhelp
-Tabulars in Wikitext:
-  {|taboptions
-  |[lineoptions|]
-  |-[newline-options]
-  |
-  |}
-taboptions:
-  - columns=: number of columns (required)
-  - columndescription:  For LaTeX
-  - border=:  HTML
-  - .* = (.*): Used for CSS
-newline-options  
-  - toprule
-  - midrule
-  - hline
-  - .* = (.*): Used for CSS
-lineoptions:
-  - colspan = 
-  - pos
-  - .* = (.*): Used for CSS
-
-Remark: If the text contains macros with | there is a bit confusion, 
-what is a parameter of the cell and whats part of the macro.
-
-Solution: Define the end of cell parameters with ||
-tabhelp
-      else
-        hlp << "Sorry, option #{version.inspect} unknown"
-      end
-    return hlp.join("\n")
-  end #help
-  #Read text and convert it to a Document.
-  def initialize(
-      options = {}
-    )
-    #convert from old interface
-    options = {
-      :wiki_inline_replacements	=> options
-    }	if options.is_a?(Array)
-    @options = {
-      :wiki_inline_replacements	=> WIKI_INLINE_REPLACEMENTS + WIKI_INLINE_REPLACEMENTS_SYMBOLS,
-      :log => Log4r::Logger.new('Wikitext', Log4r::INFO),
-      :inputsource						=>	'./',
-      :parsetest 						=> false	#Make an immediate test for parsing
-    }.update(options)
-    @source	= []
-    #Hash with all footnote groups
-    @footnotegroups = {}
-    #This rules can be extended via the accessors.
-    @wiki_inline_replacements	= @options[:wiki_inline_replacements]
-    @lineoffset	= 0	#for better debugging
-    @inputsource	= @options[:inputsource]
-    @log	= @options[:log]
-    @log.outputters = Log4r::StdoutOutputter.new('log_stdout') if  @log.outputters.empty?
-    self	<<	@options[:content]	if @options[:content]
-    @parent	= self
-  end
-  #Line offset. 
-  #Is used as initial value in << 
-  attr_writer :lineoffset
-  #Used for relative filecheck
-  attr_accessor :inputsource
-  #Array with the rules for the inline elements (like text formatting...)
-  #Can be extended/replaces by this accessor
-  #
-  #Don't include arrays. elements must be 'Wikireg'.
-  attr_reader :wiki_inline_replacements
-  #Logger
-  attr_reader :log
-  #Element, where the wiki test belongs to.
-  #Can be used in the procs insiede a wikirule.
-  attr_accessor :parent
-  #Wiki-Code.
-  #Source is an array 
-  attr_accessor :source
-  
-  include Wiki_helper
-  #Add contents to Wiki-Text
-  def <<( input )
-    inputlist, lineoffset =  get_input( input,  @lineoffset )
-    #The immediate parsing may help, when an error occurs.
-    #The immediat parsing returns error messages with correct lineoffsets.
-    #(On the other side, it may helt to see the @source itself)
-    wiki2doc( inputlist.join("\n"), lineoffset ) if @options[:parsetest] == true
-    @source.concat(inputlist)
-    return self
-  end
-  #Prepare output for docgenerator.
-  #
-  #Attention! to_doc uses another logger then the wiki.
-  #If it should be the same, it must be added at definition of the wiki.
-  def to_doc( target, options = {} )
-    o = set_option_defaults(options)
-    o[:log].debug("enter to_doc for Wikitext #{self.inspect}") if o[:log].debug?
-    @footnotegroups = {}  #Avoid the multiple additions to groups (this makes parallel processing inpossible!)
-    doc = wiki2doc( @source.join("\n") )  #return lists of element
-    doc.to_doc(target, options )
-  end #Wikitext.to_doc
-  
-  #
-  #Method is called for wiki-structures like
-  #	[[key:value]]
-  #This can be used to adapt the wiki for special usages.
-  #
-  #This is a inline replacement.
-  #The return code is added at the location, where it is defined
-  def wikidef( key, value )
-      @log.warn("#{self.class}#wikidef #{key}: #{value} in line #{@lineno}" ) if log.warn?
-      return value
-  end
-  #Include a picture	
-  #	[[Bild:Dateiname|Zusatzinfos|Beschreibung]]
-  #Zusatzinfos:
-  #	-left/right
-  #	-___px	scale the pic. When used in combination with thumb, a pic "widht-picname) is searched.
-  #	-thumb	(usefull in combination with href or width=50%)
-  #figure_type:
-  #The picture is framed by this value.
-  #When you use :div, you can't make inline-Pics.
-  #:span can be used also as float (HTML)
-  #Correct LaTeX: figure (or not?
-  def	wiki_bild( picname, parameter, log, figure_type = :span)
-    thumb	= false	#Use thumb instead
-    href		= false	#make pic clickabe
-    figure = element(figure_type, { :style	=>	css_fig	= CSS.new() }).cR
-    css_img	= CSS.new()
-    option = { :src => picname, :style => css_img  }	#Options for img
-    before_img	= []
-    after_img	= []
-      
-    parameter.each{|p|
-      case p
-        when /href=(.*)/;						href	=	$1
-        when /alt=(.*)/;						option[:alt] =	$1
-        when /imgclass=(.*)/;				option[:class]	=	$1
-        when /figureclass=(.*)/;			figure[:class]	<<	$1
-        when /^class=(.*)/;					option[:class]	=	$1	#old
-        when 'left', 'right'
-          css_fig[:float] = p
-        when /aftertitle(=(.*))*/
-          after_img << element(:br, { :clear => 'all' } ).cr
-          after_img << $2
-        when /beforetitle(=(.*))*/
-          before_img << $2
-          after_img << element(:br, { :clear => 'all' } ).cr
-        when /thumb(=(.*))*/
-          #Add a thumb in the text and link to picture
-          thumb	= true	#look later for width-picname
-          thumb	= $2	if $2
-          if File.exist?( @inputsource + picname ) and !href
-            href = picname
-          end
-        when /\A\d*px\Z/		#size
-          option[:width] = p
-        when /(width)=(.*)/
-          css_img[$1] = $2
-          w = $2	#store it, $2 is replaced in next regex.
-          case w
-            when /100%/
-              option[:width] = "\\textwidth"
-            when /\A(\d+)%/
-              option[:width] = "0.#{$1}\\textwidth"
-            else
-              option[:width] = w
-            end
-        when /(.*)=(.*)/
-          css_img[$1] = $2
-        else
-          log.warn( "Wiki-Picture with unknown setting #{p}" ) if log.warn?
-      end
-    }
-    
-    bild = []
-    bild = element(:a, {:href=>href }).cr	if href
-    
-    figure	<< before_img	if ! before_img.empty?
-    figure	<< bild
-    figure	<< after_img	if ! after_img.empty?
-
-    if thumb	== true
-      if File.exist?( "#{option[:width]}-#{option[:src]}" )
-        thumb	= "#{option[:width]}-#{option[:src]}"
-      else
-        thumb = picname
-      end									
-    end
-    option[:src] 	= thumb if thumb
-    
-    if /^(http|file|.:\/|\/)/ =~ option[:src]
-      src = option[:src]
-    else
-      src = @inputsource + option[:src]
-    end
-    if /^http/ !~ src and ! File.exist?( (src).sub(%r{file:\/\/}, '') )
-      log.warn( "Wikireg:bild: Picture #{option[:src]} not found (check from #{Dir.pwd} #{inputsource})" ) if log.warn?
-    end
-    if thumb and ! File.exist?( @inputsource + thumb )
-      log.warn( "Wikireg:bild: Thumb #{thumb} not found (check from #{Dir.pwd} #{inputsource})" ) if log.warn?
-    end
-    if href and /^http:/!~ href and ! File.exist?( @inputsource + href )
-      log.warn("Wikireg:bild: reference #{href} not found (check from #{Dir.pwd} #{inputsource})" ) if log.warn?
-    #~ puts Dir.pwd
-    #~ puts @inputsource.inspect
-    #~ puts href
-    #~ puts option[:src]
-    #~ puts '-'*10
-    end
-    
-    bild <<		element(:img, option )
-    figure
-  end	#wiki_bild
-    
-  #
-  #Analyses {{-Textmacros.
-  #If it is redefined, but want to keep the standard method,
-  #then you can call it via super in the else-branch of your case-command.
-  def wiki_macro( key, value, log = @log )
-    if value
-      val = value.split('|')
-    else
-      val	= []
-    end
-    case key
-      when 'maketitle', 'author', 'title', 'date'
-        val = val[0]
-        return [
-          element( key.to_sym,{},val ).cr,
-          ]
-      when 'Commons'
-        return [
-          element(:a, { :href => "http://commons.wikimedia.org/wiki/#{val[0]}" }, "Commons: #{val[0]}" ).cr,
-          ]
-      #~ when 'Wikibooks'
-        #~ #fixme language?
-        #~ return [
-          #~ element(:a, { :href => "http://en.wikibooks.org/wiki/#{val[0]}" }, "Commons: #{val[0]}" ).cr,
-          #~ ]
-      when 'newline'
-        if val.include?('clear')
-          return element(:br, {:clear=>'all'})
-        else
-          return element(:br)
-        end
-      when 'dmoz'
-        def dmoz_analyse(val)
-          if val[1]
-            catname = val[1]
-          else
-            catname = val[0].split(/\//).last.gsub(/_/, ' ')
-          end
-          cat = val[0].sub(%r{http://(www|editors)*.dmoz.org/}, '')
-          cat << '/' if cat[-1,1] != '/'
-          return cat, catname
-        end
-        cat, catname = dmoz_analyse(val)
-        return [
-          'Weitere Links zum Thema ',
-          element(:a, { :href => "http://dmoz.org/#{cat}" }, catname ),
-          ' im Open Directory Project'
-          ]
-      when 'dmozed'
-        #fixme: Umlaute
-        cat, catname = dmoz_analyse(val)
-        return [
-              element(:a, { :href => "http://dmoz.org/#{cat}" }, catname ),
-              ' ',
-              element(:a, { :href => "http://editors.dmoz.org/editors/editcat.cgi?cat=#{cat}" }, 
-                [ '(Edit)'])
-            ]
-      #footnotes|groupid
-      when 'footnotes'
-        #~ value = self.object_id if ! value
-        value = Footnotegroup::DEFAULTGROUPID unless value
-        return @footnotegroups[value]
-      #footnote[groupid]
-      when /footnote(\[(.*)\])*/
-        groupid = $2 ? $2 : Footnotegroup::DEFAULTGROUPID 
-        if ! @footnotegroups[groupid]
-          @footnotegroups[groupid] = Footnotegroup.new(groupid)
-        end
-        return [
-            element(:footnote, { :group => @footnotegroups[groupid] }, self.inline(value, log) ),
-          ]
-      when 'html'
-        return element(:htmlonly, {}, value )
-      when 'rubycode', 'rubyvar'	##Pfui, eval
-        log.warn( "#{self.class}#wiki_macro: eval in line #{@lineno} ('#{value}')" ) if log.warn?
-        #~ return eval(value)
-        return eval(value, binding, 'Wiki', @lineno)	
-      when 'verbatimfile'
-        if File.exist?( val.first )
-          return element(:verbatim,
-                                Hash[*val[1..-1].map{|v| kv = v.split(/=/); [kv[0].to_sym, kv[1]]}.flatten], 
-                                File.read(val.first) )
-        else
-          log.warn( "#{self.class}#wiki_macro: File #{value} missing for verbatimfile in line #{@lineno}" ) if log.warn?
-        end
-      when 'filecontent'
-        if File.exist?( val.first )
-          text = File.read(val.first)
-          #~ text.force_encoding(val[1] ) if val[1]
-          return element(:div,
-                                Hash[*val[1..-1].map{|v| kv = v.split(/=/); [kv[0].to_sym, kv[1]]}.flatten], 
-                                text )
-        else
-          log.error( "#{self.class}#wiki_macro: File #{value} missing for filecontent in line #{@lineno}" ) if log.error?
-        end
-      #A symbol. The corresponding element must be defined.
-      when 'symbol';		return element(value.to_sym)
-      when 'backslash';		return element(:backslash )
-      when '^'; 					return element(:ensuremath, {}, element(:'^' ) )
-      when '>'; 					return element(:gt)
-      when '<'; 					return element(:lt)
-      when '&'; 					return element(:'\&')
-      when 'percent', '%';	return element(:percent )
-      when 'rbrace';			return element(:rbrace )
-      when '_';					return element(:underscore )
-      when ' ';					return element(:relax )
-      when '...';					return element(:ldots )
-      when 'lbrace';			return element(:lbrace )
-      when 'tilde',	'sim';	return element(:sim )
-      when 'math';				return element(:ensuremath,{}, value )
-      #>>>requires privat/affiliate.rb
-      when 'asin'
-        return Amazon.new.asin_in_iframe( value ) if defined? JPC
-        log.error( "#{self.class}#wiki_macro: No privat/docgenerator_affiliate available (line #{@lineno})" ) if log.error?
-        return ''
-      when 'amazon'		#~ {{amazon|produktlinie|keywords}}
-        return Amazon.make_link(val) if defined? JPC
-        log.error( "#{self.class}#wiki_macro: No privat/docgenerator_affiliate available (line #{@lineno})" ) if log.error?
-        return ''
-      when 'jpc'		#~ {{amazon|produktlinie|keywords}}
-        return JPC.make_link(val) if defined? JPC
-        log.error( "#{self.class}#wiki_macro: No privat/docgenerator_affiliate available (line #{@lineno})" ) if log.error?
-        return ''
-      #<<<requires privat/affiliate.rb
-      when 'fixme'
-        log.info( "Fixme: #{value}" ) if log.info?
-        return element(:comment, {}, [ 'Fixme: ', value ] )
-      else
-        log.error( "#{self.class}#wiki_macro Key '#{key}' unknown in line #{@lineno} ('#{value}')" ) if log.error?
-        return value
-    end
-  end
-
-
-  #Little structure for use in  wiki2doc.
-  Wiki_line = Struct.new('Wiki_line', :type, :content, :lineno, :indent, :add_info)
-  #
-  #Parse the text and creates the elements of it.
-  #
-  def wiki2doc( txt, lineoffset = 0, log = @log )
-    (@wiki_inline_replacements	).each{|rule|
-      if ! rule.is_a?(Wikireg)
-        log.fatal( "Wikitext.wiki2doc: rule is no Wikireg #{rule.inspect}" ) if log.fatal?
-      end
-    }
-
-    lines = []
-    @lineno = lineoffset
-    collector		= nil	#collect content for other application
-    collectorline	= nil	#collect content for other application
-    
-    txt.each_line{|line|
-    
-      if line.gsub!( /#~.*/, '')	#delete comments
-        #skip processing, if the line is now empty.
-        #Without this, empty paragraphs can be created.
-        next if line	== "\n"
-      end
-      @lineno += 1
-
-      #if the content should be turned into new variant, do it here.
-      if collector
-        if /^<<</	=~ line	#close the collector
-          lines << Wiki_line.new(:collector, collector, collectorline )
-          collector = nil
-        else
-          collector << line.chomp	#collect content to collector
-        end
-        next
-      end
-      #Preparse. Detect line type and assign it
-      case line.chomp
-      #Example:
-      #>>>structogramm{title;width;height}
-      when /^>>>(.*)\{(.*)\}/
-        args = []
-        ctype = $1
-        args = $2.split(/[;]/)	if $2
-        collector = WikiCollector.create(ctype, args )
-        collectorline	= @lineno
-        if ! collector
-          log.error( "#{__FILE__}##{__LINE__}: Undefined Collector #{ctype.inspect} used. Take Array instead (line #{@lineno})" ) if log.error?
-          collector = []
-        end
-      #===[key]Titel===
-      when /\A(=+)(?:\[(.*?)\])?(.+?)(=+)\s*/	#:h1, :h2, :h3, :h4, :h5, :h6
-      #~ puts $1, $2, $3
-        if $1.size != $4.size
-          log.warn("#{__FILE__}: Heading problem #{$1} doesn't match <#{$3}> #{line.inspect}" ) if log.warn?
-        end
-        #Level starts with ==
-        #	=title= is not supported.
-        h_level = "h#{$1.size - 1}".to_sym
-        lines	<< Wiki_line.new(h_level, self.inline($3, log), @lineno, nil, $2)
-      when /^\s*$/ #empty line
-        lines	<< Wiki_line.new(:p, nil, @lineno)
-      when /^((?:\*|\#)+)(\s*)/	#:li
-        lines	<< Wiki_line.new(:li, self.inline($~.post_match, log), @lineno, $2.size, $1)
-      #Experiment for items in description
-      #~ when /^(:)?((?:\*|\#)+)(\s*)/	#:li
-      #~ puts '>' * 15
-      #~ puts line.inspect
-      #~ puts $1.inspect
-      #~ puts $2.inspect
-      #~ puts $3.inspect
-      #~ puts '<' * 15
-        #~ lines	<< Wiki_line.new(:li, self.inline($~.post_match, log), @lineno, $3.size, $2)
-      when /^;(\s*)/	#:dt
-        lines	<< Wiki_line.new(:dt, self.inline($~.post_match, log), @lineno, $1.size)
-      when /^:(\s*)/	#:dd
-        lastline = lines.last
-        if ! lastline
-          log.warn( "#{__FILE__}: Use ':' at start of wiki text. #{@lineno}" ) if log.warn?
-          lastline = Wiki_line.new()	#Avoid error with method type
-        end
-        #If there was already an indent before, loo back.
-        if lastline.type == :indent
-          #find first line before indent
-          lines.reverse.each{|line|
-            lastline = line
-            break if lastline.type != :indent 
-          }
-        end
-        if [:dt,:dd].include?(lastline.type)
-          lines	<< Wiki_line.new(:dd, self.inline($~.post_match, log), @lineno, $1.size)
-        else			#-> quote
-          lines	<< Wiki_line.new(:quote, self.inline($~.post_match, log), @lineno, $1.size)
-        end
-      when /^----$/	#:hr	#line
-        lines	<< Wiki_line.new(:hr,nil,@lineno)
-      when /^(\s+)/	#:indent	#can be: continuation of a list or a verbatim
-        lines	<< Wiki_line.new(:indent, $~.post_match, @lineno, $1.size)
-      when /^\{\|/	#:tab
-        lines	<< Wiki_line.new(:tabular,$~.post_match,@lineno)
-      when /^\|\}/	#:tabend
-        lines	<< Wiki_line.new(:tabular_end,$~.post_match,@lineno)
-      when /^\|-/	#:tabrow
-        lines	<< Wiki_line.new(:tabular_row,$~.post_match,@lineno)
-      when /^\|(.*\|)*(.*?)\s*$/	#:tabcell
-        par = $1
-        txt = $2
-        #if the text contains macros with | there is a bit confusion, 
-        #what is a parameter of the cell and whats part of the macro.
-        #
-        #Solution:
-        #Define the end of cell parameters with ||
-        if par and par =~ /\|\|/
-          par = $~.pre_match	#parameters only before ||
-          txt	= $~.post_match + txt	#txt all after ||
-        end
-        lines	<< Wiki_line.new(:tabular_cell	,self.inline(txt, log),@lineno,nil,par)
-      else
-        #~ puts "??\tUnknown line (#{__FILE__} line #{__LINE__})"
-        #~ puts "??\tUnknown line: #{line.inspect}"
-        #lines	<< Wiki_line.new(:text, self.inline(line, log), @lineno)
-        #Insert space at end of line, but before \n.
-        #Without, a line break results in HTML-Text without space between flow text
-        lines	<< Wiki_line.new(:text, self.inline("#{line.chomp} \n", log), @lineno)
-      end
-    }	#txt.each |line|
-    
-    if collector
-      log.error( "#{__FILE__}##{__LINE__}: Content Collector not closed (start in line #{collectorline}" ) if log.error?
-    end
-    
-    elements	= []	#main container
-    lists			={}	#lists.
-    lines.each{|line|
-      case	line.type
-      when	:h1, :h2, :h3, :h4, :h5, :h6
-        elements	<< element( line.type,{},line.content).cr
-        if line.add_info
-          elements.last[:id] << line.add_info
-        end
-        #~ elements	<< element( line.type,{},self.inline(line.content, log)).cr
-      when :p	#new paragraph
-        #fixme:  how to detect new paragraph or continuation of item/pre/verbatim
-        if !	elements.last		#Start wiki
-          elements	<< element( :p ).cr
-        elsif	elements.last.is_a?(:p) and elements.last.content.empty?
-          #There is already an empty new par, we can use it.
-        elsif	elements.last.is_a?(Lists::ListEnvironment) 
-          #The next indent decides, if we need a new paragraph or continue in the last item.
-          elements.last.content.last	<< nil	#Add neutral flag for new paragraph
-        else
-          elements	<< element( :p ).cr
-        end
-      when :hr
-          elements	<< element( :hr ).cr
-      when :text
-        if ! elements.last or ! elements.last.is_a?(:p)
-          elements	<< element( :p ).cr
-        end
-        elements.last	<< line.content
-      when :li
-        if ! elements.last.is_a?(Lists::ListEnvironment)	#ListEnvironment can be also a :dl
-            lists				= {}	#delete all lists to start fresh
-        end
-        #~ puts "-----#{line.add_info}\t#{line.content.inspect}\t#{lists.keys.inspect}"
-        listtype	= ''
-        loclist	= {}	#temporary list of lists. will be stored in 'lists'
-        1.upto(line.add_info.size){|level|
-          leveltyp = line.add_info[0..level-1]	#typ of listhirarchie
-          if	lists[leveltyp]	#list already defined
-            loclist[leveltyp]	= lists[leveltyp]
-            loclist[leveltyp]	<< element(:li,{}, line.content).cR if leveltyp == line.add_info
-          else	#create new list
-            case line.add_info[-1,1]
-            when '*'
-              list_type = :ul
-            when '#'
-              list_type = :ol
-            else
-              log.error( "#{self.class}#wiki2doc: Unknown list type #{v}" ) if log.error?
-            end
-            loclist[leveltyp]	= element( list_type ).CR
-            #include first item in list
-            loclist[leveltyp] << li = element(:li,{}).cR	#add first item line
-            li << line.content	if leveltyp == line.add_info	#add content to item line
-            #Include list
-            if level == 1	#Add first list to element-list
-              elements << loclist[leveltyp] 
-            elsif leveltyp == line.add_info	#add new list to previous list
-              loclist[line.add_info[0,level-1]].content.last << loclist[leveltyp]
-            end
-          end
-        }
-        #copy lists and delete all other lists (so we get level changes)
-        lists	= loclist
-      when :dt
-        #~ lists	= {}	#mixture dl and ul/ol not possible actual
-        if ! elements.last.is_a?(:dl)
-          elements	<< element(:dl).cR
-          lists[':'] = elements.last
-        end
-        elements.last	<< element(:dt,{},line.content ).cr
-      when :dd
-        if ! elements.last.is_a?(:dl)
-          log.warn( "#{self.class}#wiki2doc(#{line.lineno}: :dl without :dt	(#{line.content.strip})" ) if log.warn?
-          elements	<< element(:dl).cr
-        end
-        elements.last	<< element(:dd,{},line.content).cr
-      when :quote
-        if ! elements.last.is_a?(:quote)
-          elements	<< element(:quote).cR
-        end
-        if line.content	=~ /^\s*$/	#Empty line
-          elements.last	<< element(:newline).cR
-        else
-          elements.last	<< line.content
-          elements.last	<< ' '
-        end
-      when :indent
-        #~ puts "#{self.class}#wiki2doc(#{line.lineno}: indent: #{line.indent}\t#{line.add_info}\t#{line.content}"				
-        #Check if the indent is part of a list item
-        if elements.last.is_a?(Lists::ListEnvironment)
-          lastlist = lists[lists.keys.max]	#Get last (deepest) list
-          lastitem	= lastlist.content.last
-          
-          case lastitem.content.last
-          when nil	#new paragraph
-            lastitem << element(:p, {}, self.inline(line.content, log)).cr
-          when Element	#add content to last element
-            lastitem.content.last	<< self.inline(line.content, log)
-          else	#add content to item line
-            lastitem	<< ' '
-            lastitem	<< self.inline(line.content, log)
-          end
-        elsif elements.last.is_a?(:dl)
-            lastitem	<< self.inline(line.content, log)
-        elsif !	elements.last.is_a?(:pre)
-          elements	<< element(:pre).cR
-        end				
-        if elements.last.is_a?(:pre)
-          elements.last	<< ('    ' * (line.indent - 1 )) + line.content + "\n"
-        end
-      when :tabular
-          if /longtable/ =~ line.content
-          elements	<< tab = element(:longtable, {:style=>CSS.new()}).CR
-          else
-          elements	<< tab = element(:tabular, {:style=>CSS.new()}).CR
-          end
-          if line.content	#options
-            options = line.content.split('|')
-            options.each{|opt|
-              case opt
-              when /columndescription\s*=\s*(.*)/
-                tab[:columndescription] << $1.gsub(/!/, '|')	#TeX-Format
-              when /columns\s*=\s*(.*)/
-                tab[:columns] << $1.to_i
-              when /border\s*=\s*(.*)/
-                tab[:border] << $1.to_i
-              when /(.*)\s*=\s*(.*)/
-                #~ puts "#{__FILE__}##{__LINE__}: #{opt}"	if ! tab[:style].content.first
-                tab[:style].content.first[$1] = $2
-              else
-                log.warn( "#{self.class}#wiki2doc(#{line.lineno}:	options for table unknown: #{opt}" ) if log.warn?
-              end
-            }
-          end
-          #Add first row
-          elements.last	<< element(:tr, {} ).cr
-      when :tabular_end
-        elements	<< nil
-      when :tabular_row
-        if ! elements.last.is_a?(:tabular)
-          log.warn( "#{self.class}#wiki2doc(#{line.lineno}: Add row to non-tabular" ) if log.warn?
-        end
-        prev_row = elements.last.content.last
-        rowcss = CSS.new()
-        elements.last	<< element(:tr, { :style => rowcss } ).cr
-        if line.content	#options
-          options = line.content.split('|')
-  #~ puts options.inspect
-          options.each{|opt|
-            case opt
-              when 'toprule';		prev_row.toprule
-              when 'midrule';		prev_row.midrule
-              when 'hline';			  prev_row.hline
-              when /(.+)=(.+)/		#CSS?
-                rowcss[$1] = $2
-              when /\A\s*\Z/		#empty option
-              else
-                log.warn( "#{self.class}#wiki2doc(#{line.lineno}): Unknown line option #{opt.inspect}" ) if log.warn?
-            end
-          }
-        end
-      when :tabular_cell
-        cellcss = CSS.new()
-          colspan = 1
-          pos = 'c'
-          if line.add_info	#options
-            #fixme: Tabelle mit verschiedenen Optionen??
-            options = line.add_info.split('|')
-            options.each{|opt|
-              case opt
-              when /colspan\s*=\s*(.*)/
-                colspan = $1.to_i
-              when /pos\s*=\s*(.*)/
-                pos = $1
-              when /(.*?)\s*=\s*(.*)/
-                cellcss[$1] = $2
-              else
-                log.warn( "options for table cell unknown: #{opt}	(line #{line.lineno})" ) if log.warn?
-              end
-            }
-          end
-          row = elements.last.content.last
-          if colspan > 1
-            row	<<	element(:multicolumn, { :colspan => colspan, :style => cellcss, :pos => pos }, line.content).cr
-          else
-            row	<<	element(:td, {	:style => cellcss }, line.content).cr
-          end
-      when :collector
-        #~ if line.content.respond_to? :to_doc
-          #~ elements << line.content.to_element
-        #~ else
-          elements << line.content
-        #~ end
-      else
-        log.error("#{self.class}#wiki2doc(#{line.lineno}): New line type #{line.type.inspect} (#{line.content.inspect})" ) if log.error?
-        elements	<< element( line.type,{},self.inline(line.content, log)).cr
-      end
-    }
-    
-    #Delete empty paragraphs
-    elements.map!{|element|
-      if element.is_a?(:p) and element.content.empty?
-        nil #Delete empty paragraphs
-      else
-        element
-      end
-    }
-    
-    return elements
-  end	#wiki2doc
-  #Translate text for inline tags.
-  def inline( intext, log, subs = @wiki_inline_replacements )
-    return Wikitext.inline( intext, log, subs, self )
-  end
-  #Translate text for inline tags.
-  #
-  #This can also be used from "outside" to translate single lines.
-  #To keep the same environment if called via an object, the object is given in oo.
-  def self.inline( intext, log, subs = WIKI_INLINE_REPLACEMENTS,
-              oo = self)
-    subs.each{|rule|
-      if rule.regex =~ intext
-        if rule.proc.is_a?( Proc )
-          return rule.proc.call($~, oo, log)
-        else
-          return rule.proc
-        end
-      end
-    }
-    return intext
-  end
-  #Obsolete method  -don't use.
-  def toccss()
-    @log.error("Usage of obsolete toccss, use CSS_collection[:toc]")  if @log.error?
-    return CSS_collection[:toc].style.to_html
-  end
-  #Make a table of contents
-  #
-  #Options:
-  #- listtype: :ul or :ol
-  #- addlinks: Set label for each header.
-  def toc( i_options = {} )
-    options = {
-      :listtype	=> :ul,
-      :level		=> 4,
-      :startlevel	=> 1,
-      :addlinks	=> true,
-      :tocclass => 'toc',
-      }.update(i_options)
-    uls = {}
-    uls[options[:startlevel]]	= element(options[:listtype])
-    @source.flatten.each{|line|
-      if /\A(=+)(?:\[(.*?)\])?(.+?)(=+)\s*\z/ =~ line	#:h1, :h2, :h3, :h4, :h5, :h6
-        level		= $1.size.to_i - 1
-        anker	= $2
-        titletext	= $3
-        #Entfernen von Wiki-Links im Titel.
-        titletext.sub!(/\[\..*\s+(.*)\]/, '\1')
-        
-        next if level > options[:level]
-        if level < options[:startlevel]
-          log.warn( "#{self.class}#toc: TOC starts not at #{options[:startlevel]}, but level #{level} defined at #{line}" ) if log.warn?
-          next 
-        end
-        if anker
-          titel = element(:a, {:href=>"##{anker}"}, titletext)
-        elsif options[:addlinks]
-          #Build label for toc
-          toclabel = []
-          1.upto(level){|i|
-            if uls[i]
-              if i == level	#same level - add one for actual element
-                toclabel << uls[i].content.size + 1
-              else	#Previous level - use size
-                toclabel << uls[i].content.size
-              end
-            else	#First element on this level
-              toclabel << 1 
-            end
-          }					
-          #~ puts "toclabel <#{$3}>\t#{toclabel.inspect}\t#{toclabel.join('-')}"
-          titel = element(:a, {:href=>"##{toclabel.join('-')}"}, titletext)
-          line.sub!(/^(=+)/, "\\1[#{toclabel.join('-')}]")
-        else
-          titel = titletext
-        end
-        options[:startlevel].upto(6){|i|
-          #Create 'higher' sections (indicates a problem in the text)
-          if		i < level
-            if ! uls[i]
-              log.warn( "#{self.class}#toc: Sectioning jumps over level #{i} at #{line}" ) if log.warn?
-              uls[i-1].content.last << uls[i] = element(options[:listtype] ).Cr if uls[i-1]
-            end
-            if ! uls[i].content.last
-              uls[i] << element(:li,{}, '' ).cr
-            end
-          elsif	i == level
-            #Create new level if necessary
-            if ! uls[level]
-              uls[level-1].content.last << uls[level] = element(options[:listtype] ).Cr
-            end
-            #Add section title
-            uls[level] << element(:li,{}, titel ).cr
-          else
-            #delete lower levels of previous topic
-            uls[i] = nil
-          end
-        }
-      end
-    }
-    return element(:div, { :class => options[:tocclass] }, uls[options[:startlevel]] ).CR
-  end
-  def footnotes()
-    footnotes	= Footnotegroup[self.object_id]
-    return footnotes
-  end
-end
-
-#Wiki-Collector is a hash with collectors.
-#
-#A WikiCollector give you the possibility to define 
-#'customized exits' in the wiki code.
-#
-#Usage example: see code2structogramm
-class WikiCollector
-  @@variants	= {}
-  #Add a new collector type.
-  #
-  #Each collector must implement the following methods:
-  #-new without parameters.
-  #-<<				get lines of wiki-source
-  #-to_doc	return the result 
-  #See the two examples 
-  #- WikiCollectorHTML
-  #- WikiCollectorFilecontent
-  #
-  def self.add(key, classtype)
-    if @@variants[key] 
-      puts "WikiCollector: Double assignment #{key.inspect}, #{classtype}"
-    end
-    if ! classtype.method_defined?(:'<<')
-      puts "WikiCollector: Collector <#{key.inspect}> doesn't support <<"
-      return false
-    end
-    if ! classtype.method_defined?(:to_doc)
-      puts "WikiCollector: Collector <#{key.inspect}> doesn't support to_doc"
-      return false
-    end
-    @@variants[key] = classtype
-  end
-  #Get an instance of the requested collector.
-  def self.create(key, arguments	= [] )
-    #~ puts "WikiCollector: request #{key.inspect}"
-    if @@variants[key.to_sym]
-      begin
-        return @@variants[key.to_sym].new(*arguments)
-      rescue	ArgumentError
-        puts "WikiCollector: Collector <#{key.inspect}> get wrong parameters"
-        return false
-      end
-    else
-      puts "WikiCollector: Collector <#{key}> not found (available: #{@@variants.keys.inspect})"
-      return nil
-    end
-  end
-end	#WikiCollector	
-=begin rdoc
-A little collector of "Plain-HTML".
-
-Can be called in a Wiki with:
- >>>html{}
-   here you can add plain HTML
- <<<
-=end
-class WikiCollectorHTML < Element
-  #Return the content 'as is', but only for HTML
-  def to_doc( target, options = {}  )
-    case target
-      when :html
-        @content.join("\n")
-      else
-        ''
-      end
-    #~ return element(:onlyhtml,{},@htmlcode).restrict_to(:html).to_doc(target)
-  end
-  #~ def to_html()
-    #~ return @htmlcode
-  #~ end
-  #~ def to_latex(); ''; 	end
-  #~ def to_wiki(); ''; 	end
-  #~ def to_text(); ''; 	end
-end	
-WikiCollector.add(:html, WikiCollectorHTML )
-end #module Wikimedia
-end #module Docgenerator
-
-
-if __FILE__ == $0
-  
-puts 'Use the unit test for complete test'
-
-puts Wikitext.help
-puts Wikitext.help(:img)
-puts Wikitext.help(:tab)
-
-    #~ wiki = Wikitext.new(:content => <<wiki
-#~ There are normal footnotes{{footnote|Like this one}}. But:
-#~ Here is a footnote in group 1{{footnote[group1]some remarks}}, and
-#~ a second footnote{{footnote[group1]more remarks}}.
-#~ In another group{{footnote[group2]Each group gets a name}}, we can define further remarks.
-
-#~ ----
-#~ Normal Footnotes:
-#~ {{footnotes}}    
-#~ ----
-#~ Footnote group 1:
-#~ {{footnotes|group1}}    
-#~ ----
-#~ Footnote group 2:
-#~ {{footnotes|group2}}    
-#~ wiki
-    #~ )
-    wiki = Wikitext.new(:content => <<wiki
-vorher
-
-nachher
-nachher2
-
-==test==
-drei
-wiki
-)
-puts '---------------------'
-
-
-#~ puts wiki.toc.inspect
-#~ puts wiki.toc.to_html
-#~ puts wiki.toc.to_wiki
-#~ puts '--------HTML-------------'
-puts wiki.to_html
-#~ puts '--------HTML-------------'
-#~ puts wiki.to_html
-#~ puts '--------LaTeX-------------'
-#~ puts wiki.to_latex
-#~ puts '--------Wiki-------------'
-#~ puts wiki.to_wiki
-#~ puts '--------Text-------------'
-#~ puts wiki.to_text
-
-doc = Document.new()
-doc.body << wiki
-doc.save('test.html')
-end
-
-
-__END__