webgen 0.3.3 → 0.3.4

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

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: filecopy.rb 249 2005-04-13 19:23:51Z thomas $
+# $Id: filecopy.rb 269 2005-05-08 16:06:40Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -30,15 +30,14 @@ module FileHandlers
   class FileCopyHandler < DefaultFileHandler
 
     summary "Copies files from source to destination without modification"
-    add_param 'types', ['css', 'jpg', 'png', 'gif'], \
-    'The extension that will be registered by this handler. All files with ' \
-    'these extensions will be copied from the source to the destination folder.'
+    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'
 
     def initialize
       super
-      get_param( 'types' ).each do |type|
-        extension( type )
+      get_param( 'paths' ).each do |path|
+        self.class.handle_path( path )
       end
     end
 

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

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: filehandler.rb 256 2005-04-14 01:13:57Z thomas $
+# $Id: filehandler.rb 272 2005-05-09 08:53:04Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -20,13 +20,11 @@
 #++
 #
 
-require 'util/listener'
+require 'set'
+require 'webgen/listener'
 
 module FileHandlers
 
-  # Super plugin for handling files. File handler plugins can register themselves by adding a new
-  # key:value pair to +extensions+. The key has to be the extension in lowercase and the value is
-  # the plugin object itself.
   class FileHandler < Webgen::Plugin
 
     summary "Super plugin for handling files"
@@ -35,31 +33,50 @@ module FileHandlers
         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 'ignored', ['.svn', 'CVS'], 'Specifies path names via regular expresssions which should be ignored.'
-
+    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.'
 
     include Listener
 
-    attr_reader :extensions
-
     def initialize
-      @extensions = Hash.new
-
-      add_msg_name( :DIR_NODE_CREATED )
-      add_msg_name( :FILE_NODE_CREATED )
-      add_msg_name( :AFTER_DIR_READ )
+      add_msg_name( :AFTER_ALL_READ )
     end
 
-
-    # Recursively builds the tree with all the nodes and returns it.
+    # Builds the tree with all the nodes and returns it.
     def build_tree
-      root = build_entry( Webgen::Plugin['Configuration']['srcDirectory'], nil )
-      unless root.nil?
-        root['title'] = '/'
-        root['dest'] = Webgen::Plugin['Configuration']['outDirectory'] + '/'
-        root['src'] = Webgen::Plugin['Configuration']['srcDirectory'] + '/'
+      allFiles = get_files_for_pattern( File.join( '**', '{.[^.]**/**/**,**}' ) )
+      get_param( 'ignorePaths' ).each do |pattern|
+        allFiles.subtract( get_files_for_pattern( pattern ) )
       end
+
+      handlerFiles = sort_file_handlers( Webgen::Plugin['DefaultFileHandler'].get_file_handlers ).collect do |pattern, handler|
+        [get_files_for_pattern( pattern ), Webgen::Plugin.config[handler].obj]
+      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?
+        logger.error { "No files found in directory <#{rootPath}>" } if allFiles.empty?
+        return nil
+      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 ) }
+      end
+
+      dispatch_msg( :AFTER_ALL_READ, root )
+      logger.info { "No handlers found for files: #{allFiles.inspect}" } if allFiles.length > 0
+
       root
     end
 
@@ -71,7 +88,7 @@ module FileHandlers
       node['processor'].write_node( node )
 
       node.each do |child|
-        write_tree child
+        write_tree( child )
       end
     end
 
@@ -87,70 +104,60 @@ module FileHandlers
       end
     end
 
-
     #######
     private
     #######
 
-    def build_entry( path, parent )
-      self.logger.info { "Processing <#{path}> ..." }
-
-      if FileTest.file?( path )
-        node = handle_file( path, parent )
-      elsif FileTest.directory?( path )
-        node = handle_directory( path, parent )
-      else
-        type = File.lstat( path ).ftype if File.exists?( path )
-        self.logger.warn { "Path <#{path}> (type: #{type || 'non existing file/dir'}) cannot be handled as it is neither a file nor a directory" }
-        node = nil
+    def get_files_for_pattern( pattern )
+      files = Dir[File.join( Webgen::Plugin['Configuration']['srcDirectory'], pattern )].to_set
+      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
       end
-
-      return node
+      files
     end
 
-
-    def handle_file( path, parent )
-      extension = File.extname( path ).sub( /^./, '' )
-
-      if @extensions.has_key?( extension )
-        node = @extensions[extension].create_node( path, parent )
-        dispatch_msg( :FILE_NODE_CREATED, node ) unless node.nil?
-      else
-        self.logger.warn { "No plugin for <#{path}> (extension: #{extension}) -> ignored" }
-      end
-
-      return node
+    def create_root_node( path, handler )
+      root = handler.create_node( path, nil )
+      root['title'] = '/'
+      root['dest'] = Webgen::Plugin['Configuration']['outDirectory'] + '/'
+      root['src'] = Webgen::Plugin['Configuration']['srcDirectory'] + '/'
+      root
     end
 
