docgenerator 1.2.1 → 2.0.0

data/lib/docgenerator/compatibility_v1.rb

@@ -0,0 +1,249 @@
+#encoding: utf-8
+=begin rdoc
+Collection of some "old" coding.
+
+You can load this code to get:
+* Element.create  - a dynamic command to define a new Element
+=end
+
+Docgenerator::DOCGENERATOR_LOGGER.warn("Load compatibility_v1.rb")
+
+# 
+module Docgenerator 
+=begin rdoc
+This class defines possible elements of a document.
+For each type of elements a class is defined.
+The definition can be done explicite or generic with Element.create.
+
+All types of elements are stored in a hash, 
+the elements can be created via the method Element.get (or element() ).
+=end
+class Element
+=begin rdoc
+#Set Element tracing on/off. 
+
+Obsolete. Please use
+  Docgenerator.trace_on
+=end
+  def self.trace=( val )
+    Docgenerator.trace_on
+  end
+=begin rdoc
+Return all id's of the class.
+@@ids is expanded in Element.add.
+
+Replaced by Element.element_ids.
+=end
+  def ids( )
+    myids = []
+    @@ids.each{|k,v| myids << k if v == self.class and k.class != Class }
+    return myids
+  end
+  #Prepares an overview on all Elements.
+  #Can be used for some debugging.
+  def self.overview( list = @@ids.values.uniq )
+    if ! list.kind_of?(Array)
+      list = [ list ]
+    end
+    result = '=' * 10 + "\nElement overview:"
+    list.each{ |k|
+      result += "\n#{k}\n"
+      result += "\tId's:\t\t"
+      result += k.new.element_ids.join("\n\t\t\t")
+      result += "\n\tAttributes:\t"
+      result += "can contain "
+      result += "no " if ! k.new.content?
+      result += "content\n\t\t\t"
+      self.class.attributes.each{ |k2,v|
+        result += "#{k2}:\t#{v.inspect}\n\t\t\t"
+      }
+    }
+    return result
+  end
+
+=begin rdoc
+Add a new element class or assign another name (synonym) for a class.
+The initial call is made by Element.inherited.
+
+Element.add( [:element],  Element )
+
+Replaced by meta method Element.add_id
+=end
+  def  self.add( idlist, elementClass )
+    #~ DOCGENERATOR_LOGGER.warn("Element.add called -> to be replaced") if DOCGENERATOR_LOGGER.warn?
+    if ! elementClass.new.kind_of?( Element )
+      raise "Element.add get no Element-class #{elementClass}"
+    end
+    idlist = [ idlist ] if ! idlist.kind_of?( Array )
+    raise "Empty idlist for #{elementClass}" if idlist.empty?
+    
+    idlist.each{|id|
+      elementClass.add_id(id)
+    }
+  end
+
+=begin rdoc
+Generic creation of a new class to define a new element.
+-  name must be defined.
+-  attr is a hash with all attributes.
+  For details see Element.add_attributes
+-  content is a flag, which defines if the element contains "content".
+  Valid values are:
+  -  true:  content available and necessary (e.g. <p>)
+  -  :empty_ok: content available, but not necessary (e.g. <td> or iframe)
+  -  false:  no content, no endtag, but tag closed with / (example: <br />)
+  -  nil:    no content, no endtag, no closing  (example: <br>)
+-  output contains a hash with logic, how to handle the output.
+  -:htmltag  Tag for html-output.
+  -:latex  Template for LaTeX-output
+  -:html    Template for HTML-output
+
+This code is obsolete. 
+Please use Element.create_convert_to_code to get a template to replace your Element#create.
+=end
+  def  self.create( name, attr = {}, content = false, output = {} )
+    DOCGENERATOR_LOGGER.warn("Element.create called -> to be replaced") if DOCGENERATOR_LOGGER.warn?
+    create_convert_to_code( [name].flatten, attr, content, output ) if DOCGENERATOR_LOGGER.warn?
+    #First some checks
+    if ! attr.kind_of?( Hash )
+      raise "Type error Element.create: Expected Hash, get #{attr.class}"
+    end
+    #Generic class creation
+    elementclass = Class.new( Element )
+    #Add the id of the new class to central collection.
+    Element.add( name, elementclass )
+
+    #Set a flag, if the class can contain 'content'.
+    #-true:  content available and necessary (e.g. <p>)
+    #-:empty_ok: content available, but not necessary (e.g. <td>)
+    #-false:  no content, no endtag, but tag closed with / (example: <br />)
+    #-nil:    no content, no endtag, no closing  (example: <br>)
+    elementclass.class_eval( %Q|
+      def content?()
+        return #{content.inspect}
+      end|)
+    
+    output.each{ |k,v|
+      case k
+      when :latex
+        elementclass.add_output( :latex,  v )
+      when :context
+        elementclass.add_output( :context,  v )
+      when :html
+        elementclass.add_output( :html,  v )
+      when :text
+        elementclass.add_output( :text,  v )
+      when :wiki
+        elementclass.add_output( :wiki,  v )
+      when :creole
+        elementclass.add_output( :creole,  v )
+      when :htmltag
+        if v
+          elementclass.class_eval( "def htmltag()\n'#{v}'\nend" )
+        else
+          elementclass.class_eval( "def htmltag()\nnil\nend" )
+        end
+      else
+        puts "#{__FILE__}##{__LINE__}: Unknown format #{k} for #{name}"
+      end
+    }
+    elementclass.add_attributes( attr )
+    #Return the class.
+    return elementclass
+  end #Element.create
+=begin rdoc
+Transformer of old Element.create-Logic to metaprogramming.
+
+Requires a manual postprocess to define Attributes correct.
+
+=end
+  def  self.create_convert_to_code( name, attr = {}, content = false, output = {} )
+    #First some checks
+    if ! attr.kind_of?( Hash )
+      raise "Type error Element.create: Expected Hash, get #{attr.class}"
+    end
+    #Build code for class creation
+    code = "\n"
+    code << <<comment
+=begin rdoc
+Define Element #{name.map{|x|x.inspect}.join(', ')}
+
+Create an instance with
+#{name.map{|x|
+      "  element( #{x.inspect}, [ attributes, [content]] )"
+    }.join("\n")
+}
+or
+  #{name.first.capitalize}.new( [ attributes, [content]] )
+comment
+    if attr.size == 0
+      code << "Attributes are not defined for this element.\n"
+    else
+      code << "Attributes may be:\n"
+    end
+    attr.each{|key, att|
+      code << "* #{key.inspect}: \n"  #fixme #{att.new.allowed_values.inspect}
+    }
+    code << "=end\n"
+    code << "class #{name.first.capitalize} < Element\n"
+    name[1..-1].each{|n|
+      code << "  add_id #{n.inspect}\n"
+    }
+    if ! content
+      code << "  has_no_content #{content.inspect}\n"
+    end
+    if ( HTML_ATTR_CORE.keys & attr.keys ) == HTML_ATTR_CORE.keys
+      code << "  add_attributes HTML_ATTR_CORE\n"      
+    end
+    if ( HTML_ATTR_I18N.keys & attr.keys ) == HTML_ATTR_I18N.keys
+      code << "  add_attributes HTML_ATTR_I18N\n"      
+    end    
+    if ( HTML_ATTR_EVENTS.keys & attr.keys ) == HTML_ATTR_EVENTS.keys
+      code << "  add_attributes HTML_ATTR_EVENTS\n"      
+    end    
+    if attr.has_value?(ATTR_LANG)
+      code << "  add_attribute #{attr.key(ATTR_LANG).inspect}, ATTR_LANG\n"      
+    end    
+    if attr.has_value?(HTML_ATTR_ALIGN)
+      code << "  add_attribute #{attr.key(HTML_ATTR_ALIGN).inspect}, HTML_ATTR_ALIGN\n"      
+    end    
+    if attr.has_value?(HTML_ATTR_VALIGN)
+      code << "  add_attribute #{attr.key(HTML_ATTR_VALIGN).inspect}, HTML_ATTR_VALIGN\n"      
+    end    
+    (   attr.keys - HTML_ATTR_CORE.keys - HTML_ATTR_I18N.keys - HTML_ATTR_EVENTS.keys
+    ).each{|key|
+      code << "  add_attribute #{key.inspect}, ?? )\n"  #?? - Definition aus Vorlag holen
+    }
+    output.each{ |k,v|
+      case k
+      when :latex
+        code << "  add_latex_output '#{v}'\n"
+      when :context
+        code << "  add_context_output '#{v}'\n"
+      when :html
+        code << "  add_html_output '#{v}'\n"
+      when :text
+        code << "  add_text_output '#{v}'\n"
+      when :wiki
+        code << "  add_wiki_output '#{v}'\n"
+      when :creole
+        code << "  add_creole_output '#{v}'\n"
+      when :htmltag
+        if v
+          code << "  add_html_tag '#{v}'\n"
+        else
+          #~ code << "  def htmltag(); nil; end\n" 
+        end
+      else
+        puts "#{__FILE__}##{__LINE__}: Unknown format #{k} for #{name}"
+      end
+    }
+    code << "end ##{name.first.capitalize}\n"
+    puts code 
+    #~ class_eval(code)
+    #Return the class.
+    return code
+  end
+
+end #Element
+end

