webgen 0.3.8 → 0.4.0

data/lib/webgen/plugins/filehandlers/copy.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: copy.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: copy.rb 538 2006-12-18 08:52:02Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -21,37 +21,59 @@
 #
 
 require 'fileutils'
-require 'webgen/plugins/filehandlers/filehandler'
+require 'erb'
+load_plugin 'webgen/plugins/filehandlers/filehandler'
 
 module FileHandlers
 
-  # A simple file handler which copies files with a specific extension from the source to the output
-  # directory. The extensions of the files to copy are customizable.
-  class CopyFileHandler < DefaultFileHandler
+  # A simple file handler which copies files specified by a pattern from the source to the output
+  # directory.
+  class CopyHandler < DefaultHandler
 
-    summary "Copies files from source to destination without modification"
-    add_param 'paths', ['**/*.css', '**/*.jpg', '**/*.png', '**/*.gif'], \
-    'The path patterns which should match the files that should get copied by this handler.'
-    depends_on 'FileHandler'
+    infos( :name => 'File/CopyHandler',
+           :author => Webgen::AUTHOR,
+           :summary => "Copies files from source to destination"
+           )
 
-    def initialize
+    param 'paths', ['**/*.css', '**/*.js', '**/*.jpg', '**/*.png', '**/*.gif'], 'The path patterns ' +
+      'which match the files that should get copied by this handler.'
+
+    param 'erbPaths', ['**/*.rhtml', '**/*.rcss'], 'The path patterns which match the files ' +
+      'that should get preprocessed by ERB. The leading letter r is removed from the extension.'
+
+    def initialize( plugin_manager )
       super
-      get_param( 'paths' ).each do |path|
-        self.class.handle_path( path )
-      end
+      param( 'paths' ).each {|path| register_path_pattern( path ) }
+      param( 'erbPaths' ).each {|path| register_path_pattern( path ) }
     end
 
-    def create_node( srcName, parent )
-      node = Node.new( parent )
-      node['dest'] = node['src'] = node['title'] = File.basename( srcName )
-      node['processor'] = self
+    def create_node( path, parent, meta_info )
+      processWithErb = param( 'erbPaths' ).any? {|pattern| File.fnmatch( pattern, path, File::FNM_DOTMATCH )}
+      name = File.basename( path )
+      name = name.sub( /\.r([^.]+)$/, '.\1' ) if processWithErb
+
+      node = parent.find {|c| c =~ name }
+      if node.nil?
+        node = Node.new( parent, name )
+        node['title'] = name
+        node.meta_info.update( meta_info )
+        node.node_info[:src] = path
+        node.node_info[:processor] = self
+        node.node_info[:preprocess] = processWithErb
+      else
+        log(:warn) { "Can't create node <#{node.full_path}> as it already exists (node handled by #{node.node_info[:processor].class.plugin_name})!" }
+      end
       node
     end
 
     # Copy the file to the destination directory if it has been modified.
     def write_node( node )
-      if Webgen::Plugin['FileHandler'].file_modified?( node.recursive_value( 'src' ), node.recursive_value( 'dest' ) )
-        FileUtils.cp( node.recursive_value( 'src' ), node.recursive_value( 'dest' ) )
+      if @plugin_manager['Core/FileHandler'].file_modified?( node.node_info[:src], node.full_path )
+        if node.node_info[:preprocess]
+          File.open( node.full_path, 'w+' ) {|f| f.write( ERB.new( File.read( node.node_info[:src] ) ).result( binding ) ) }
+        else
+          FileUtils.cp( node.node_info[:src], node.full_path )
+        end
       end
     end
 

data/lib/webgen/plugins/filehandlers/directory.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: directory.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: directory.rb 548 2006-12-23 14:45:53Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -20,40 +20,45 @@
 #++
 #
 
-require 'webgen/plugins/filehandlers/filehandler'
+load_plugin 'webgen/plugins/filehandlers/filehandler.rb'
+require 'webgen/node'
 
 module FileHandlers
 
   # Handles directories.
-  class DirectoryHandler < DefaultFileHandler
+  class DirectoryHandler < DefaultHandler
 
-    # Specialized node describing a directory.
+    # Specialized node for a directory.
     class DirNode < Node
 