-
-    def handle_directory( path, parent )
-      node = nil
-
-      if @extensions.has_key?( :dir )
-        node = @extensions[:dir].create_node( path, parent )
-
-        dispatch_msg( :DIR_NODE_CREATED, node )
-
-        Dir[path + File::SEPARATOR + '{.*,*}'].delete_if do |name|
-          name =~ /#{File::SEPARATOR}\.{1,2}$/ || \
-          File.basename( name ) =~ Regexp.new( get_param( 'ignored' ).join( '|' ) )
-        end.sort! do |a, b|
-          if File.file?( a ) && File.directory?( b )
-            -1
-          elsif ( File.file?( a ) && File.file?( b ) ) || ( File.directory?( a ) && File.directory?( b ) )
-            a <=> b
-          else
-            1
-          end
-        end.each do |filename|
-          child = build_entry( filename, node )
-          node.add_child( child ) unless child.nil?
+    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
-
-        dispatch_msg( :AFTER_DIR_READ, node )
       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
 
-      return node
+    def handler_for_path( path, handlerFiles )
+      handlerFiles.find {|p, handler| p.include?( path )}[1]
+    end
+
+    def sort_file_handlers( handlers )
+      handlers.sort {|a,b| a[0].count( "?*" ) <=> b[0].count( "?*" )}
     end
 
   end
@@ -158,21 +165,25 @@ module FileHandlers
   # The default handler which is the super class of all file handlers.
   class DefaultFileHandler < Webgen::Plugin
 
-    VIRTUAL = true
-
     summary "Base class of all file handler plugins"
 