data/lib/docgenerator/css.rb

@@ -1,25 +1,29 @@
-if __FILE__ == $0
-	require 'docgenerator' 
-end
+=begin rdoc
+Define classes to use cascading style sheets (CSS) for HTML-documents.
+=end
+
+#
+module Docgenerator   
+=begin rdoc
+Define Element ':style'
 
-#~ Element.create( [:style], {
-		#~ :type		=> Attribute.create( [ :html, :required ], "text/css", 1 ),
-	#~ }, true,
-	#~ {	:htmltag	=> 'style',
-		#~ :html	=> "\n<style type=\"text/css\">\n" + '#{@content}' + "</style>\n",
-		#~ :latex	=> nil
-	#~ } )
+Create an instance with
+  element( :style, [ attributes, [content]] )
+  
+  Style.new( [ attributes, [content]] )
 
+Only for HTML.
+=end
 class Style < Element
-	Element.add( [:style],  self)
 	#~ add_attributes( HTML_ATTR_ALL ) 
-	add_output( :latex,	'')	
-	add_output( :text,	'')	
-	add_output( :wiki,	'')	
+	add_latex_output ''
+	add_text_output ''
+	add_wiki_output ''
+	add_creole_output ''
 	#Prepare HTML-Output for Style-Tag.
 	#The values can be overwritten, if different CSS-Elements are inside.
 	def to_html( options = {} )
