webgen 0.3.0

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

@@ -0,0 +1,59 @@
+#
+#--
+#
+# $Id: filecopy.rb 203 2005-02-21 18:42:04Z thomas $
+#
+# webgen: template based static website generator
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+require 'fileutils'
+require 'webgen/plugins/filehandler/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 FileCopyHandler < DefaultHandler
+
+    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.'
+    depends_on 'FileHandler'
+
+    def initialize
+      super
+      get_param( 'types' ).each do |type|
+        extension( type )
+      end
+    end
+
+    def create_node( srcName, parent )
+      node = Node.new( parent )
+      node['dest'] = node['src'] = node['title'] = File.basename( srcName )
+      node['processor'] = self
+      node
+    end
+
+    # Copy the file to the destination directory if it has been modified.
+    def write_node( node )
+      FileUtils.cp( node.recursive_value( 'src' ), node.recursive_value( 'dest' ) ) if Webgen::Plugin['FileHandler'].file_modified?( node )
+    end
+
+  end
+
+end

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

@@ -0,0 +1,209 @@
+#
+#--
+#
+# $Id: filehandler.rb 203 2005-02-21 18:42:04Z thomas $
+#
+# webgen: template based static website generator
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+require 'util/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"
+    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 'ignored', ['.svn', 'CVS'], 'Specifies path names via regular expresssions which should be ignored.'
+
+
+    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 )
+    end
+
+
+    # Recursively 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'] + '/'
+      end
+      root
+    end
+
+
+    # Recursively writes out the tree specified by +node+.
+    def write_tree( node )
+      self.logger.info { "Writing <#{node.recursive_value('dest')}>" }
+
+      node['processor'].write_node( node )
+
+      node.each do |child|
+        write_tree child
+      end
+    end
+
+
+    # Returns true if the source file specified by +node+ 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?( node )
+      src = node.recursive_value( 'src' )
+      dest = node.recursive_value( '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
+      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
+      end
+
+      return node
+    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
+    end
+
+
+    def handle_directory( path, parent )
+      node = nil
+
+      if @extensions.has_key?( :dir )
+        node = @extensions[:dir].create_node( path, parent )
+        node['processor'] = @extensions[:dir]
+
+        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?
+        end
+
+        dispatch_msg( :AFTER_DIR_READ, node )
+      end
+
+      return node
+    end
+
+  end
+
+  # The default handler which is the super class of all file handlers.
+  class DefaultHandler < Webgen::Plugin
+
+    VIRTUAL = true
+
+    summary "Base class of all file handler plugins"
+
+    def initialize
+      extension( Webgen::Plugin.config[self.class.name].extension ) if Webgen::Plugin.config[self.class.name].extension
+    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
+    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.
+    #
+    # Has to be overridden by the subclass!!!
+    def create_node( path, parent )
+      raise "Not implemented"
+    end
+
+    # Asks the plugin to write out the node.
+    #
+    # Has to be overridden by the subclass!!!
+    def write_node( node )
+      raise "Not implemented"
+    end
+
+    # Returns the language node for the given +node+. The default implementation returns the node
+    # itself. You can optionally specify the language of the node which should be returned. If not
+    # specified the language of the node is used.
+    def get_lang_node( node, 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>"
+    end
+
+  end
+
+end

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

@@ -0,0 +1,43 @@
+#
+#--
+#
+# $Id: html.rb 203 2005-02-21 18:42:04Z thomas $
+#
+# webgen: template based static website generator
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+require 'webgen/plugins/filehandler/pagehandler/page'
+
+module ContentHandlers
+
+  # Handles HTML content. Assumes that the content is already valid HTML.
+  class HTMLHandler < ContentHandler
+
+    summary "Handles HTML formatted content"
+    depends_on "PageHandler"
+
+    def initialize
+      register_format( 'html' )
+    end
+
+    def format_content( txt )
+      txt
+    end
+
+  end
+
+end

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

@@ -0,0 +1,53 @@
+#
+#--
+#
+# $Id: markdown.rb 203 2005-02-21 18:42:04Z thomas $
+#
+# webgen: template based static website generator
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+
+begin
+  require 'bluecloth'
+  require 'webgen/plugins/filehandler/pagehandler/page'
+
+  module ContentHandlers
+
+    # Handles text formatted in Markdown format using BlueCloth.
+    class MarkdownHandler < ContentHandler
+
+      summary "Handles content formatted in Markdown format using BlueCloth"
+      depends_on "PageHandler"
+
+      def initialize
+        register_format( 'markdown' )
+      end
+
+      def format_content( txt )
+        BlueCloth.new( txt ).to_html
+      rescue
+        self.logger.error { "Error converting Markdown text to HTML" }
+        ''
+      end
+
+    end
+
+  end
+
+rescue LoadError => e
+  self.logger.warn { "Markdown not available as content format as BlueCloth could not be loaded: #{e.message}" }
+end

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

@@ -0,0 +1,205 @@
+#
+#--
+#
+# $Id: page.rb 203 2005-02-21 18:42:04Z thomas $
+#
+# webgen: template based static website generator
+# Copyright (C) 2004 Thomas Leitner
+#
+# This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+# General Public License as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along with this program; if not,
+# write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+#++
+#
+
+require 'webgen/plugins/filehandler/filehandler'
+require 'yaml'
+
+module FileHandlers
+
+  # Super class for all page description files. Provides helper methods so that writing new plugins
+  # for page description files is easy.
+  class PageHandler < DefaultHandler
+
+    # Specialized node describing a page. A page node itself is virtual, it has sub nodes which
+    # describe the page files in all available languages.
+    class PageNode < Node
+
+      def initialize( parent, basename )
+        super( parent )
+        self['page:basename'] = self['title'] = basename
+        self['src'] = self['dest'] = basename
+        self['virtual'] = true
+        self['processor'] = Webgen::Plugin['PageHandler']
+      end
+
+    end
+
+    summary "Class for processing page files"
+    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.'
+    add_param 'defaultContentFormat', 'textile', 'The default content format used in page files'
+    depends_on 'FileHandler'
+
+    attr_reader :formats
+
+    def initialize
+      super
+      @formats = Hash.new( ContentHandlers::ContentHandler.new )
+    end
+
+    def create_node( srcName, parent )
+      create_node_internally( parse_data( File.read( srcName ), srcName ), analyse_file_name( File.basename( srcName ) ), parent )
+    end
+
+    def create_node_from_data( data, srcName, parent )
+      create_node_internally( parse_data( data, srcName ), analyse_file_name( File.basename( srcName ) ), parent )
+    end
+
+    def write_node( node )
+      # do nothing if page base node
+      return unless node['virtual'].nil?
+      templateNode = Webgen::Plugin['TemplateFileHandler'].get_template_for_node( node )
+
+      outstring = templateNode['content'].dup
+
+      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 )
+      end
+    end
+
+    def page_node_exists?( basename, dirNode )
+      dirNode.find {|node| node['page:basename'] == basename}
+    end
+    alias :get_page_node :page_node_exists?
+
+    def lang_node_exists?( pageNode, lang )
+      langNode = pageNode.find {|child| child['lang'] == lang }
+      return !langNode.nil?
+    end
+
+    def get_lang_node( node, lang = node['lang'] )
+      node = node.parent unless node['page:basename']
+      langNode = node.find {|child| child['lang'] == lang} ||
+                 node.find {|child| child['lang'] == Webgen::Plugin['Configuration']['lang']}
+      if langNode.nil?
+        langNode = node.children[0]
+        self.logger.warn do
+          "No input file in language '#{lang}' nor the default language (#{Webgen::Plugin['Configuration']['lang']}) found," +
+          "using first available input file for <#{node['title']}>"
+        end
+      end
+      langNode
+    end
+
+    #######
+    private
+    #######
+
+    def create_node_internally( data, analysed, parent )
+      pageNodeExisted = get_page_node( analysed.baseName, parent )
+      pageNode = pageNodeExisted || PageNode.new( parent, analysed.baseName )
+
+      lang = data['lang'] || analysed.lang
+
+      if lang_node_exists?( pageNode, lang )
+        pageNodeExisted = false
+        logger.warn do
+          "Two input files in the same language for one page, " + \
+          "using <#{get_lang_node( pageNode, lang ).recursive_value( 'src' )}> " + \
+          "instead of <#{analysed.srcName}>"
+        end
+      else
+        node = Node.new( pageNode )
+        node.metainfo = data
+        node['src'] = analysed.srcName
+        node['dest'] = analysed.urlName
+        node['lang'] ||= analysed.lang
+        node['title'] ||= analysed.title
+        node['menuOrder'] ||= analysed.menuOrder
+        node['processor'] = self
+        pageNode.add_child( node )
+      end
+
+      return ( pageNodeExisted ? nil : pageNode )
+    end
+
+    def parse_data( data, srcName )
+      options = {}
+      blocks = data.split( /^---\s*$/ )
+      if blocks.length > 0
+        if blocks[0] == ''
+          begin
+            options = YAML::load( blocks[1] )
+          rescue ArgumentError => x
+            self.logger.error { "Error parsing options for file <#{srcName}>: #{x.message}" }
+          end
+          blocks[0..1] = []
+        end
+        blocks.each {|b| b.gsub!( /^(\\+)(---\s*)$/ ) {|m| "\\" * ($1.length / 2) + $2 } }
+        (options['blocks'] ||= [{'name'=>'content', 'format'=>get_param( 'defaultContentFormat' )}]).each do |blockdata|
+          self.logger.debug { "Block '#{blockdata['name']}' formatted using '#{blockdata['format']}'" }
+          options[blockdata['name']] = @formats[blockdata['format']].format_content( blocks.shift || '' )
+        end
+      end
+      options
+    end
+
+    def analyse_file_name( srcName )
+      matchData = /^(?:(\d+)\.)?([^.]*?)(?:\.(\w\w))?\.(.*)$/.match( srcName )
+      analysed = OpenStruct.new
+
+      self.logger.info { "Using default language for file <#{srcName}>" } if matchData[3].nil?
+      analysed.lang      = matchData[3] || Webgen::Plugin['Configuration']['lang']
+      analysed.baseName  = matchData[2] + '.html'
+      analysed.srcName   = srcName
+      langPart = ( !get_param( 'defaultLangInFilename' ) && Webgen::Plugin['Configuration']['lang'] == analysed.lang ? '' : '.' + analysed.lang )
+      analysed.urlName   = matchData[2] + langPart + '.html'
+      analysed.menuOrder = matchData[1].to_i
+      analysed.title     = matchData[2].tr('_-', ' ').capitalize
+
+      self.logger.debug { analysed.inspect }
+
+      analysed
+    end
+
+  end
+
+end
+
+
+module ContentHandlers
+
+  class ContentHandler < Webgen::Plugin
+
+    VIRTUAL = true
+
+    summary "Base class for all page file content handlers"
+
+    # Register the format specified by a subclass.
+    def register_format( fmt )
+      self.logger.info { "Registering class #{self.class.name} for formatting '#{fmt}'" }
+      Webgen::Plugin['PageHandler'].formats[fmt] = self
+    end
+
+    # Format the given +content+. Should be overridden in subclass!
+    def format_content( content )
+      self.logger.error { "Invalid content format specified, copying source verbatim!" }
+      content
+    end
+
+  end
+
+end