-    def initialize
-      extension( Webgen::Plugin.config[self.class].extension ) if Webgen::Plugin.config[self.class].extension
+    # 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}" }
+      (@@config[self].path ||= []) << path
+      handlers = (@@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
     end
 
-    # Specify the extension which should be handled by the class.
-    def self.extension( ext ); @@config[self].extension = ext; end
+    # Specify the files handled by the class via the extension.
+    def self.extension( ext )
+      handle_path( "**/{.[^.]**/**/*.#{ext},*.#{ext}}" )
+    end
 
-    # Register the file extension specified by a subclass.
-    def extension( ext )
-      self.logger.info { "Registering file handler #{self.class.name} (#{self.object_id}) with extension '#{ext}'" }
-      Webgen::Plugin['FileHandler'].extensions[ext] = self
+    # Return the registered file handler plugins.
+    def get_file_handlers
+      @@config[self.class].file_handler
     end
 
     # Supplies the +path+ to a file and the +parent+ node sothat the plugin can create a node for this
@@ -180,21 +191,25 @@ module FileHandlers
     #
     # Has to be overridden by the subclass!!!
     def create_node( path, parent )
-      raise "Not implemented"
+      raise NotImplementedError
     end
 
     # Asks the plugin to write out the node.
     #
     # Has to be overridden by the subclass!!!
     def write_node( node )
-      raise "Not implemented"
+      raise NotImplementedError
+    end
+
+    # Returns the node for the language +lang+ which is equal to this +node+.
+    def get_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'] )
-      url = refNode.relpath_to_node( node )
-      "<a href=\"#{url}\">#{title}</a>"
+      "<a href=\"#{refNode.relpath_to_node( node )}\">#{title}</a>"
     end
 
   end

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

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: page.rb 256 2005-04-14 01:13:57Z thomas $
+# $Id: page.rb 277 2005-05-12 08:43:54Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -22,6 +22,7 @@
 
 require 'webgen/plugins/filehandler/filehandler'
 require 'yaml'
+require 'erb'
 
 module FileHandlers
 
@@ -32,7 +33,9 @@ module FileHandlers
     class PageNode < Node; end;
 
     summary "Class for processing page files"
+    depends_on 'FileHandler', 'DefaultContentHandler'
     extension 'page'
+
     add_param 'defaultLangInFilename', false, \
     'If true, the output files for the default language will have the ' \
     'language in the file name like all other page files. If false, they won''t.'
@@ -41,7 +44,9 @@ module FileHandlers
     'the :name part and the file language will be used for the :lang part. If <defaultLangInFilename> is true, the :lang part or the subarray in which '\
     'the :lang part was defined, will be omitted.'
     add_param 'validator', 'xmllint', 'The validator for checking HTML files on their validness. Set to "" or nil to prevent checking.'
-    depends_on 'FileHandler', 'DefaultContentHandler'
+    add_param 'useERB', true, 'Specifies if the content blocks of the page file should be processed with ERB before they are formatted.'
+
+    used_meta_info 'title', 'orderInfo', 'lang', 'blocks', 'useERB'
 
     def create_node( srcName, parent )
       create_node_internally( parse_data( File.read( srcName ), srcName ), analyse_file_name( File.basename( srcName ) ), parent )
@@ -52,12 +57,25 @@ module FileHandlers
     end
 
     def write_node( node )
-      # do nothing if page base node
       templateNode = Webgen::Plugin['TemplateFileHandler'].get_template_for_node( node )
 
-      outstring = templateNode['content'].dup
-
-      Webgen::Plugin['Tags'].substitute_tags( outstring, node, templateNode )
+      useERB = node['useERB'] || ( node['useERB'].nil? && get_param( 'useERB' ) )
+      node['blocks'].each do |blockdata|
+        begin
+          content = ( useERB ? ERB.new( blockdata['data'] ).result( binding ) : blockdata['data'] )
+        rescue Exception => e
+          logger.error { "ERB threw an error while processing an ERB template (<#{node.recursive_value('src')}>, block #{blockdata['name']}): #{e.message}" }
+          content = blockdata['data']
+        end
+        node[blockdata['name']] = Webgen::Plugin['DefaultContentHandler'].get_format( blockdata['format'] ).format_content( content )
+      end
+      begin
+        outstring = ERB.new( templateNode['content'] ).result( binding )
+      rescue Exception => e
+        logger.error { "ERB threw an error while processing an ERB template (<#{templateNode.recursive_value('src')}>: #{e.message}" }
+        outstring = templateNode['content'].dup
+      end
+      outstring = Webgen::Plugin['Tags'].substitute_tags( outstring, node, templateNode )
 
       File.open( node.recursive_value( 'dest' ), File::CREAT|File::TRUNC|File::RDWR ) do |file|
         file.write( outstring )
@@ -69,17 +87,18 @@ module FileHandlers
       end
     end
 
+    # Returns a page node in +dirNode+ which has the name +name+.
     def get_page_node_by_name( dirNode, name )
-      dirNode.find {|node| node['page:name'] == name}
+      dirNode.find {|node| node['int:pagename'] == name}
     end
 
-    # Returns the page node for the given language. +node+ has to be a page node!
-    def get_page_node_for_lang( node, lang )
+    # Returns the page node for the given language.
+    def get_node_for_lang( node, lang )
       dirNode = node.parent
-      pageNode = dirNode.find {|child| child['page:name'] == node['page:name'] && child['lang'] == lang}
+      pageNode = dirNode.find {|child| child['int:pagename'] == node['int:pagename'] && child['lang'] == lang}
       if pageNode.nil?
         self.logger.info { "No page node in language '#{lang}' for page '#{node['title']}' found, trying default language" }
-        pageNode = dirNode.find {|child| child['page:name'] == node['page:name'] && child['lang'] == Webgen::Plugin['Configuration']['lang']}
+        pageNode = dirNode.find {|child| child['int:pagename'] == node['int:pagename'] && child['lang'] == Webgen::Plugin['Configuration']['lang']}
         if pageNode.nil?
           self.logger.warn do
             "No page node in default language (#{Webgen::Plugin['Configuration']['lang']}) " + \
@@ -91,6 +110,14 @@ module FileHandlers
       pageNode
     end
 
+    # Get the HTML link for the page +node+.
+    def get_html_link( node, refNode, title = nil )
+      lang_node = get_node_for_lang( node, refNode['lang'] )
+      title ||=  lang_node['title']
+      super( lang_node, refNode, title )
+    end
+
+
     #######
     private
     #######
@@ -98,7 +125,9 @@ module FileHandlers
     def create_node_internally( data, analysed, parent )
       lang = data['lang'] || analysed.lang
 
-      if node = parent.find {|node| node['page:commonName'] == analysed.name && node['lang'] == lang }
+      pagename = create_output_name( analysed, data['outputNameStyle'] || get_param( 'outputNameStyle' ), true )
+
+      if node = parent.find {|node| node['int:pagename'] == pagename && node['lang'] == lang }
         logger.warn do
           "Two input files in the same language for one page, " + \
           "using <#{node.recursive_value( 'src' )}> instead of <#{analysed.srcName}>"
@@ -108,10 +137,10 @@ module FileHandlers
         node.metainfo = data
         node['lang'] ||= analysed.lang
         node['title'] ||= analysed.title
-        node['menuOrder'] ||= analysed.menuOrder
+        node['orderInfo'] ||= analysed.orderInfo
         node['src'] = analysed.srcName
         node['dest'] = create_output_name( analysed, node['outputNameStyle'] || get_param( 'outputNameStyle' ) )
-        node['page:name'] = create_output_name( analysed, node['outputNameStyle'] || get_param( 'outputNameStyle' ), true )
+        node['int:pagename'] = pagename
         node['processor'] = self
       end
 
@@ -137,7 +166,7 @@ module FileHandlers
             next
           end
           self.logger.debug { "Block '#{blockdata['name']}' formatted using '#{blockdata['format']}'" }
-          options[blockdata['name']] = Webgen::Plugin['DefaultContentHandler'].get_format( blockdata['format'] ).format_content( blocks.shift || '' )
+          blockdata['data'] = blocks.shift || ''
         end
       end
       options
@@ -152,7 +181,7 @@ module FileHandlers
       analysed.srcName   = srcName
       analysed.useLangPart  = ( !get_param( 'defaultLangInFilename' ) && Webgen::Plugin['Configuration']['lang'] == analysed.lang ? false : true )
       analysed.name      = matchData[2]
-      analysed.menuOrder = matchData[1].to_i
+      analysed.orderInfo = matchData[1].to_i
       analysed.title     = matchData[2].tr('_-', ' ').capitalize
 
       self.logger.debug { analysed.inspect }