-    o = Docgenerator_logger.set_option_defaults(options)
+    o = set_option_defaults(options)
     o[:log].debug("Enter style.to_html") if o[:log].debug?
 		res =	""
 		res <<	"\n" if @crbefore
@@ -31,30 +35,36 @@ class Style < Element
 		res << "\n" if @crafter
 		return res
 	end
-end
+end #Style
 
 CSS_COLORS = [ /rgb\((\d+%?,?){3,3}\)/, 
 			#rgb(R,G,B), rgb(%,%,%) oder #XXXXXX
 			#/gray\d{1,3}/
-			'black','gray','maroon','red', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'purple', 'fuchsia', 'teal', 'aqua', 'silver', 'white',
+			'black','gray', 'grey', 'maroon','red', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'purple', 'fuchsia', 'teal', 'aqua', 'silver', 'white',
 			#Netscape-Farbnamen (120 zus�tzliche Farben)
 			#Falsche Darstellungen, siehe http://www.rzuser.uni-heidelberg.de/~x22/ht/farben2.html
-			'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightsteelblue', 'lightyellow',
+			'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgreen', 
+      'lightgrey', 'lightgray', 'lightslategray', 'lightslategrey', #yes, both are defined
+      'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightsteelblue', 'lightyellow',
 			'greenyellow', 'palegreen', 'darkgreen',
 			'darkred', 'firebrick',
 			'salmon',
 		]
 CSS_BORDER = [ 'none', 'hidden', 'dotted', 'dashed', 'solid', 'double', 'groove', 'ridge', 'inset', 'outset' ]
 CSS_WIDTH =	[ /\d*(cm|mm|px|em|%)/, 'thin', 'medium', 'thick' ]
