docgenerator 2.0.0 → 2.1.0

data/lib/docgenerator/element.rb

@@ -16,12 +16,12 @@ Often there is the problem, that you get an error when you write the element.
 But the error is done, when the element is created.
 When you redefine ELEMENTS_TRACE, some tracing information are stored during creation.
 =end
-class Element
-  include Docgenerator  #get VERSION
+  class Element
+    include Docgenerator  #get VERSION
 
-  SUPPORTED_TARGETS = [ :latex, :html, :wiki, :text, :debug ]
-  SUPPORTED_TARGETS << :context #Added later
-  SUPPORTED_TARGETS << :creole #Added later
+    SUPPORTED_TARGETS = [ :latex, :html, :wiki, :text, :debug ]
+    SUPPORTED_TARGETS << :context #Added later
+    SUPPORTED_TARGETS << :creole #Added later
 
 =begin rdoc
 Defines an element.
@@ -36,64 +36,64 @@ There are two ways to add values:
 :log is the default attribute for the logger.
 In Elementto_doc you can give another logger!
 =end
-  def initialize( attr={}, content = nil)
-    #@attr is a hash containing the values for each attribute.
-    @attr = Hash.new(  )
-    #Attention! in to_doc another logger may be given.
-    @log  = attr[:log] || DOCGENERATOR_DEFAULT_LOGGER
-    attr.delete(:log) #remove from attr-interface
-    #attr alias
-    @attr_alias = Hash.new(  )
-    if self.content?()
-      @content  = []
-    else
-      @content  = nil
-    end
-    @crbefore  = false  #make \n before element
-    @crmid  = false  #make \n before and after opening/closing html-tag
-    @crafter  = false  #make \n after element
-    #List of targets, where the element can be used.
-    #Details see method restrict_to()
-    #Default: allsupported targets
-    @targets  = SUPPORTED_TARGETS.dup
-    @suppressed_targets = []
-    
-    #Initialize the attribute hash.
-    self.class.attributes.each{ |k,a|
-      #type check on Attribute does not work .
-      if a.kind_of?( Symbol )
-        #Filled in the second run
-        #~ @attr[k] = @attr[a]
-      elsif a  #.kind_of?( Attribute )
-        @attr[k] = a.new( k, self )
-      else
-        @attr[k] = Attribute.create().new( k, self )
-      end
-    }
-    #Assign Alias-Attributes
-    self.class.attributes.each{ |k,a|
-      next if !a.kind_of?( Symbol )
-      if @attr[a]
-        @attr_alias[k] = @attr[a]
+    def initialize( attr={}, content = nil)
+      #@attr is a hash containing the values for each attribute.
+      @attr = Hash.new(  )
+      #Attention! in to_doc another logger may be given.
+      @log  = attr[:log] || DOCGENERATOR_DEFAULT_LOGGER
+      attr.delete(:log) #remove from attr-interface
+      #attr alias
+      @attr_alias = Hash.new(  )
+      if self.content?()
+        @content  = []
       else
-        @log.warn("Undefined Alias-Attribute #{k}") if @log.warn?
-        @attr[k] = Attribute.create().new( k, self )
+        @content  = nil
       end
-    }
-    attr.each{ |k,v|
-      if @attr[k]
-        @attr[k] << v
-      elsif @attr_alias[k]
-        @attr_alias[k] << v
-      else
-        @log.warn("Usage of unknown attribute '#{k}' in #{self.inspect}") if @log.warn?
-        #~ @log.debug(caller) if @log.debug?
-      end
-    }
-    #store info, where the element was created 
-    @creation_caller = prepare_tracing_info() if Docgenerator.trace_on?
-    self << content if  content 
-  end
+      @crbefore  = false  #make \n before element
+      @crmid  = false  #make \n before and after opening/closing html-tag
+      @crafter  = false  #make \n after element
+      #List of targets, where the element can be used.
+      #Details see method restrict_to()
+      #Default: allsupported targets
+      @targets  = SUPPORTED_TARGETS.dup
+      @suppressed_targets = []
+      
+      #Initialize the attribute hash.
+      self.class.attributes.each{ |k,a|
+        #type check on Attribute does not work .
+        if a.kind_of?( Symbol )
+          #Filled in the second run
+          #~ @attr[k] = @attr[a]
+        elsif a  #.kind_of?( Attribute )
+          @attr[k] = a.new( k, self )
+        else
+          @attr[k] = Attribute.create().new( k, self )
+        end
+      }
+      #Assign Alias-Attributes
+      self.class.attributes.each{ |k,a|
+        next if !a.kind_of?( Symbol )
+        if @attr[a]
+          @attr_alias[k] = @attr[a]
+        else
+          @log.warn("Undefined Alias-Attribute #{k}") if @log.warn?
+          @attr[k] = Attribute.create().new( k, self )
+        end
+      }
+      attr.each{ |k,v|
+        if @attr[k]
+          @attr[k] << v
+        elsif @attr_alias[k]
+          @attr_alias[k] << v
+        else
+          @log.warn("Usage of unknown attribute '#{k}' in #{self.inspect}") if @log.warn?
+          #~ @log.debug(caller) if @log.debug?
+        end
+      }
+      #store info, where the element was created 
+      @creation_caller = prepare_tracing_info() if Docgenerator.trace_on?
+      self << content if  content 
+    end
 =begin rdoc  
 Only for debbuging reasons.
 