-      def initialize( parent, name )
-        super( parent )
-        self['title'] = name
-        self['src'] = self['dest'] = name + '/'
-        self['processor'] = Webgen::Plugin['DirectoryHandler']
-        self['int:directory?'] = true
+      def initialize( parent, path, meta_info = {} )
+        super( parent, path )
+        self.meta_info = meta_info
+        self['title'] = File.basename( path ).capitalize
       end
 
       def []( name )
-        process_dir_index if !self.metainfo.has_key?( 'indexFile' ) && name == 'indexFile'
+        process_dir_index if name == 'indexFile' &&
+          (!self.meta_info.has_key?( 'indexFile' ) ||
+           (!self.meta_info['indexFile'].nil? && !self.meta_info['indexFile'].kind_of?( Node ) ) )
         super
       end
 
+      #######
+      private
+      #######
+
       def process_dir_index
-        indexFile = Webgen::Plugin['DirectoryHandler']['indexFile']
+        indexFile = self.meta_info['indexFile']
         if indexFile.nil?
           self['indexFile'] = nil
         else
-          node = node_for_string( indexFile )
+          node = resolve_node( indexFile )
           if node
-            self.logger.info { "Directory index file for <#{self.recursive_value( 'src' )}> => <#{node.recursive_value( 'src', false )}>" }
+            node_info[:processor].log(:info) { "Directory index file for <#{self.full_path}> => <#{node.full_path}>" }
             self['indexFile'] = node
           else
-            self.logger.warn { "No directory index file found for directory <#{self.recursive_value( 'src' )}>" }
+            node_info[:processor].log(:warn) { "No directory index file found for directory <#{self.full_path}>" }
             self['indexFile'] = nil
           end
         end
@@ -62,61 +67,58 @@ module FileHandlers
     end
 
 
-    summary "Handles directories"
-    handle_path '**/'
-    add_param 'indexFile', 'index.page', 'The default file name for the directory index page file.'
-    depends_on 'FileHandler'
-    used_meta_info 'indexFile', 'directoryName'
+    infos( :name => 'File/DirectoryHandler',
+           :author => Webgen::AUTHOR,
+           :summary => "Handles directories"
+           )
+
+    default_meta_info( { 'indexFile' => 'index.page' } )
+
+    register_path_pattern '**/', 0
+
 