-#Class to collect css-settings for a Element.
-#This values can be used inline (style-Attribute) and inside style>-Tags
+
+=begin rdoc
+Class to collect css-settings for a Element.
+
+This values can be used inline (style-Attribute) and inside style>-Tags
+=end
 class CSS
 	#List of all allowed values.
 	#The first value is a regular expression, coninued by fixed values.
 	@@values = {
-		'font-size'	=> [ /\A\d+(pt|px|em)/, 'xx-small', 'x-small', 'small', 'medium', 'large','x-large','xx-large','smaller','larger' ],
+		'font-size'	=> [ 'xx-small', 'x-small', 'small', 'medium', 'large','x-large','xx-large','smaller','larger', /\A\d+(pt|px|em)/ ],
 		'font-style'	=> ['italic', 'oblique', 'normal'],
-		'font-weight'	=> ['bold' ],	#fixme complete it
+		'font-weight'	=> ['bold', 'bolder', 'lighter', 'normal', /\A\d00\Z/ ],
 		'color'		=> CSS_COLORS,
 		'background-color'	=> CSS_COLORS,
 		'visibility'	=> ['hidden', 'visible' ],
@@ -124,7 +134,8 @@ class CSS
 	}
 	def initialize( values ={} )
 		@values	= {}
-    @log = values[:log] ? values[:log]  : DOCGENERATOR_LOGGER  #fixme
+    #~ set_option_defaults(values) #guarantee :log
+    @log = values[:log] || DOCGENERATOR_DEFAULT_LOGGER
     values.delete(:log)
     
 		values.each{|k,v|
@@ -132,7 +143,9 @@ class CSS
 		}
 		@cr = nil
 	end
-	#Make key unique. convert symbol to String...
+=begin rdoc
+Make key unique. convert symbol to String...
+=end
 	def generalize_key( k )
 		key = nil
 		if k.is_a?(Symbol)
@@ -145,11 +158,13 @@ class CSS
 	def []( k )
 		return @values[generalize_key( k )]
 	end
-	#Add a setting.
-	#
-	#If an existing value is overwritten, you get a warning.
-	#To replace a value, use
-	#	css[key].replace( value )	(But the you have no check)
+=begin rdoc
+Add a setting.
+
+If an existing value is overwritten, you get a warning.
+To replace a value, use
+	css[key].replace( value )	(But the you have no check)
+=end
 	def []=( k, v )
 		key = generalize_key( k )
 		if @values[key]
@@ -165,7 +180,9 @@ class CSS
 		
 		@values[key] = v
 	end