@@ -103,31 +103,31 @@ This should be the location, where the element is created.
 
 Via Element#inspect you get access to this information.
 =end  
-  def prepare_tracing_info()
-    caller().each{|c|
-      next if ( /lib\/(docgenerator|creole|wiki2doc)/ =~  c )
-      return c
-    }
-    #--> No calling stack outside lib/docgenerator found --> Error    
-    @log.error('Element#prepare_tracing_info: Found no starting place in caller stack') if @log.error?
-    caller().each{|c| @log.debug("\t#{c}") } if @log.debug?
-    return caller()
-  end
+    def prepare_tracing_info()
+      caller().each{|c|
+        next if ( /lib\/(docgenerator|creole|wiki2doc)/ =~  c )
+        return c
+      }
+      #--> No calling stack outside lib/docgenerator found --> Error    
+      @log.error('Element#prepare_tracing_info: Found no starting place in caller stack') if @log.error?
+      caller().each{|c| @log.debug("\t#{c}") } if @log.debug?
+      return caller()
+    end
 =begin rdoc
 Set a text for the inspect command.
 
 Nil if the information was not collected at Element#new.
 =end
-  def inspect_creation_caller
-    if @creation_caller
-      ", created at #{@creation_caller}"
-    else
-      nil #'unknown. Please set Elements.trace if needed'
+    def inspect_creation_caller
+      if @creation_caller
+        ", created at #{@creation_caller}"
+      else
+        nil #'unknown. Please set Elements.trace if needed'
+      end
+    end
+    def inspect()
+      return "<#{self.class}#{inspect_creation_caller}>"
     end
-  end
-  def inspect()
-    return "<#{self.class}#{inspect_creation_caller}>"
-  end
 
 =begin rdoc  
 List (array) of targets, where the element can be used.
@@ -135,100 +135,100 @@ Default are all supported targets.
 
 With restrictions of this attribute, elements can be restricted on special documents.
 =end  