-    # Return a new DirNode.
-    def create_node( path, parent )
-      unless parent && node = parent.find {|child| /^#{File.basename( path )}\/$/ =~ child['src'] }
-        node = DirNode.new( parent, File.basename( path ) )
+    # Returns a new DirNode.
+    def create_node( path, parent, meta_info )
+      filename = File.basename( path ) + '/'
+      if parent.nil? || (node = parent.find {|child| child =~ filename }).nil?
+        node = DirNode.new( parent, filename, meta_info )
+        node.node_info[:processor] = self
+        node.node_info[:src] = path
       end
       node
     end
 
-    # Create the directory (and all its parent directories if necessary).
+    # Creates the directory (and all its parent directories if necessary).
     def write_node( node )
-      name = node.recursive_value( 'dest' )
-      FileUtils.makedirs( name ) unless File.exists?( name )
+      FileUtils.makedirs( node.full_path ) unless File.exists?( node.full_path )
     end
 
     # Return the page node for the directory +node+ using the specified language +lang+. If an
     # index file is specified, then the its correct language node is returned, else +node+ is
     # returned.
-    def get_node_for_lang( node, lang )
-      if node['indexFile']
-        node['indexFile']['processor'].get_node_for_lang( node['indexFile'], lang )
-      else
-        node
-      end
+    def node_for_lang( node, lang )
+      langnode = node['indexFile'].node_for_lang( lang ) if node['indexFile']
+      langnode || node
     end
 
-    # Get the HTML link for the directory +node+.
-    def get_html_link( node, refNode, title = nil )
-      lang_node = get_node_for_lang( node, refNode['lang'] )
-      title ||=  lang_node['directoryName'] || node['title']
-      super( lang_node, refNode, title )
+    # See DefaultFileHandler#link_from and PageHandler#link_from.
+    def link_from( node, ref_node, attr = {} )
+      lang_node = (attr[:resolve_lang_node] == false ? node : node.node_for_lang( ref_node['lang'] ) )
+      attr[:link_text] ||=  lang_node['directoryName'] || node['title']
+      super( lang_node, ref_node, attr )
     end
 
-    # Recursively create a given path
+    # Recursively creates a given directory path starting from the path of +parent+ and returns the
+    # bottom most directory node.
     def recursive_create_path( path, parent )
-      p = parent
-      node = nil
       path.split( File::SEPARATOR ).each do |pathname|
         case pathname
-        when '.' then
-          # do nothing
-        when '..' then
-          p = p.parent
-        else
-          node = create_node( pathname, p )
-          p.add_child( node ) unless p.nil? || node.nil?
-          p = node
+        when '.' then  #do nothing
+        when '..' then parent = parent.parent
+        else parent = @plugin_manager['Core/FileHandler'].create_node( pathname, parent, self )
         end
       end
-      node
+      parent
     end
 
   end

data/lib/webgen/plugins/filehandlers/filehandler.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: filehandler.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: filehandler.rb 577 2007-01-04 20:09:28Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -21,182 +21,366 @@
 #
 
 require 'set'
+require 'yaml'
+require 'webgen/node'
 require 'webgen/listener'
+require 'webgen/languages'
 
 module FileHandlers
 
+  # The main plugin for handling files.
+  #
+  # The following message listening hooks (defined via symbols) are available for this plugin
+  # (see Listener):
+  #
+  # +before_node_created+:: called before a node is created
+  # +after_node_created+::  called after a node has been created
+  # +after_all_nodes_created+:: called after the plugin has finfished reading in all files and the
+  #                             output backing section of the meta information file has been processed
+  # +before_node_written+:: called before a node is written out
+  # +after_node_written+::  called after a node has been written out
+  # +before_all_nodes_written+:: called before the plugin starts writing out the files
+  # +after_all_nodes_written+:: called after the plugin has finfished writing out the files
   class FileHandler < Webgen::Plugin
 
-    summary "Super plugin for handling files"
-    description "Provides interface on file level. The FileHandler goes through the source
-        directory, reads in all files for which approriate plugins exist and
-        builds the tree. When all approriate transformations on the tree have
-        been performed the FileHandler is used to write the output files.
-      ".gsub( /^\s+/, '' ).gsub( /\n/, ' ' )
-    add_param 'ignorePaths', ['**/.svn{/**/**,/}', '**/CVS{/**/**,/}'], 'An array of path patterns which match files that should ' \
-    'be excluded from the list of \'to be processed\' files.'
+    infos( :name => 'Core/FileHandler',
+           :author => Webgen::AUTHOR,
+           :summary => "Main plugin for handling the files in the source directory"
+           )
+
+    param 'ignorePaths', ['**/CVS{/**/**,/}'], 'An array of path patterns which match files ' +
+      'that should be excluded from the list of \'to be processed\' files.'
+
+    param 'defaultMetaInfo', {}, 'The keys for this hash are the names of file handlers, the ' +
+      'values hashes with meta data.'
+
+    depends_on 'Core/Configuration'
 
     include Listener
 
-    def initialize
-      add_msg_name( :AFTER_ALL_READ )
-      add_msg_name( :AFTER_ALL_WRITTEN )
+    def initialize( manager )
+      super
+      add_msg_name( :before_node_created )
+      add_msg_name( :after_node_created )
+      add_msg_name( :after_all_nodes_created )
+      add_msg_name( :before_node_written )
+      add_msg_name( :after_node_written )
+      add_msg_name( :before_all_nodes_written )
+      add_msg_name( :after_all_nodes_written )
+      load_meta_info_backing_file
     end
 
-    # Builds the tree with all the nodes and returns it.
-    def build_tree
-      allFiles = get_files_for_pattern( File.join( '**', '{.[^.]**/**/**,**}' ) )
-      get_param( 'ignorePaths' ).each do |pattern|
-        allFiles.subtract( get_files_for_pattern( pattern ) )
+    # Renders the whole website.
+    def render_site
+      tree = build_tree
+      #TODO
+      #transform tree???
+      write_tree( tree ) unless tree.nil?
+    end
+
+    # Renders only the given +files+.
+    def render_files( files )
+      tree = build_tree
+      return unless tree.nil?
+      files.each do |file|
+        node = tree.resolve_node( file )
+        if !node.nil?
+          write_node( node.parent ) if !node.parent.nil? && node.parent.is_directory?
+          write_node( node )
+        end
       end
+    end
 
-      handlerFiles = sort_file_handlers( FileHandlers::DefaultFileHandler.get_file_handlers ).collect do |pattern, handler|
-        [get_files_for_pattern( pattern ), Webgen::Plugin.config[handler].obj]
+    # Returns true if the file +src+ is newer than +dest+ and therefore has been modified since the
+    # last execution of webgen. The +mtime+ values for the source and destination files are used to
+    # find this out.
+    def file_modified?( src, dest )
+      if File.exists?( dest ) && ( File.mtime( src ) <= File.mtime( dest ) )
+        log(:info) { "File is up to date: <#{dest}>" }
+        return false
+      else
+        return true
       end
+    end
 
-      rootPath = Webgen::Plugin['Configuration']['srcDirectory'] + File::SEPARATOR
-      rootHandler = handler_for_path( rootPath, handlerFiles )
-      if rootHandler.nil? || allFiles.empty?
-        logger.error { "No file handler for root directory <#{rootPath}> found" } if rootHandler.nil? && !allFiles.empty?
-        logger.error { "No files found in directory <#{rootPath}>" } if allFiles.empty?
-        return nil
+    # Returns the meta info for nodes for the given +handler+. If +file+ is specified, meta
+    # information from the backing file is also used if available (using files specified in the
+    # source block of the backing file). The parameter +file+ has to be an absolute path, ie.
+    # starting with a slash.
+    def meta_info_for( handler, file = nil )
+      info = (handler.class.config.infos[:default_meta_info] || {}).dup
+      info.update( param('defaultMetaInfo')[handler.class.plugin_name] || {} )
+      if file
+        file = normalize_path( file )
+        if @source_backing.has_key?( file )
+          info.update( @source_backing[file] )
+        end
       end
+      info
+    end
 
-      logger.debug { "Using plugin #{rootHandler.class.name} for handling the root node" }
-      root = create_root_node( rootPath, rootHandler )
-      allFiles.subtract( [rootPath] )
-      handlerFiles.find {|files, handler| handler == rootHandler}[0].subtract( [rootPath] )
-
-      handlerFiles.each do |files, handler|
-        commonFiles = allFiles & files
-        allFiles.subtract( commonFiles )
-        diffFiles = files - commonFiles
-        logger.info { "Not handling files for #{handler.class.name} as they do not exist or are excluded:  #{diffFiles.inspect}" } if diffFiles.length > 0
-        commonFiles.each {|file| build_entry( file, root, handler, handlerFiles ) }
+    # Creates a node for +file+ (creating parent directories apropriately) under +parent_node+ using
+    # the given +handler+. If a block is given, then the block is used to create the node which is
+    # useful if you want a custom node creation method.
+    def create_node( file, parent_node, handler ) # :yields: file, parent_node, handler, meta_info
+      pathname, filename = File.split( file )
+      parent_node = @plugin_manager['File/DirectoryHandler'].recursive_create_path( pathname, parent_node )
+
+      meta_info = meta_info_for( handler, File.join( parent_node.absolute_path, filename ) )
+
+      src_path = File.join( Node.root( parent_node ).node_info[:src], parent_node.absolute_path, filename )
+      dispatch_msg( :before_node_created, src_path, parent_node, handler, meta_info )
+      if block_given?
+        node = yield( src_path, parent_node, handler, meta_info )
+      else
+        node = handler.create_node( src_path, parent_node, meta_info )
       end
+      check_node( node ) unless node.nil?
 
-      dispatch_msg( :AFTER_ALL_READ, root )
-      logger.info { "No handlers found for files: #{allFiles.inspect}" } if allFiles.length > 0
+      dispatch_msg( :after_node_created, node ) unless node.nil?
 
-      root
+
+      node
     end
 
+    #######
+    private
+    #######
+
+    # Used to check that certain meta/node information is available and correct.
+    def check_node( node )
+      node['lang'] = Webgen::LanguageManager.language_for_code( node['lang'] ) unless node['lang'].kind_of?( Webgen::Language )
+      node['title'] ||= node.path
+    end
+
+    # Returns a normalized path, ie. a path starting with a slash and any trailing slashes removed.
+    def normalize_path( path )
+      path = (path =~ /^\// ? '' : '/') + path.sub( /\/+$/, '' )
+    end
+
+    # Loads the meta information backing file from the website directory.
+    def load_meta_info_backing_file
+      file = File.join( param( 'websiteDir', 'Core/Configuration' ), 'metainfo.yaml' )
+      if File.exists?( file )
+        begin
+          index = 1
+          YAML::load_documents( File.read( file ) ) do |data|
+            if data.nil? || (data.kind_of?( Hash ) && data.all? {|k,v| v.kind_of?( Hash ) })
+              if index == 1
+                @source_backing = {}
+                data.each_pair {|path, metainfo| @source_backing[normalize_path(path)] = metainfo} unless data.nil?
+              elsif index == 2
+                @output_backing = data
+              else
+                log(:error) { "A backing file can only have two blocks: one for source and one for output backing!" }
+              end
+            else
+              log(:error) { "Content of backing file (#{index == 1 ? 'source' : 'output'} block) not correctcly structured" }
+            end
+            index += 1
+          end
+        rescue
+          log(:error) { "Backing file is not a valid YAML document: #{$!.message}" }
+        end
+      else
+        log(:info) { 'No meta information backing file found!' }
+      end
+      @source_backing ||= {}
+      @output_backing ||= {}
+    end
+
+    # Uses the output backing section of the meta information file to assign meta information or, if
+    # no node for a path can be found, to create virtual nodes.
+    def handle_output_backing( root )
+      @output_backing.each do |path, data|
+        path = path[1..-1] if path =~ /^\//
+        if node = root.resolve_node( path )
+          node.meta_info.update( data )
+        else
+          node = create_node( path, root, @plugin_manager['File/VirtualFileHandler'] ) do |src, parent, handler, meta_info|
+            meta_info = meta_info.merge( data )
+            handler.create_node( src, parent, meta_info )
+          end
+        end
+        check_node( node )
+      end
+    end
+
+    # Reads all files from the source directory and constructs the node tree which is returned.
+    def build_tree
+      all_files = find_all_files()
+      return if all_files.empty?
+
+      files_for_handlers = find_files_for_handlers()
+
+      root_node = create_root_node()
+
+      used_files = Set.new
+      files_for_handlers.sort {|a,b| a[0] <=> b[0]}.each do |rank, handler, files|
+        log(:debug) { "Creating nodes for #{handler.class.plugin_name} with rank #{rank}" }
+        common = all_files & files
+        used_files += common
+        diff = files - common
+        log(:info) { "Not using these files for #{handler.class.plugin_name} as they do not exist or are excluded: #{diff.inspect}" } if diff.length > 0
+        common.each  do |file|
+          log(:info) { "Creating node(s) for file <#{file}>..." }
+          create_node( file.sub( /^#{root_node.node_info[:src]}/, '' ), root_node, handler )
+        end
+      end
+
+      unused_files = all_files - used_files
+      log(:info) { "No handlers found for: #{unused_files.inspect}" } if unused_files.length > 0
+
+      handle_output_backing( root_node )
+      dispatch_msg( :after_all_nodes_created, root_node )
+
+      root_node
+    end
 
     # Recursively writes out the tree specified by +node+.
     def write_tree( node )
-      self.logger.info { "Writing <#{node.recursive_value('dest')}>" }
+      dispatch_msg( :before_all_nodes_written, node ) if node.parent.nil?
 
-      node['processor'].write_node( node )
+      write_node( node )
+      node.each {|child| write_tree( child ) }
 
-      node.each do |child|
-        write_tree( child )
-      end
+      dispatch_msg( :after_all_nodes_written, node ) if node.parent.nil?
+    end
 
-      dispatch_msg( :AFTER_ALL_WRITTEN ) if node.parent.nil?
+    # Writes out the given +node+.
+    def write_node( node )
+      log(:info) { "Writing <#{node.full_path}>" }
+      dispatch_msg( :before_node_written, node )
+      node.write_node
+      dispatch_msg( :after_node_written, node )
     end
 
+    # Creates a set of all files in the source directory, removing all files which should be ignored.
+    def find_all_files
+      all_files = files_for_pattern( '**/{**,**/}' ).to_set
+      param( 'ignorePaths' ).each {|pattern| all_files.subtract( files_for_pattern( pattern ) ) }
+      log(:error) { "No files found in the source directory <#{param('srcDir', 'Core/Configuration')}>" } if all_files.empty?
+      all_files
+    end
 
-    # Returns true if the file +src+ is newer than +dest+ and therefore has been modified since the last execution
-    # of webgen. The +mtime+ values for the source and destination files are used to find this out.
-    def file_modified?( src, dest )
-      if File.exists?( dest ) && ( File.mtime( src ) < File.mtime( dest ) )
-        self.logger.info { "File is up to date: <#{dest}>" }
-        return false
-      else
-        return true
+    # Finds the files for each registered handler plugin and stores them in a Hash with the plugin
+    # as key.
+    def find_files_for_handlers
+      files_for_handlers = []
+      @plugin_manager.plugins.each do |name, plugin|
+        files_for_plugin = Set.new
+        if plugin.kind_of?( DefaultHandler )
+          plugin.path_patterns.each do |rank, pattern|
+            files = files_for_pattern( pattern ) - files_for_plugin
+            files_for_handlers << [rank, plugin, files ] unless files.empty?
+            files_for_plugin += files
+          end
+        end
       end
+      files_for_handlers
     end
 
-    #######
-    private
-    #######
-
-    def get_files_for_pattern( pattern )
-      files = Dir[File.join( Webgen::Plugin['Configuration']['srcDirectory'], pattern )].to_set
+    # Returns an array of files of the source directory matching +pattern+
+    def files_for_pattern( pattern )
+      files = Dir[File.join( param( 'srcDir', 'Core/Configuration' ), pattern )].to_set
+      files.delete( File.join( param( 'srcDir', 'Core/Configuration' ), '/' ) )
       files.collect!  do |f|
         f = f.sub( /([^.])\.{1,2}$/, '\1' ) # remove '.' and '..' from end of paths
-        f += File::SEPARATOR if File.directory?( f ) && ( f[-1] != ?/ )
+        f += '/' if File.directory?( f ) && ( f[-1] != ?/ )
         f
       end
       files
     end
 
-    def create_root_node( path, handler )
-      root = handler.create_node( path, nil )
+    # Creates the root node.
+    def create_root_node
+      root_path = File.join( param( 'srcDir', 'Core/Configuration' ), '/' )
+      root_handler = @plugin_manager['File/DirectoryHandler']
+      if root_handler.nil?
+        log(:error) { "No handler for root directory <#{root_path}> found" }
+        return nil
+      end
+
+      root = root_handler.create_node( root_path, nil, meta_info_for( root_handler, '/' ) )
       root['title'] = ''
-      root['dest'] = Webgen::Plugin['Configuration']['outDirectory'] + '/'
-      root['src'] = Webgen::Plugin['Configuration']['srcDirectory'] + '/'
+      root.path = File.join( param( 'outDir', 'Core/Configuration' ), '/' )
+      root.node_info[:src] = root_path
+
       root
     end
 
-    def build_entry( file, root, handler, handlerFiles )
-      pathname, filename = File.split( file )
-      pathname = pathname + '/'
-      treeFile = file.sub( /^#{root['src']}/, '' )
-      treePath = pathname.sub( /^#{root['src']}/, '' )
-
-      node = root.node_for_string?( treeFile, 'src' )
-      return node unless node.nil?
-      logger.info { "Processing <#{file}> with #{handler.class.name} ..." }
-
-      parentNode = root.node_for_string?( treePath )
-      if parentNode.nil?
-        if pathname == root['src']
-          parentNode = root
-        else
-          logger.debug { "Parent node for <#{file}> does not exist, create node for path <#{pathname}>" }
-          parentNode = build_entry( pathname, root, handler_for_path( pathname, handlerFiles ), handlerFiles )
-        end
-      end
-      raise "Parent node is nil" if parentNode.nil?
-      logger.info { "Creating node for <#{file}>..." }
-      n = handler.create_node( file, parentNode )
-      parentNode.add_child( n ) unless n.nil?
-      n
-    end
+  end
 
-    def handler_for_path( path, handlerFiles )
-      temp, handler = handlerFiles.find {|p, handler| p.include?( path )}
-      handler
-    end
 
-    def sort_file_handlers( handlers )
-      handlers.sort {|a,b| a[0].count( "?*" ) <=> b[0].count( "?*" )}
-    end
+  # The default handler which is the super class of all file handlers. It defines methods thata
+  # should be used by the subclasses to specify which files should be handled. There are two types
+  # of path patterns: constant ones defined using the class methods and dynamic ones defined using
+  # the instance methods. The dynamic path patterns should be defined during the initialization!
+  #
+  # During a webgen run the FileHandler retrieves all plugins which derive from the DefaultHandler
+  # and uses the constant and dynamic path patterns defined for each file handler plugin for finding
+  # the handled files.
+  class DefaultHandler < Webgen::Plugin
 
-  end
+    EXTENSION_PATH_PATTERN = "**/*.%s"
+    DEFAULT_RANK = 100
+
+    infos( :name => 'File/DefaultHandler',
+           :author => Webgen::AUTHOR,
+           :summary => "Base class of all file handler plugins",
+           :instantiate => false
+          )
+
+    param 'linkToCurrentPage', false, 'Specifies whether in menus, breadcrumb trails, etc. a real link to ' +
+      'the current page should be used or only the link text.'
 
-  # The default handler which is the super class of all file handlers.
-  class DefaultFileHandler < Webgen::Plugin
 
-    summary "Base class of all file handler plugins"
+    # Specify the path pattern which should be handled by the class. The +rank+ is used for sorting
+    # the patterns so that the creation order of nodes can be influenced. If a file is matched by
+    # more than one path pattern defined by a single file handler plugin, it is only used once for
+    # the first pattern.
+    def self.register_path_pattern( path, rank = DEFAULT_RANK )
+      (self.config.infos[:path_patterns] ||= []) << [rank, path]
+    end
+
+    # Specify the files handled by the class via the extension. The parameter +ext+ should be the
+    # pure extension without the dot. Also see DefaultHandler.register_path_pattern !
+    def self.register_extension( ext, rank = DEFAULT_RANK )
+      register_path_pattern( EXTENSION_PATH_PATTERN % [ext], rank )
+    end
 
-    VIRTUAL = true
+    # See DefaultHandler.register_path_pattern
+    def register_path_pattern( path, rank = DEFAULT_RANK )
+      (@path_patterns ||= []) << [rank, path]
+    end
+    protected :register_path_pattern
 
-    # Specify the extension which should be handled by the class.
-    def self.handle_path( path )
-      logger.info { "Registering class #{self.name} for handling the path pattern: #{path.inspect}" }
-      (self.config[self].path ||= []) << path
-      handlers = (self.config[DefaultFileHandler].file_handler ||= {})
-      logger.warn { "Path pattern #{path} already associated with class #{handlers[path].name}, not using class #{self.name} for it!" } if handlers[path]
-      handlers[path] ||= self
+    # See DefaultHandler.register_extension
+    def register_extension( ext, rank = DEFAULT_RANK )
+      register_path_pattern( EXTENSION_PATH_PATTERN % [ext], rank )
     end
+    protected :register_extension
 
-    # Specify the files handled by the class via the extension.
-    def self.extension( ext )
-      handle_path( "**/{.[^.]**/**/*.#{ext},*.#{ext}}" )
+    # Returns all (i.e. static and dynamic) path patterns defined for the file handler.
+    def path_patterns
+      (self.class.config.infos[:path_patterns] || []) + (@path_patterns ||= [])
     end
 
-    # Return the registered file handler plugins.
-    def self.get_file_handlers
-      self.config[self].file_handler
+    # Sets the default meta information for the file handler. This meta information can later be
+    # overridden by the +Core/FileHandler:defaultMetaInfo+ parameter and values set in the meta
+    # information backing file. The so updated meta information is then passed to the #create_node
+    # method.
+    def self.default_meta_info( hash )
+      self.config.infos[:default_meta_info] = hash
     end
 
-    # Supplies the +path+ to a file and the +parent+ node sothat the plugin can create a node for this
-    # path. Should return the node for the path or nil if the node could not be created.
+    # Asks the plugin to create a node for the given +path+ and the +parent+, using +meta_info+ as
+    # default meta data for the node. Should return the node for the path (the newly created node
+    # or, if a node with the path already exists, the existing one) or +nil+ if the node could not
+    # be created.
     #
     # Has to be overridden by the subclass!!!
-    def create_node( path, parent )
+    def create_node( path, parent, meta_info )
       raise NotImplementedError
     end
 
@@ -207,15 +391,78 @@ module FileHandlers
       raise NotImplementedError
     end
 
-    # Returns the node for the language +lang+ which is equal to this +node+.
-    def get_node_for_lang( node, lang )
+    # Returns the node which has the same data as +node+ but in language +lang+; or +nil+ if such a
+    # node does not exist. The default behaviour assumes that +node+ has the data for all languages.
+    def node_for_lang( node, lang )
       node
     end
 
-    # Returns a HTML link for the given +node+ relative to +refNode+. You can optionally specify the
-    # title for the link. If not specified, the title of the node is used.
-    def get_html_link( node, refNode, title = node['title'] )
-      "<a href=\"#{refNode.relpath_to_node( node )}\" title=\"#{title}\">#{title}</a>"
+    # Returns a HTML link to the +node+ from +ref_node+ or, if +node+ and +ref_node+ are the same
+    # and the parameter +linkToCurrentPage+ is +false+, a +span+ element with the link text.
+    #
+    # You can optionally specify additional attributes for the html element in the +attr+ Hash.
+    # Also, the meta information +linkAttrs+ of the given +node+ is used, if available, to set
+    # attributes. However, the +attr+ parameter takes precedence over the +linkAttrs+ meta
+    # information. If the special value +:link_text+ is present in the attributes, it will be used
+    # as the link text; otherwise the title of the +node+ will be used. Be aware that all key-value
+    # pairs with Symbol keys are removed before the attributes are written. Therefore you always
+    # need to specify general attributes with Strings!
+    def link_from( node, ref_node, attr = {} )
+      attr = node['linkAttrs'].merge( attr ) if node['linkAttrs'].kind_of?( Hash )
+      link_text = attr[:link_text] || node['title']
+      attr.delete_if {|k,v| k.kind_of?( Symbol )}
+
+      use_link = ( node != ref_node || param( 'linkToCurrentPage' ) )
+      attr['href'] = ref_node.route_to( node ) if use_link
+      attrs = attr.collect {|name,value| "#{name.to_s}=\"#{value}\"" }.sort.unshift( '' ).join( ' ' )
+      ( use_link ? "<a#{attrs}>#{link_text}</a>" : "<span#{attrs}>#{link_text}</span>" )
+    end
+
+  end
+
+
+  # Handles virtual nodes created via the output backing section of the meta information backing
+  # file.
+  class VirtualFileHandler < DefaultHandler
+
+    # A virtual node.
+    class VirtualNode < ::Node
+
+      # Overridden to also match the +reference+ path of the virtual node.
+      def =~( path )
+        md = /^(#{@path}|#{@node_info[:reference]})(?=#|$)/ =~ path
+        ( md ? $& : nil )
+      end
+
+    end
+
+    infos( :name => 'File/VirtualFileHandler',
+           :author => Webgen::AUTHOR,
+           :summary => 'Handles virtual files specified in the backing file'
+           )
+
+    def create_node( path, parent, meta_info )
+      filename = File.basename( path )
+      filename, reference = (meta_info['url'] ? [meta_info['url'], filename] : [filename, filename])
+
+      # no need to check for an existing nodes, that is already done in FileHandler#handle_output_backing
+      temp_node = VirtualNode.new( parent, reference )
+      resolved_node = temp_node.resolve_node( filename )
+      if resolved_node
+        node = VirtualNode.new( parent, temp_node.route_to( resolved_node ) )
+      else
+        node = VirtualNode.new( parent, filename )
+      end
+      parent.del_child( temp_node )
+
+      node.meta_info.update( meta_info )
+      node.node_info[:reference] = reference
+      node.node_info[:processor] = self
+      node
+    end
+
+    def write_node( node )
+      # nothing to write
     end
 
   end