-	#returns the values for a direct css in the style-attribute for a HTML-tag.
+=begin rdoc
+Returns the values for a direct css in the style-attribute for a HTML-tag.
+=end
 	def to_html(options={})
     o = {
       :map => "%s;",
@@ -175,7 +192,9 @@ class CSS
 	def to_s()
 		return self.to_html
 	end
-	#Returns a tab with the textes for each characteristic.
+=begin rdoc
+Returns a tab with the textes for each characteristic.
+=end
 	def to_tab()
 		s = []
 		@values.sort.each{|k,v|
@@ -183,7 +202,9 @@ class CSS
 		}
 		return s
 	end
-end
+end #CSS
+
+end #module Docgenerator
 
 if __FILE__ == $0
 #~ DOCGENERATOR_LOGGER.level = Log4r::DEBUG

data/lib/docgenerator/document.rb

@@ -1,4 +1,27 @@
 #encoding: utf-8
+
+#
+module Docgenerator
+=begin rdoc
+Extension for Log4r::Logger (#INFO)
+=end
+module Logger_INFO
+  #Print INFO-message, if logging level is WARN
+  def INFO?()
+    Log4r::WARN >= self.level
+  end #INFO?()
+=begin rdoc
+INFO is a *important* information.
+It's like a warning, but outputted as information.
+=end
+  def INFO(*args)
+    return unless INFO?
+    level = self.level  #remember previous level
+    self.level = Log4r::INFO  #temporary level change
+    self.info(*args)
+    self.level = level
+  end
+end
 =begin rdoc
 Container for a document.
 
@@ -29,12 +52,14 @@ class Document
     end
  end
     
-  #Create a new document.
-  #There are different document templates supported. 
-  #The templates refer to the corresponding TeX-classes.
-  #-  article
-  #-  report
-  #-  book
+=begin rdoc
+Create a new document.
+There are different document templates supported. 
+The templates refer to the corresponding TeX-classes.
+-  article
+-  report
+-  book
+=end
   def initialize( settings = {} )
     #Set template defaults
     @template  = {
@@ -60,6 +85,8 @@ class Document
       @log = Log4r::Logger.new( 'Doc', Log4r::WARN )
       @log.outputters = Log4r::StdoutOutputter.new('log_xxx')
     end
+    @log.extend(Logger_INFO) unless @log.respond_to?(:INFO)
+    
     @meta  = {}  #some meta-Tags for HTML
     @body  = element( :body, { :log => @log } )
     @head  = element( :head, { :log => @log } )
@@ -137,13 +164,15 @@ class Document
   #Define, if there should be a message in case of:
   #-:change  Document changed
   #-:nochange  Document existed, but is unchanged
-  #Give an array with the wanted values.
+  #Please provide an array with the wanted values.
   def Document.givemessage=( value = [:change, :nochange] )
     @@givemessage = value
   end
   @@givemessage = [:change, :nochange]
   def Document.givemessage();  @@givemessage;  end
-  #Add a meta-tag-information for the HTML-Output.
+=begin rdoc  
+Add a meta-tag-information for the HTML-Output.
+=end
   def meta( key, content )
     key  = key.to_s
     
@@ -219,12 +248,13 @@ class Document
     toccnt  = 0
     toc_ids = [ :chapter, :section,:subsection, :subsubsection, :paragraph, :subparagraph,:minisec]
     @body.content.flatten.each{|el|
-if ! el.respond_to?(:ids)
-  #e.g. Wikitext. Has a to_doc, but doesn't react on flatten.
-  opt[:log].error("Toc: Element ohne :ids #{el.class}") if opt[:log].error?
-  next
-end  
-      depth = toc_ids.index((el.ids & toc_ids)[0])
+      if ! el.respond_to?(:element_ids)
+        #e.g. Wikitext. Has a to_doc, but doesn't react on flatten.
+        opt[:log].error("Toc: Element without ids #{el.class}") if opt[:log].error?
+        next
+      end  
+      #Get section depth. Determine it via the position inside toc_ids.
+      depth = toc_ids.index((el.element_ids & toc_ids)[0])
       next if ! depth #Element is no header
       
       opt[:log].debug("Toc: Found entry on level #{depth}: <#{el.content}>") if opt[:log].debug?
@@ -271,11 +301,14 @@ end
 =begin rdoc
 Save the file.
 The type of the document is determined by the file extensison.
+
 Supported document types are:
--  tex
--  html
--  (wiki)
+-  tex (*.tex)
+-  context (*.mkiv)
+-  html (*.htm[l])
+-  (wiki wikimedia/creole)
 -  (text)
+
 Depending on a template, different results are created.
 
 There is a comparison between an already existing file and the new one.
@@ -288,7 +321,7 @@ Valid options:
    allows to overwrite 
 - target
    In most cases this is defined by the extension.
-   Main usage will be for ConTeXt (shares the extension with LaTeX)
+   This attribute allows to set :context for tex-files.
 - :additional_options 
    List of options.
    If you want to give parameters to specific 'Element'-objects you can define the keys here.
@@ -329,10 +362,11 @@ Valid options:
       return false
     end
     
+    
     prefix = [   nil, 
         "Build by\t#{__FILE__}",
         "Dir:\t\t#{Dir.pwd}",
-        "Creator:\t#{$0}",
+        "Creator:\tDocgenerator #{Docgenerator::VERSION} - http://rubygems.org/gems/docgenerator",
         "Target:\t\t#{filename}",
         "#{Time.now.strftime('%Y/%m/%d %H:%M:%S')}",
         nil,
@@ -346,7 +380,7 @@ Valid options:
       target  = :latex
       #Take context if requested.
       target  = :context if options[:target] == :context
-    when /miv/i #Mark IV
+    when /mk(ii|iv)/i #Mark II and IV
       target  = :context
     when /htm[l]?/i
       target  = :html
@@ -412,19 +446,21 @@ Valid options:
     if new != old
       new.sub!( '<<prefix>>',  prefix)
       if ( File.exist?( filename ) and ! options[:overwrite] )
-        puts "Datei #{filename} exist already \nContinue [yn]?"
-        answer = $stdin.gets()  if $stdin.tty? #only when called in a shell
-        if ! ( answer =~ /[YyjJ].*/ )
-          puts "Bye"
-          @log.info( "Overwrite #{filename} after confirmation" ) if @log.info?
-          return false
+        @log.warn("Datei #{filename} exist already.") if @log.warn?
+        if $stdin.tty? #only when called in a shell
+          puts "Datei #{filename} exist already \nContinue [yn]?"
+          answer = $stdin.gets()  
+          if ! ( answer =~ /[YyjJ].*/ )
+            puts "Bye"
+            return false
+          end
         end
+        @log.info( "Overwrite #{filename} after confirmation" ) if @log.info?
       end  
       File.open( filename, 'w', :external_encoding => new.encoding ){|f|
         f << new
       }
-      @log.info( "Save changed\t#{filename}") if @log.info?
-      puts "Save changed\t#{filename}"  if @@givemessage.include?(:change)
+      @log.INFO( "Save changed\t#{filename}") if @log.INFO?
       #Save copy of old version (attention, *.bak makes no control on tex or html)
       #~ f = File.new( filename.sub( extension, 'bak'), 'w' )
       #~ f << old
@@ -432,38 +468,48 @@ Valid options:
       Document.runtex( filename, options[:runtex] ) if options[:runtex] and [:latex, :context].include?(target)
       return true
     elsif old
-      @log.info("Unchanged\t#{filename}") if @log.info?
-      puts "Unchanged\t#{filename}" if @@givemessage.include?(:nochange)
+      @log.INFO("Unchanged\t#{filename}") if @log.INFO?
       return false
     end    
   end #Document#save
 =begin rdoc  
-Build the content for the target format.
+Build the content of a document for the target format.
+
 Supported target formats are:
 -  :latex
 -  :html
 -  :text
+-  :wiki
+-  :creole
+
+Options are passed in a Hash:
+* :log [required]: a logger
+* :template [required]: a Docgenerator::DocumentTemplate-instance
+* :filename [recommended]: used in logging informations 
+* :replacements [optional]: Hash with regexp/result pairs to modify the output.
+
 If the standard templates are used, there is a <<prefix>> left 
 (used from Document#save to include some additional information).
 
+You may use a String as dummy template.
+
 If the method is called directly to prepare document snipplets, you can use:
-  puts Document#to_doc( :latex, '<<body>>')
+  doc = Document.new()
+  # ... fill doc
+  puts doc.to_doc( :latex, 
+                    :log  => Log4r::Logger.new('testlog'),
+                    :template=> '<<body>>',
+                    #~ :template=> doc.template[:latex],
+                    :filename => 'dummy',
+                    #~ :replacements => { /xxx/ => 'cc' }
+                  )
 
-It is possible to give pairs of RegExp (pattern) and a replacement to the result.
 =end
   def to_doc( target, options )
-    #~ o = Docgenerator_logger.set_option_defaults(options)
+    #~ o = set_option_defaults(options)
     options[:log].info( "Build document for #{target.inspect}" ) if options[:log].info?
-    template  = options[:template]
-    if ! template
-      options[:log].error( "No template available to create #{target.inspect} #{self.class}" ) if options[:log].error?
-      return ''
-    end
-    replacements = options[:replacements] || {}
-    options[:log].warn( "No filename given " ) if options[:log].warn? and ! options[:filename]
 
-    new = template.template
-    encoding = template.template.encoding
+    #check target
     case target
     when :latex
       add_option( @language )
@@ -472,37 +518,52 @@ It is possible to give pairs of RegExp (pattern) and a replacement to the result
     when :html
     when :text
     when :wiki
+      options[:log].warn( "Support for #{target} stopped" ) if options[:log].warn?
     when :creole
       options[:log].warn( "Support for #{target} under development" ) if options[:log].warn?
     else
       options[:log].fatal( "Unknown target #{target} for #{options[:filename]}" ) if options[:log].fatal?
       return ''
     end
+    
+    #set template to variable new
+    case options[:template]
+      when DocumentTemplate
+        new = options[:template].template
+      when String
+        new = options[:template]
+      else
+        options[:log].error( "No template available to create #{target.inspect} #{self.class}" ) if options[:log].error?
+        return ''
+    end
     if ! new.kind_of?( String )
-      options[:log].error( "New is wrong type: #{new.inspect}") if options[:log].error?
+      options[:log].fatal( "New is wrong type: #{new.inspect}") if options[:log].fatal?
+      return ''
     end
+    encoding = new.encoding
+
+    #Set replacements
+    replacements = options[:replacements] || {}
 
     options[:document] = self
+    
     @head  << self.docinfo()
     options[:log].debug( "Build header data") if options[:log].debug?
     new.sub!( '<<head>>',  @head.to_doc(target, options ).encode(encoding))
+    
     options[:log].debug( "Build body") if options[:log].debug?
     new.sub!( '<<body>>',  @body.to_doc(target, options).encode(encoding))
-    new.sub!( '<<classoptions>>',  @options.uniq.join(',').encode(encoding))
     
+    new.sub!( '<<classoptions>>',  @options.uniq.join(',').encode(encoding))
     
+    #manipulate result
     replacements.each{|pattern, replace |
       options[:log].info("Replace text #{pattern.source} with #{replace}" ) if options[:log].info?
       new.gsub!( pattern, replace ) if replace
     }
     return new
   end  #Document#to_doc
-  #Return the actual target type.
-  #Needed by Element#to_s to decide which method is used to prepare the output.
-  #
-  #The usage of this technic makes similar processing unposibble.
-  #Set in Document#save.
-  attr_reader :target
+
 =begin rdoc
 Call rake4latex to translate the file.
 =end
@@ -534,8 +595,6 @@ warning
         options = [:touch, :statistic, :clean]
       rescue LoadError
         puts "Sorry, I didn't find the rake4latex to translate #{filename}"
-        puts "I try to use the old 'RunTeX'"
-        runtex_old( filename, options[:format] )
         return false
       end unless defined? Rake4LaTeX
     end # ! defined? Rake4LaTeX
@@ -567,10 +626,14 @@ warning
 Make some basic replacements for TeX.
 There is no sense to use it with HTML.
 
-Better solution: Puts String into \path, \verb or similar.
+Better solution: 
+* use elements from Docgenerator::Characters
+* Use unicode in TeX-Document.
+* Put string into \path, \verb or similar.
 =end
   def Document.texify( input )
     out = input.strip
+    
     #~ out.gsub!( /&/, '\\\&')  #geht schief. erzeugt <<body>>...
     #~ out.gsub!( /\\/, '\\\\')
     out.gsub!( /%/, '\%')
@@ -578,11 +641,11 @@ Better solution: Puts String into \path, \verb or similar.
     out.gsub!( /&/, '\\\\&')
     out.gsub!( /_/, '\_')
     out.gsub!( /#/, '\#')
-    out.gsub!( /€/, '\euro ')
+    #~ out.gsub!( /€/, '\euro ')  #regexp is in utf-8 -- may make problems.
     return out
   end
   def inspect()
     return "#<Document '#{@title}'>"
-    #~ return "#<Document '#{@title} #{@body.inspect}>'"
   end
 end  #Document
+end #module Docgenerator