-  def restrict_to( *argv )
-    @targets = []
-    @suppressed_targets = SUPPORTED_TARGETS.dup
-    @log.info("Element#restrict_to: #{self.inspect} restrict to #{argv.inspect}") if @log.warn?
-    argv.each{ |arg|
-      #~ if ! SUPPORTED_TARGETS.include?( arg )
-      if ! @suppressed_targets.delete( arg )
-        @log.warn("Restriction for unsupported target #{arg}") if @log.warn?
-      end
-      @targets  << arg
-    }
-    self
-  end
-  #Accessor on content
-  attr_reader :content
-  #Logger of the element
-  attr_reader :log
+    def restrict_to( *argv )
+      @targets = []
+      @suppressed_targets = SUPPORTED_TARGETS.dup
+      @log.info("Element#restrict_to: #{self.inspect} restrict to #{argv.inspect}") if @log.warn?
+      argv.each{ |arg|
+        #~ if ! SUPPORTED_TARGETS.include?( arg )
+        if ! @suppressed_targets.delete( arg )
+          @log.warn("Restriction for unsupported target #{arg}") if @log.warn?
+        end
+        @targets  << arg
+      }
+      self
+    end
+    #Accessor on content
+    attr_reader :content
+    #Logger of the element
+    attr_reader :log
 =begin rdoc  
 Add something to the content.
 Only possible on elements, which supports "content".
 =end
-  def << ( content )
-    if @content
-      @content << content
-    else
-      @log.warn("Add content to an element without this feature #{self.inspect}, #{content.inspect}") if @log.warn?
+    def << ( content )
+      if @content
+        @content << content
+      else
+        @log.warn("Add content to an element without this feature #{self.inspect}, #{content.inspect}") if @log.warn?
+      end
     end
-  end
 
 =begin rdoc
 Add content after a target (other content)
   insertafter(target,*obj)
 Requires the ability of "content".
 =end
-  def insertafter(target,*obj)
-    self.insert(target, 1, obj)
-  end
+    def insertafter(target,*obj)
+      self.insert(target, 1, obj)
+    end
 =begin rdoc  
 Add content before a target (other content)
   insertbefore(target,*obj)
 Requires the ability of "content".
 =end
-  def insertbefore(target,*obj)
-    self.insert(target, 0, obj)
-  end
+    def insertbefore(target,*obj)
+      self.insert(target, 0, obj)
+    end
 =begin rdoc  
 Insert content relative to a given target.
 The target must exist, pos defines the relative position (0=before, 1=one after the element).
 Method called by Element#insertbefore and Element#insertafter.
 =end
-  def insert(target,pos,*obj )
-    if @content
-      if @content.include?( target )
-        @content[@content.index(target)+pos ,0] = obj
+    def insert(target,pos,*obj )
+      if @content
+        if @content.include?( target )
+          @content[@content.index(target)+pos ,0] = obj
+        else
+          @log.warn("Insert content not possible. Reference object does not exist (#{target.inspect})") if @log.warn?
+        end
       else
-        @log.warn("Insert content not possible. Reference object does not exist (#{target.inspect})") if @log.warn?
-      end
-    else
-      @log.warn("Add content to an element without this feature") if @log.warn?
-    end    
-    self
-  end
+        @log.warn("Add content to an element without this feature") if @log.warn?
+      end    
+      self
+    end
 =begin rdoc
 Delete the given object from content.
 =end
-  def delete(target )
-    if @content
-      @content.delete( target )
-    else
-      @log.warn("Delete content of an element without this feature") if @log.warn?
-    end    
-    self
-  end
+    def delete(target )
+      if @content
+        @content.delete( target )
+      else
+        @log.warn("Delete content of an element without this feature") if @log.warn?
+      end    
+      self
+    end
 =begin rdoc  
 Insert an empty line after the last entry.
 
 Example:
   <tag>content</tag>[CR]
 =end
-  def cr()
-    @crafter  = true
-    self
-  end
+    def cr()
+      @crafter  = true
+      self
+    end
 =begin rdoc
 Insert an empty line before and after the last entry.
 
 Example:
   [CR]<tag>content</tag>[CR]
 =end
-  def Cr()
-    @crbefore  = true
-    @crafter  = true
-    self
-  end
+    def Cr()
+      @crbefore  = true
+      @crafter  = true
+      self
+    end
 =begin rdoc  
 Insert an empty line after the last entry and after the opening of the tag.
 
