webgen 0.3.0

data/lib/webgen/node.rb

@@ -0,0 +1,147 @@
+#
+#--
+#
+# $Id: node.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/logging'
+require 'util/composite'
+
+class Node
+
+  include Composite
+
+  attr_reader   :parent
+  attr_accessor :metainfo
+
+  def initialize( parent )
+    @parent = parent
+    @metainfo = Hash.new
+  end
+
+  # Get object +name+ from +metainfo+.
+  def []( name )
+    @metainfo[name]
+  end
+
+  # Assign +value+ to +metainfo+ called +name.
+  def []=( name, value )
+    @metainfo[name] = value
+  end
+
+  # Get the recursive value for metainfo +name+. +ignoreVirtual+ specifies if virtual nodes should
+  # not be appended, but they are traversed nonetheless.
+  def recursive_value( name, ignoreVirtual = true )
+    value = ignoreVirtual && @metainfo['virtual'] ? '' : @metainfo[name]
+    if value.nil?
+      value = ''
+      self.logger.warn { "No meta information called '#{name}' for <#{metainfo['src']}>" }
+    end
+    @parent.nil? ? value : @parent.recursive_value( name, ignoreVirtual ) + value
+  end
+
+
+  # Return the relative path from this node to the destNode, virtual nodes are not used in the
+  # calculation. The destNode can be any non virtual node. If +destNode+ starts with http://, the
+  # relative path to it is the empty string. If +includeDestNode+ is true, then the path of the
+  # destination node is appended to the calculated path.
+  def relpath_to_node( destNode, includeDestNode = true)
+    if destNode['dest'] =~ /^http:\/\//
+      path = ''
+    else
+      from = recursive_value( 'dest' ).sub( /#{self['dest']}$/, '' ).split( '/' )[1..-1] || []
+      to = destNode.recursive_value( 'dest' ).sub( /#{destNode['dest']}$/, '' ).split( '/' )[1..-1] || []
+
+      while from.size > 0 and to.size > 0 and from[0] == to[0]
+        from.shift
+        to.shift
+      end
+
+      from.fill( '..' )
+      from.concat( to )
+      path = ( from.length == 0 ? '.' : from.join( '/' ) )
+      path += '/' + destNode['dest'] if includeDestNode && !destNode.parent.nil?
+    end
+    path
+  end
+
+
+  # Return the node identified by +destString+ relative to the current node.
+  def node_for_string( destString )
+    node = get_node_for_string( destString )
+    if node.nil?
+      self.logger.warn { "Could not get destination node '#{destString}' for <#{metainfo['src']}>" }
+    end
+    node
+  end
+
+  # Check if there is a node for +destString+.
+  def node_for_string?( destString )
+    get_node_for_string( destString ) != nil
+  end
+
+  # Return the level of the node. The level specifies how deep the node is in the hierarchy.
+  def level( ignoreVirtual = true )
+    if self.parent.nil?
+      1
+    else
+      self.parent.level( ignoreVirtual ) \
+      + ( (@metainfo['virtual'] && ignoreVirtual) || (@metainfo['dest'] !~ /\/$/) ? 0 : 1 )
+    end
+  end
+
+  # Checks if the current node is in the subtree in which the supplied node is. This is done by
+  # analyzing the paths of the two nodes.
+  def in_subtree?( node )
+    node = node.parent if node.metainfo['dest'] !~ /\/$/
+    node = node.parent while node['virtual']
+    /^#{node.recursive_value( 'dest' )}/ =~ recursive_value( 'dest' )
+  end
+
+  # Returns the root node for +node+.
+  def self.root( node )
+    node = node.parent until node.parent.nil?
+    node
+  end
+
+  #######
+  private
+  #######
+
+  def get_node_for_string( destString )
+    if /^\// =~ destString
+      node = Node.root( self )
+      destString = destString[1..-1]
+    else
+      node = self.parent || self
+      node = node.parent while !node.nil? && node['virtual']
+    end
+
+    destString.split( '/' ).each do |element|
+      return nil if node.nil?
+      case element
+      when '..' then node = node.parent
+      else node = node.find do |child| /^#{element}\/?$/ =~ child['dest'] end
+      end
+    end
+
+    node
+  end
+
+end

data/lib/webgen/plugins/extloader.rb

@@ -0,0 +1,88 @@
+#
+#--
+#
+# $Id: extloader.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/tags/tags'
+require 'webgen/plugins/filehandler/filehandler'
+
+module Webgen
+
+  # Loads website specific extensions.
+  class ExtensionLoader < Plugin
+
+    summary "Loads extensions from a configuration file"
+    depends_on 'Tags', 'FileHandler'
+    add_param 'extconfig', 'extension.config', 'Configuration file for extensions'
+
+    def parse_config_file
+      file = get_param( 'extconfig' )
+      if File.exists?( file )
+        begin
+          instance_eval( File.read( file ), file )
+        rescue Exception => e
+          self.logger.error { "Error parsing file <#{file}>: #{e.message}" }
+        end
+      end
+    end
+
+    def simple_tag( name, processOutput = true, &block )
+      register_tag( name, Tags::SimpleTag.new( processOutput, block ) )
+    end
+
+    def register_tag( name, processor )
+      Plugin['Tags'].tags[name] = processor
+    end
+
+    def register_filehandler( name, processor )
+      Plugin['FileHandler'].extensions[name] = processor
+    end
+
+  end
+
+end
+
+
+module Tags
+
+  class SimpleTag < DefaultTag
+
+    VIRTUAL = true
+
+    summary "Used by the Tag Loader, provides the interface used by the Tags class"
+
+    def initialize( processOutput, block )
+      super()
+      @processOutput = processOutput
+      @block = block
+    end
+
+    def process_tag( tag, node, refNode )
+      begin
+        @block.call( tag, node, refNode )
+      rescue Exception => e
+        self.logger.error { "Error executing extension code: #{e.message}" }
+        return ''
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,200 @@
+#
+#--
+#
+# $Id: backing.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 'webgen/plugins/filehandler/directory'
+require 'webgen/plugins/filehandler/pagehandler/page'
+
+module FileHandlers
+
+  # Handles page description backing files. Backing files are files that specify meta information
+  # for other files. They are written in YAML and have a very easy structure:
+  #
+  #    filename1.html:
+  #      lang1:
+  #        metainfo1: value1
+  #        metainfo2: value2
+  #      lang2:
+  #        metainfo21: value21
+  #
+  #    dir1/../dir1/filenam2.html:
+  #      lang1:
+  #        title: New titel by backing file
+  #
+  #    /index.html:
+  #      lang1:
+  #        title: YES!!!
+  #
+  # As you can see, you can use relative and absoulte paths in the filenames. However, you cannot
+  # specify meta information for files which are in one of the parent directories of the backing
+  # file. These backing files are very useful if you are using page description files which do not
+  # support meta information, e.g. HTML fragment files.
+  #
+  # Using backing files you can add virtual files and directories. If the file specified in the
+  # entry does not exist, a virtual page node for that entry will be created. This will also create
+  # the whole directory tree this virtual node is in. This allows you, for example, to add external
+  # items to the menu. You need to specify the +dest+ meta information which points to the actual
+  # location of the referenced page. If the virtual page references an external page, you have to
+  # add the +external+ meta information (i.e. set +external+ to +true+).
+  class BackingFileHandler < DefaultHandler
+
+    summary "Handles backing files for page file"
+    extension 'info'
+    depends_on 'FileHandler'
+
+    def initialize
+      super
+      Webgen::Plugin['FileHandler'].add_msg_listener( :AFTER_DIR_READ, method( :process_backing_file ) )
+    end
+
+    def create_node( path, parent )
+      node = Node.new( parent )
+      node['src'] = node['dest'] = node['title'] = File.basename( path )
+      begin
+        node['content'] = YAML::load( File.new( path ) )
+        if !valid_content( node['content'] )
+          node['content'] = {}
+          self.logger.error { "Content of backing file <#{backingFile.recursive_value( 'src' )}> not correctcly structured" }
+        end
+      rescue
+        self.logger.error { "Content not correctly formatted (should be valid YAML) in backing file <#{path}>" }
+      ensure
+        node['content'] ||= {}
+      end
+      node['processor'] = self
+      node
+    end
+
+    def write_node( node )
+      # nothing to write
+    end
+
+    #######
+    private
+    #######
+
+    def valid_content( data )
+      data.kind_of?( Hash ) \
+      && data.all? {|k,v| v.kind_of?( Hash ) && v.all? {|k1,v1| v1.kind_of?( Hash )} }
+    end
+
+    def process_backing_file( dirNode )
+      backingFiles = dirNode.find_all {|child| /\.#{Webgen::Plugin.config[self.class.name].extension}$/ =~ child['src'] }
+
+      backingFiles.each do |backingFile|
+        backingFile['content'].each do |filename, data|
+          if dirNode.node_for_string?( filename )
+            backedFile = dirNode.node_for_string( filename )
+            data.each do |language, fileData|
+              langFile = Webgen::Plugin['PageHandler'].get_lang_node( backedFile, language )
+              next unless langFile['lang'] == language
+
+              self.logger.info { "Setting meta info data on file <#{langFile.recursive_value( 'dest' )}>" }
+              langFile.metainfo.update( fileData )
+            end
+          else
+            add_virtual_node( dirNode, filename, data )
+          end
+        end
+      end
+    end
+
+
+    def add_virtual_node( dirNode, path, data )
+      dirname = File.dirname( path ).sub( /^.$/, '' )
+      filename = File.basename( path )
+      dirNode = create_path( dirname, dirNode )
+
+      data.each do |language, filedata|
+        self.logger.debug { "Trying to create virtual node for '#{filename}'..." }
+        filedata['lang'] = language
+
+        handler = VirtualPageHandler.new
+        pageNode = handler.create_node_from_data( '', filename, dirNode )
+        unless pageNode.nil?
+          pageNode['processor'] = Webgen::Plugin['VirtualPageHandler']
+          self.logger.debug { "Adding virtual page node <#{pageNode.recursive_value( 'src', false )}> to directory <#{dirNode.recursive_value( 'src' )}>" }
+          dirNode.add_child( pageNode )
+        end
+        pageNode ||= Webgen::Plugin['VirtualPageHandler'].get_page_node( filename, dirNode ) #TODO
+        node = Webgen::Plugin['VirtualPageHandler'].get_lang_node( pageNode, language )
+        node.metainfo.update( filedata )
+        self.logger.info { "Created virtual node <#{node.recursive_value( 'src' )}> (#{language}) in <#{dirNode.recursive_value( 'dest' )}> " \
+          "referencing '#{node['dest']}'" }
+      end
+    end
+
+
+    def create_path( dirname, dirNode )
+      if /^#{File::SEPARATOR}/ =~ dirname
+        node = Node.root( dirNode )
+        dirname = dirname[1..-1]
+      else
+        node = dirNode
+      end
+
+      parent = node
+      dirname.split( File::SEPARATOR ).each do |element|
+        case element
+        when '..'
+          node = node.parent
+        else
+          node = node.find do |child| /^#{element}\/?$/ =~ child['src'] end
+        end
+        if node.nil?
+          node = FileHandlers::DirHandler::DirNode.new( parent, element )
+          node['processor'] = Webgen::Plugin['VirtualDirHandler']
+          parent.add_child( node )
+          self.logger.info { "Created virtual directory <#{node.recursive_value( 'dest' )}>" }
+        end
+        parent = node
+      end
+
+      return node
+    end
+
+  end
+
+
+  # Handles virtual directories, that is, directories that do not exist in the source tree.
+  class VirtualDirHandler < DirHandler
+
+    summary "Handles virtual directories"
+    depends_on "DirHandler"
+
+    def write_node( node )
+    end
+
+  end
+
+  # Handles virtual pages, that is, pages that do not exist in the source tree.
+  class VirtualPageHandler < PageHandler
+
+    summary "Handles virtual pages"
+    depends_on "PageHandler"
+
+    def write_node( node )
+    end
+
+  end
+
+end

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

@@ -0,0 +1,96 @@
+#
+#--
+#
+# $Id: directory.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'
+
+module FileHandlers
+
+  # Handles directories.
+  class DirHandler < DefaultHandler
+
+    # Specialized node describing a directory.
+    class DirNode < Node
+
+      def initialize( parent, name )
+        super( parent )
+        self['title'] = self['directoryName'] = name
+        self['src'] = self['dest'] = name + '/'
+        self['processor'] = Webgen::Plugin['DirHandler']
+      end
+
+      def []( name )
+        process_dir_index if super('indexFile').nil? && name == 'indexFile'
+        super
+      end
+
+      def process_dir_index
+        node = Webgen::Plugin['PageHandler'].get_page_node( Webgen::Plugin['DirHandler']['indexFile'], self )
+        if node
+          self.logger.info { "Directory index file for <#{self.recursive_value( 'src' )}> => <#{node.recursive_value( 'src', false )}>" }
+          self['indexFile'] = node
+        else
+          self.logger.warn { "No directory index file found for directory <#{self.recursive_value( 'src' )}>" }
+          self['indexFile'] = nil
+        end
+      end
+
+    end
+
+
+    summary "Handles directories"
+    extension :dir
+    add_param 'indexFile', 'index.html', 'The default file name for the directory index file.'
+    depends_on 'FileHandler'
+
+
+    # Return a new DirNode.
+    def create_node( path, parent )
+      DirNode.new( parent, File.basename( path ) )
+    end
+
+    # Create 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 )
+    end
+
+    # Return the language 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_lang_node( node, lang = node['lang'] )
+      if node['indexFile']
+        node['indexFile']['processor'].get_lang_node( node['indexFile'], lang )
+      else
+        node
+      end
+    end
+
+    # Get the HTML link for the directory +node+.
+    def get_html_link( node, refNode, title = nil )
+      lang_node = get_lang_node( node, refNode['lang'] )
+      title ||=  lang_node['directoryName'] || node['directoryName']
+      super( lang_node, refNode, title )
+    end
+
+  end
+
+end