@@ -244,28 +244,28 @@ Example:
   <li>item with cr</li>
   </ul>
 =end
-  def cR()
-    @crbefore  = false
-    @crmid  = true
-    @crafter  = true
-    self
-  end
+    def cR()
+      @crbefore  = false
+      @crmid  = true
+      @crafter  = true
+      self
+    end
 =begin rdoc
 Insert an empty line before and after the last entry and after the opening of the tag.
 
 Example:
   [CR]<tag>[CR]content</tag>[CR]
 =end
-  def CR()
-    @crbefore  = true
-    @crmid  = true
-    @crafter  = true
-    self
-  end
+    def CR()
+      @crbefore  = true
+      @crmid  = true
+      @crafter  = true
+      self
+    end
 =begin rdoc
 Accessor on attribute list
 =end
-  attr_reader :attr
+    attr_reader :attr
 =begin rdoc  
 Return an attribute to add content.
 
@@ -276,16 +276,16 @@ Example:
 Normally, this is the better solution:
   sec = element(:section, { :shorttitle => 'shorttitle'}, 'title' )
 =end
-  def [] (key)
-    attr = @attr[key]
-    #If Attribute does not exist, take a look, if it is an alias-name.
-    attr = @attr_alias[key] if !attr
-    if ! attr
-      @log.warn("Request unknown attribute '#{key}', return a dummy (#{self.inspect})") if @log.warn?
-      attr = Attribute.create( ).new(key, self)
+    def [] (key)
+      attr = @attr[key]
+      #If Attribute does not exist, take a look, if it is an alias-name.
+      attr = @attr_alias[key] if !attr
+      if ! attr
+        @log.warn("Request unknown attribute '#{key}', return a dummy (#{self.inspect})") if @log.warn?
+        attr = Attribute.create( ).new(key, self)
+      end
+      return attr
     end
-    return attr
-  end
 =begin rdoc  
 Default setting, each element class may contain contents.
 Can be redefined by meta-method Elements.has_no_content
@@ -294,16 +294,16 @@ Can be redefined by meta-method Elements.has_no_content
 - false:  no content, no endtag, but tag closed with / (example: Docgenerator::Elements::Newline as < br/>)
 - nil:    no content, no endtag, no closing  (example: Docgenerator::Elements::Newline as < br>)
 =end
-  def content?()
-    return true
-  end
+    def content?()
+      return true
+    end
 =begin rdoc
 check if there is content assigned.
 =end
-  def empty?()
-    return @content.empty?
-  end
-  @@level = 0
+    def empty?()
+      return @content.empty?
+    end
+    @@level = 0
 =begin rdoc  
 Build a String to be used for the target document.
 Calls 
@@ -316,99 +316,99 @@ Calls
 
 Via the options-hash, you can transport additional information.
 =end
-  def to_doc( target, options = {} )
-    o = set_option_defaults(options)
-    o[:log].debug("enter to_doc(#{target}) for #{self.inspect}, options: #{options.keys.inspect}") if o[:log].debug?
-    #Return empty string, if target is not requested.
-    if ! @targets.include?( target )
-      if @suppressed_targets.include?(target)
-      o[:log].info("Element#to_doc: Content of #{self.inspect} suppressed for Target #{target.inspect}.") if o[:log].info?
-      else
-      o[:log].warn("Element#to_doc: Target #{target.inspect} not supported for #{self.inspect}.") if o[:log].warn?
+    def to_doc( target, options = {} )
+      o = set_option_defaults(options)
+      o[:log].debug("enter to_doc(#{target}) for #{self.inspect}, options: #{options.keys.inspect}") if o[:log].debug?
+      #Return empty string, if target is not requested.
+      if ! @targets.include?( target )
+        if @suppressed_targets.include?(target) #an Element#restrict_to was defined.
+          o[:log].debug("Element#to_doc: Content of #{self.inspect} suppressed for Target #{target.inspect}. (use of restrict_to ?)") if o[:log].debug?
+        else
+          o[:log].warn("Element#to_doc: Target #{target.inspect} not supported for #{self.inspect}.") if o[:log].warn?
+        end
+        return ''
       end
-      return ''
-    end
-    #Some checks
-    @attr.each{|k,v|
-      if v.required? and v.to_s == '' and v.settings.include?(target)
-        o[:log].error "#{self.inspect}: Attribut '#{k}' without required value" if o[:log].error?
+      #Some checks
+      @attr.each{|k,v|
+        if v.required? and v.to_s == '' and v.settings.include?(target)
+          o[:log].error "#{self.inspect}: Attribut '#{k}' without required value" if o[:log].error?
+        end
+      }
+      #Build the string.
+      result = ''
+
+      case target
+      when :latex
+        result = to_latex(o)  
+      when :context
+        result = to_context(o)  
+      when :html
+        result = to_html(o)
+      when :wiki
+        result = to_wiki(o)
+      when :creole
+        result = to_creole(o)
+      when :text
+        result = to_text(o)
+      else
+        o[:log].fatal("Undefined target format '#{target}'") if o[:log].fatal?
       end
-    }
-    #Build the string.
-    result = ''
-
-    case target
-    when :latex
-      result = to_latex(o)  
-    when :context
-      result = to_context(o)  
-    when :html
-      result = to_html(o)
-    when :wiki
-      result = to_wiki(o)
-    when :creole
-      result = to_creole(o)
-    when :text
-      result = to_text(o)
-    else
-      o[:log].fatal("Undefined target format '#{target}'") if o[:log].fatal?
+      #Already added in submethods
+      #~ result = "\n#{result}"   if @crbefore
+      #~ result << "\n"       if @crafter
+      return result
     end
-    #Already added in submethods
-    #~ result = "\n#{result}"   if @crbefore
-    #~ result << "\n"       if @crafter
-    return result
-  end
 =begin rdoc  
 This is a dummy method, called from Element#to_s for the target format LaTeX.
 This method must be overwritten from the element class.
 
 By default, the concatenation of all ids and the content is taken.
 =end
-  def to_latex(options = {})
-    o = set_option_defaults(options)
-    makroname = 'dummy'
-    self.element_ids.each{|id|
-      makroname = id if id.is_a?(Symbol) or id.is_a?(String)
-    }
-    o[:log].error("Missing output routine for LaTeX, use \\#{makroname} (#{self.inspect})")
-    cmd  =  ''
-    cmd  <<  "\n" if @crbefore
-    cmd  <<  "\\#{makroname}{#{@content.to_latex(options)}}"
-    cmd  <<  "\n" if @crafter
-    return cmd
-  end
+    def to_latex(options = {})
+      o = set_option_defaults(options)
+      makroname = 'dummy'
+      self.element_ids.each{|id|
+        makroname = id if id.is_a?(Symbol) or id.is_a?(String)
+      }
+      o[:log].error("Missing output routine for LaTeX, use \\#{makroname} (#{self.inspect})")
+      cmd  =  ''
+      cmd  <<  "\n" if @crbefore
+      cmd  <<  "\\#{makroname}{#{@content.to_latex(options)}}"
+      cmd  <<  "\n" if @crafter
+      return cmd
+    end
 =begin rdoc  
 Create context-output.
 
 ConTeXt-support is added later and there are a lot of gaps (2009-07-01)
 =end
-  def to_context(options = {})
-    o = set_option_defaults(options)
-    makroname = 'dummy'
-    self.element_ids.each{|id|
-      makroname = id if id.is_a?(Symbol) or id.is_a?(String)
-    }
-    o[:log].error("Missing output routine for ConTeXt, use \\#{makroname} (#{self.inspect})")
-    
-    cmd  =  ''
-    cmd  <<  "\n" if @crbefore
-    cmd  <<  "\\#{makroname}{#{@content.to_context(options)}}"
-    cmd  <<  "\n" if @crafter
-    return cmd
-  end
+    def to_context(options = {})
+      o = set_option_defaults(options)
+      makroname = 'dummy'
+      self.element_ids.each{|id|
+        makroname = id if id.is_a?(Symbol) or id.is_a?(String)
+      }
+      o[:log].error("Missing output routine for ConTeXt, use \\#{makroname} (#{self.inspect})")
+      
+      cmd  =  ''
+      cmd  <<  "\n" if @crbefore
+      cmd  <<  "\\#{makroname}{#{@content.to_context(options)}}"
+      cmd  <<  "\n" if @crafter
+      return cmd
+    end
 =begin rdoc
 Method for definition inside Element.create.
 =end
-  def linebreak( flag = true )
-    flag ? "\n" : ''
-  end
+    def linebreak( flag = true )
+      flag ? "\n" : ''
+    end
 =begin rdoc  
 Prints the optional attribut key inside []. If empty, nil is returned
 =end
-  def texoptional(key)
-    return nil unless @attr[key].filled?
-    return "[#{@attr[key]}]"
-  end
+    def texoptional(key)
+      return nil unless @attr[key].filled?
+      return "[#{@attr[key]}]"
+    end
 =begin rdoc  
 Build key-val options from attributs.
 Used e.g. by includegraphics.
@@ -435,19 +435,19 @@ Example (Packages::IncludePDF):
   
   
 =end
-  def texkeyval()
-    keyval = []
-    @attr.sort_by{|k,v| v.sortkey  }.each{|k,v|
-      next unless v.texkeyval?
-      case v.content
-        when true, [true];   keyval << "#{k}" 
-        when false, [false]  #ignore
-        else  #take the value
-          keyval << "#{k}={#{v}}" unless v.to_s.empty?
-        end
-    }
-    return keyval.join(', ')
-  end
+    def texkeyval()
+      keyval = []
+      @attr.sort_by{|k,v| v.sortkey  }.each{|k,v|
+        next unless v.texkeyval?
+        case v.content
+          when true, [true];   keyval << "#{k}" 
+          when false, [false]  #ignore
+          else  #take the value
+            keyval << "#{k}={#{v}}" unless v.to_s.empty?
+          end
+      }
+      return keyval.join(', ')
+    end
 =begin rdoc  
 Define the tag for html-output.
 
@@ -456,9 +456,9 @@ Redfinition is made by Element.add_html_tag.
 
 htmltag nil/false supress the output.
 =end
-  def htmltag()
-    ''
-  end
+    def htmltag()
+      ''
+    end
 =begin rdoc  
 This is a dummy method, called from Element#to_doc for the target format HTML.
 
@@ -467,77 +467,77 @@ If Element#htmltag is nil/false, nothing '' is returned.
 
 This method can be overwritten from the element class.
 =end
-  def to_html(options = {})
-    o = set_option_defaults(options)
-    tag = htmltag()
-    if ! tag 
-      o[:log].error("No HTML element available (#{self.inspect})") if o[:log].error?
-      return ''
-    elsif tag == ''
-      tag = 'span' 
-      o[:log].error("Missing output routine for HTML (#{self.inspect})") if o[:log].error?
-    end
-    #Test if the HTML-Tag should contain something, but there is nothing.
-    #If :empty_ok it is ok, that there is no content (e.g <td>)
-    #May make problems, if an empty tag is used to set a id-mark.
-    if content?() and content? != :empty_ok and
-      ( ! @content or @content == [] or @content == [nil] )
-      o[:log].warn("HTML-Tag #{tag} without content -> ignored #{self.inspect}")  if o[:log].warn?
-      return ''
-    end
-    html  = String.new()
-    html  <<  "\n" if @crbefore
-    html  << "<#{tag} "
-    @attr.sort_by{|k,v|   v.sortkey }.each{|k,v|
-      html << "#{k} = \"#{v}\" " if v.to_s != '' and v.html?
-    }
-    if @content
-      html << ">"
-      html  <<"\n" if @crmid
-      html << "#{@content.to_html(options)}"
-      html  << "\n" if @crmid and @content.size > 0 and html[-1,1] != "\n"
-      html << "</#{tag}>"
-    elsif  content?() == nil
-      html  << '>'
-    else
-      html << '/>'
-    end
-    html  <<  "\n" if @crafter
-    return html
-  end  #to_html
+    def to_html(options = {})
+      o = set_option_defaults(options)
+      tag = htmltag()
+      if ! tag 
+        o[:log].error("No HTML element available (#{self.inspect})") if o[:log].error?
+        return ''
+      elsif tag == ''
+        tag = 'span' 
+        o[:log].error("Missing output routine for HTML (#{self.inspect})") if o[:log].error?
+      end
+      #Test if the HTML-Tag should contain something, but there is nothing.
+      #If :empty_ok it is ok, that there is no content (e.g <td>)
+      #May make problems, if an empty tag is used to set a id-mark.
+      if content?() and content? != :empty_ok and
+        ( ! @content or @content == [] or @content == [nil] )
+        o[:log].warn("HTML-Tag #{tag} without content -> ignored #{self.inspect}")  if o[:log].warn?
+        return ''
+      end
+      html  = String.new()
+      html  <<  "\n" if @crbefore
+      html  << "<#{tag} "
+      @attr.sort_by{|k,v|   v.sortkey }.each{|k,v|
+        html << "#{k} = \"#{v}\" " if v.to_s != '' and v.html?
+      }
+      if @content
+        html << ">"
+        html  <<"\n" if @crmid
+        html << "#{@content.to_html(options)}"
+        html  << "\n" if @crmid and @content.size > 0 and html[-1,1] != "\n"
+        html << "</#{tag}>"
+      elsif  content?() == nil
+        html  << '>'
+      else
+        html << '/>'
+      end
+      html  <<  "\n" if @crafter
+      return html
+    end  #to_html
 =begin rdoc
 Return content in Wikimedia-Syntax.
 Support stopped.
 =end
-  def to_wiki(options = {})
-    o = set_option_defaults(options)
-    o[:log].error("Missing output routine for Wiki (#{self.inspect})") if o[:log].error?
-    return "#{@content.to_wiki(options)}\n"
-  end
+    def to_wiki(options = {})
+      o = set_option_defaults(options)
+      o[:log].error("Missing output routine for Wiki (#{self.inspect})") if o[:log].error?
+      return "#{@content.to_wiki(options)}\n"
+    end
 =begin rdoc
 Return content in creole-Syntax.
 =end
-  def to_creole(options = {})
-    o = set_option_defaults(options)
-    o[:log].error("Missing output routine for creole (#{self.inspect})") if o[:log].error?
-    return "#{@content.to_creole(options)}\n"
-  end
+    def to_creole(options = {})
+      o = set_option_defaults(options)
+      o[:log].error("Missing output routine for creole (#{self.inspect})") if o[:log].error?
+      return "#{@content.to_creole(options)}\n"
+    end
 =begin rdoc
 Make an Text-Representation of the content.
 =end
-  def to_text(options = {})
-    o = set_option_defaults(options)
-    o[:log].error("Missing output routine for Text (#{self.inspect})") if o[:log].error?
-    text = String.new()
-    text  <<  "\n" if @crbefore
-    text = "#{@content.to_text(options)}".strip
-    text  <<  "\n" if @crafter
-    return text
-  end
-  def to_s()
-    return self.inspect
-  end
-end #Element
+    def to_text(options = {})
+      o = set_option_defaults(options)
+      o[:log].error("Missing output routine for Text (#{self.inspect})") if o[:log].error?
+      text = String.new()
+      text  <<  "\n" if @crbefore
+      text = "#{@content.to_text(options)}".strip
+      text  <<  "\n" if @crafter
+      return text
+    end
+    def to_s()
+      return self.inspect
+    end
+  end #Element
 end #module Docgenerator
 
 =begin rdoc