webgen 0.4.7 → 0.5.0

data/doc/sourcehandler/metainfo.page

@@ -0,0 +1,117 @@
+---
+title: SourceHandler::Metainfo
+---
+
+> TODO: This information needs to be updated
+{.exclamation}
+
+### The meta information backing file {#metainfo-file}
+
+The meta information backing file contains meta information about files/directories in the source
+directory. It has two sections both of which have to be in YAML format and both have to have the
+same structure: a source backing section and an output backing section which is optional. The
+sections are separated by three dashes on an otherwise empty line.
+
+The source backing section is used to apply meta information to a file before a node for this file
+is created. A file handler plugin can therefore use this meta information during the creation of the
+node. Make sure that you use a valid source path, i.e. a path that resolves to a file in the source
+directory!
+
+The output backing section is used to apply meta information after _all_ nodes have been created and
+to create so called "virtual nodes". The paths specified in the output backing section have to be:
+
+* valid (localized) canonical names (for assigning meta info to existing nodes) or
+* a path pattern for matching against localized canonical names (for assigning meta info to multiple
+  existing nodes)
+* the desired output names (for creating virtual nodes)!
+
+The different cases are handled like this:
+
+* If a path has a `*` or a `?` in it, it is considered a path pattern and the meta information is
+  assigned to all nodes whose localized canonical name matches the pattern.
+
+  > Since the localized canonical name of the nodes are used, you need to remember that the pattern
+  > `**/*.html` sets the meta information on all nodes ending in `.html` whereas the pattern
+  > `**/*.en.html` only sets the meta information on English nodes ending in `.html`.
+  {.information}
+
+* If a specified path resolves to an already created node, the meta information is applied to this
+  node.
+
+* If the path ends in an slash, a directory node is created with the meta information.
+
+* Otherwise, a virtual node is created with the specified meta information and empty content - a
+  virtual node _never_ creates a real output file!
+
+This facility can be used, for example, to specify meta information common to a set of nodes (for
+example, the author of blog pages), to include links to external web pages in menus or to create a
+whole menu with custom sections and multiple references in different sections to the same node!
+
+Following is a sample meta information backing file with explanations afterwards:
+
+    index.page:
+      inMenu: true
+      sort_info: 2
+
+    images:
+      indexFile: ~
+    ---
+    index.html:
+      inMenu: false
+
+    wiki.html:
+      title: Link to wiki
+      url: http://myhost.com/path/to/my/wiki
+      inMenu: true
+      sort_info: 5
+
+    api.html:
+      title: API Reference
+      url: http://myhost.com/api
+
+    virtdir/:
+      indexFile: index.html
+
+    virtdir/index.html:
+      title: A virtual index file
+      inMenu: true
+      url: /index.page
+
+    virtdir/other.html:
+      inMenu: true
+      url: /otherdir/linked.de.page
+
+    **/*.html:
+      author: The Real Author
+
+The above sample meta information backing file consists of both sections: the mandatory source
+section and the optional output section. As you can see each section is described using a hash of
+hashes, i.e. the keys are paths and the values are the meta information hashes.
+
+The source section specifies additional meta information for the `index.page` file and for the
+`images` directory: the `index.page` gets the `inMenu` and `sort_info` meta information set and it
+is specified that the `images` directory has no `indexFile`.
+
+The output section is more interesting than the source section:
+
+* The first entry references an existing file, therefore the meta information for that file
+  (`index.html`) is set appropriately.
+
+* The second entry specifies that under the `root` directory a virtual node with the path
+  `wiki.html` should be created (the node will be virtual as the path references no existing file).
+  It should have the specified title and should be in the menu with the specified
+  order. Furthermore, a special *`url`* key is used. This key can only be used for virtual file
+  nodes (not directory nodes) in the output section and it specifies the link target for the node.
+  So, whenever a reference to `wiki.html` is requested the resolved `url` is returned. This `url`
+  can be a link to an outside page or it can refer to another node, as described below. The `url` is
+  assumed to be relative to the directory the virtual node is in.
+
+* The third entry also specifies a virtual node linking to an external page, but one which will not
+  appear in a menu. Such nodes are normally inserted into the output section so that the
+  Tag/Relocatable plugin can be used.
+
+* The next three entries add virtual entries to the menu to show how one page can appear in more
+  than one directory: the `virtdir/index.html` links to the top level `index.page` and
+  `virtdir/other.html` links to a page in another subdirectory, namely `/otherdir/linked.de.page`.
+
+* The last entry set the `author` meta information on all nodes that end with `.html`.

data/doc/sourcehandler/page.page

@@ -0,0 +1,32 @@
+---
+title: Webgen::SourceHandler::Page
+---
+
+> TODO: this needs to be redone!
+{.exclamation}
+
+
+### Processing
+
+TODO: redo this whole section
+
+There is a well defined procesing order for files in WebPage Format:
+
+* After reading in the file, it is split into the blocks.
+
+* Each content block is converted to HTML (depends on the format specifier) and the HTML sections
+  are resolved (caveat: only those with an `id` attribute)
+
+* When writing out the file, the converted content is first processed with ERB (if specified to do
+  so),
+
+* then webgen tags are replaced and,
+
+* finally, the result is written.
+
+The first two steps happen when the file is read and the last three when the file is written.
+
+#### Converting to HTML
+
+The conversion of a content block to HTML is done via the ContentConverter plugins. Each plugin is
+able to convert a special marked-up text to HTML.

data/doc/webgen_page_format.page

@@ -0,0 +1,126 @@
+---
+title: Webgen Page Format
+---
+## Webgen Page Format
+
+The Webgen Page Format is a custom format designed primarily for page and template files. It
+consists of an optional meta information block and one or more blocks of data; it is very simple and
+easy to use.
+
+## Structure
+
+A file using the Webgen Page Format consists of one or more blocks which are the smallest units
+recongnized. Blocks are separated from each other through a line containing three dashes. This is
+illustrated in the following examples which are all valid files in WebPage Format:
+
+Example 1:
+
+    Here is a block!
+
+Example 2:
+
+    This is one block of the file
+    ---
+    This is another block.
+
+Example 3:
+
+    Block 1
+    --- name:block2
+    Block 2
+    --- name:block3
+    Block 3...
+
+If you want to use three dashes in a block but you don't want to end the block, you have to escape
+them with a backslash character, like this:
+
+    Block 1
+    \---
+    still Block 1
+    --- name:block2
+    Block 2
+
+All of the above examples show one kind of block, the content block. However, there may also be
+another type of block: the meta information block. Following is a short description of both kinds,
+starting with the meta information block.
+
+
+### Meta Information Block
+
+Each file in Webgen Page Format can have zero or one meta information blocks. This block is
+specified at the beginning of the file. To tell the parser that the first block is the meta
+information block and not a content block, you have to start the file with three dashes:
+
+    ---
+    title: The title set by Meta info
+    ---
+    This is the content of the file
+
+The above defines a meta information block and a content block. The meta information block has to be
+in YAML format and should contain key-value pairs of meta information. [YAML](http://www.yaml.org)
+is a simple markup language designed for ease of use and although you define structured data with
+it, it feels like just writing a plain text document.
+
+
+### Content Blocks
+
+A content block is used to provide content in a specific format. Each file in Webgen Page Format
+needs to have at least one content block which may be empty. However, it can have as many content
+blocks as necessary. Each content block needs to have a unique name and additional options can also
+be set.
+
+The name uniquely identifies a content block and is used to access it. The only option used by
+webgen is the `pipeline` option which specifies the processing pipeline for the block. The
+processing pipeline is used for rendering the block by using the specified content processors in the
+specified order. There are several different content processors available - have a look at the
+[content processor listing]({relocatable: contentprocessor/}) for an overview.
+
+There are also defaults for the name and the options of a block but they can be overwritten. You can
+use one of two ways to do this:
+
+* you either specify the name and additional options of the block on the starting line with the
+  three dashes
+
+* or you use the special meta information `block` to define the names and options of one or all
+  blocks.
+
+The following example uses the first technique to override the name and/or the `pipeline` option:
+
+    1. content block of the file
+    --- name:sidebar pipeline:maruku,tags
+    2. content block of the file
+    --- name:other
+    3. content block of the file
+
+The first block has no identifieres set (there is no line with three dashes and the identifieres).
+Therefore the default value for the name is used: `content`. The second block is named `sidebar` and
+uses the processing pipeline `maruku,tags`. As you can see, the name of a block as well as
+additional options are specified by stating the key (e.g. `name` or `pipeline`) followed by a colon
+and the value. Multiple options are separated via one or more spaces.
+
+> Only the first block gets the default name of `content`. The second and following blocks have
+> numbered names like `block2`, `block3` and so on.
+{.information}
+
+You can also set the name and additional options of the content blocks by using the special `blocks`
+meta information. It is a hash using the index of a block (or the special value `default`) as key
+and the options as values. The above example can therefore also be written like this:
+
+    ---
+    blocks: \{2: {name: sidebar, pipeline: maruku,tags}, 3: {name: other}}
+    ---
+    1. content block of the file
+    ---
+    2. content block of the file
+    ---
+    3. content block of the file
+
+When selecting a value for the name of a block or an option, the following precedence is used (from
+low to high):
+
+* global defaults set via the `default` key of the meta information `blocks`
+* block defaults set via the meta information `blocks`
+* the `--- line` options
+
+As stated above, the "option" `name` is special insofar that when it is not set, an automatic name
+gets generated.

data/lib/webgen/blackboard.rb

@@ -0,0 +1,73 @@
+module Webgen
+
+  # A blackboard object provides two features for inter-object communication:
+  #
+  # * services: An object can add a service to the blackboard which can be called by any other
+  #             object by just specifing the service name. Therefore it is easy to change the
+  #             underlying implementation of the service and there are no hard dependencies on
+  #             specific class or method names.
+  #
+  # * listeners: Objects may register themselves for specific messsage names and get notified when
+  #              such a message gets dispatched.
+  class Blackboard
+
+    # Create a new Blackboard object.
+    def initialize
+      @listener = {}
+      @services = {}
+    end
+
+    # Add the +callable_object+ or the given block as listener for the messages +msg_names+ (one
+    # message name or an array of message names).
+    def add_listener(msg_names = nil, callable_object = nil, &block)
+      callable_object = callable_object || block
+      if !callable_object.nil?
+        raise ArgumentError, "The listener needs to respond to 'call'" unless callable_object.respond_to?(:call)
+        [msg_names].flatten.compact.each {|name| (@listener[name] ||= []) << callable_object}
+      else
+        raise ArgumentError, "You have to provide a callback object or a block"
+      end
+    end
+
+    # Remove the given object from the dispatcher queues of the message names specified in
+    # +msg_names+.
+    def del_listener(msg_names, callable_object)
+      [msg_names].flatten.each {|name| @listener[name].delete(callable_object) if @listener[name]}
+    end
+
+    # Dispatch the message +msg_name+ to all listeners for this message, passing the given
+    # arguments.
+    def dispatch_msg(msg_name, *args)
+      return unless @listener[msg_name]
+      @listener[msg_name].each {|obj| obj.call(*args)}
+    end
+
+    # Add a service named +service_name+ provided by the +callable_object+ or a block to the
+    # blackboard.
+    def add_service(service_name, callable_object = nil, &block)
+      callable_object = callable_object || block
+      if @services.has_key?(service_name)
+        raise "The service name '#{service_name}' is already taken"
+      else
+        raise ArgumentError, "An object providing a service needs to respond to 'call'" unless callable_object.respond_to?(:call)
+        @services[service_name] = callable_object
+      end
+    end
+
+    # Delete the service +service_name+.
+    def del_service(service_name)
+      @services.delete(service_name)
+    end
+
+    # Invoke the service called +service_name+ with the given arguments.
+    def invoke(service_name, *args, &block)
+      if @services.has_key?(service_name)
+        @services[service_name].call(*args, &block)
+      else
+        raise ArgumentError, "No such service named '#{service_name}' available"
+      end
+    end
+
+  end
+
+end

data/lib/webgen/cache.rb

@@ -0,0 +1,77 @@
+require 'set'
+require 'facets/kernel/constant'
+
+module Webgen
+
+  # A cache object provides access to various caches to speed up rendering of a website.
+  #
+  # permanent:: The permanent cache should be used for data that should be available between webgen
+  #             runs.
+  #
+  # volatile:: The volatile cache is used for data that can easily be regenerated but might be
+  #            expensive to do so. This cache is not stored between webgen runs.
+  #
+  # standard:: The standard cache saves data between webgen runs and returns the cached data (not
+  #            the newly set data) if it is available. This is useful, for example, to store file
+  #            modifcation times and check if a file has been changed between runs.
+  class Cache
+
+    # The permanent cache hash.
+    attr_reader :permanent
+
+    # Create a new cache object.
+    def initialize()
+      @old_data = {}
+      @new_data = {}
+      @volatile = {}
+      @permanent = {:classes => []}
+    end
+
+    # Return the cached data (or, if it is not available, the new data) identified by +key+ from the
+    # standard cache.
+    def [](key)
+      if @old_data.has_key?(key)
+        @old_data[key]
+      else
+        @new_data[key]
+      end
+    end
+
+    # Store +value+ identified by +key+ in the standard cache.
+    def []=(key, value)
+      @new_data[key] = value
+    end
+
+    # Restore the caches from +data+ and recreate all cached instances (see #instance).
+    def restore(data)
+      @old_data, @permanent = *data
+      @permanent[:classes].each {|klass| instance(klass)}
+    end
+
+    # Return all caches that should be available between webgen runs.
+    def dump
+      [@old_data.merge(@new_data), @permanent]
+    end
+
+    # Return the volatile cache hash. If volatile caching has not been enabled, a new hash is
+    # returned on every invocation!
+    def volatile
+      (@volatile[:enabled] ? @volatile : {})
+    end
+
+    # Enable the volatile cache.
+    def enable_volatile_cache
+      @volatile[:enabled] = true
+    end
+
+    # Return the unique instance of the class +name+. This method should be used when it is
+    # essential that webgen uses only one object of a class or when an object should automatically
+    # be recreated upon cache restoration (see #restore).
+    def instance(name)
+      @permanent[:classes] << name unless @permanent[:classes].include?(name)
+      (@volatile[:classes] ||= {})[name] ||= constant(name).new
+    end
+
+  end
+
+end

data/lib/webgen/cli.rb

@@ -1,457 +1,116 @@
-#
-#--
-#
-# $Id: cli.rb 601 2007-02-14 21:20:44Z 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 'rbconfig'
-require 'fileutils'
 require 'cmdparse'
 require 'webgen/website'
+require 'webgen/version'
 
 module Webgen
 
-  class Color
-
-    @@colors = {:bold => [0, 1], :green => [0, 32], :lblue => [1, 34], :lred => [1, 31], :reset => [0, 0]}
-
-    def self.colorify
-      @@colors.each do |color, values|
-        module_eval <<-EOF
-        def Color.#{color.to_s}( text = nil )
-          "\e[#{values[0]};#{values[1]}m" + (text.nil? ? '' : text + self.reset)
+  # Namespace for all classes that act as CLI commands.
+  #
+  # = Implementing a CLI command
+  #
+  # Each CLI command class needs to be put into this module and has to end with +Command+, otherwise
+  # it is not used. A CLI command is an extension that can be invoked from the webgen command and
+  # thus needs to be derived from CmdParse::Command. For detailed information on this class and the
+  # whole cmdparse package have a look at http://cmdparse.rubyforge.org!
+  #
+  # = Sample CLI command
+  #
+  # Here is a sample CLI command extension:
+  #
+  #   require 'webgen/cli'
+  #
+  #   class Webgen::CLI::SampleCommand < CmdParse::Command
+  #
+  #     def initialize
+  #       super('sample', false)
+  #       self.short_desc = "This sample command just outputs its parameters"
+  #       self.description = Utils.format("Uses the global verbosity level and outputs additional " +
+  #         "information when the level is set to verbose!")
+  #       @username = nil
+  #       self.options = CmdParse::OptionParserWrapper.new do |opts|
+  #         opts.separator "Options:"
+  #         opts.on('-u', '--user USER', String,
+  #           'Specify an additional user name to output') {|@username|}
+  #       end
+  #     end
+  #
+  #     def execute(args)
+  #       if args.length == 0
+  #         raise OptionParser::MissingArgument.new('ARG1 [ARG2 ...]')
+  #       else
+  #         puts "Command line arguments:"
+  #         args.each {|arg| puts arg}
+  #         if commandparser.verbosity == :verbose
+  #           puts "Yeah, some additional information is always cool!"
+  #         end
+  #         puts "The entered username: #{@username}" if @username
+  #       end
+  #     end
+  #
+  #   end
+  #
+  # Note the use of Utils.format in the initialize method so that the long text gets wrapped
+  # correctly! The Utils class provides some other useful methods, too!
+  #
+  # For information about which attributes are available on the webgen command parser instance have
+  # a look at Webgen::CLI::CommandParser!
+  module CLI
+
+    autoload :RunCommand, 'webgen/cli/run_command'
+    autoload :CreateCommand, 'webgen/cli/create_command'
+
+    autoload :Utils, 'webgen/cli/utils'
+
+
+    # This is the command parser class used for handling the webgen command line interface. After
+    # creating an instance, the inherited #parse method can be used for parsing the command line
+    # arguments and executing the requested command.
+    class CommandParser < CmdParse::CommandParser
+
+      # The website directory. Default: the current working directory.
+      attr_reader :directory
+
+      # The verbosity level. Default: <tt>:normal</tt>
+      attr_reader :verbosity
+
+      # The log level. Default: <tt>Logger::WARN</tt>
+      attr_reader :log_level
+
+      def initialize # :nodoc:
+        super(true)
+        @directory = Dir.pwd
+        @verbosity = :normal
+        @log_level = ::Logger::WARN
+
+        self.program_name = "webgen"
+        self.program_version = Webgen::VERSION
+        self.options = CmdParse::OptionParserWrapper.new do |opts|
+          opts.separator "Global options:"
+          opts.on("--directory DIR", "-d", String, "The website directory (default: the current directory)") {|@directory|}
+          opts.on("--verbose", "-v", "Print more output") { @verbosity = :verbose }
+          opts.on("--quiet", "-q", "No output") { @verbosity = :quiet }
+          opts.on("--log-level", "-l", [0, 1, 2, 3], "The logging level (0..debug, 3..error)") {|@log_level|}
+          opts.on("--log-filter", "-f", Regexp, 'Filter for logging events') {|@log_filter|}
         end
-        EOF
-      end
-    end
-
-    def self.method_missing( id, text = nil )
-      text.to_s
-    end
-
-  end
-
-
-  class CliUtils
-
-    def self.format( content, indent = 0, width = 100 )
-      content ||= ''
-      return [content] if content.length + indent <= width
-      lines = []
-      while content.length + indent > width
-        index = content[0..(width-indent-1)].rindex(' ')
-        lines << (lines.empty? ? '' : ' '*indent) + content[0..index]
-        content = content[index+1..-1]
-      end
-      lines << ' '*indent + content unless content.strip.empty?
-      lines
-    end
-
-    def self.headline( text, indent = 2 )
-      ' '*indent + "#{Color.bold( text )}"
-    end
-
-    def self.section( text, ljustlength = 0, indent = 4, color = :green )
-      ' '*indent + "#{Color.send( color, text )}".ljust( ljustlength - indent + Color.send( color ).length + Color.reset.length )
-    end
-
-    def self.dirinfo_output( opts, name, dirinfo )
-      ljust = 15 + opts.summary_indent.length
-      opts.separator CliUtils.section( 'Name', ljust, opts.summary_indent.length + 2 ) + "#{Color.lred( name )}"
-
-      dirinfo.infos.sort.each do |name, value|
-        desc = CliUtils.format( value, ljust )
-        opts.separator CliUtils.section( name.capitalize, ljust, opts.summary_indent.length + 2 ) + desc.shift
-        desc.each {|line| opts.separator line}
-      end
-      opts.separator ''
-    end
-
-  end
-
-
-  class CreateCommand < CmdParse::Command
-
-    def initialize
-      super( 'create', false )
-      self.short_desc = "Creates the basic directories and files for webgen."
-      self.description = CliUtils.format( "\nIf the global verbosity level is set to 0 or 1, the created files are listed." )
-      self.options = CmdParse::OptionParserWrapper.new do |opts|
-        opts.separator "Options:"
-        opts.on( '-t', '--template TEMPLATE', Webgen::WebSiteTemplate.entries.keys, 'Specify the template which should be used' ) {|@template|}
-        opts.on( '-s', '--style STYLE', Webgen::WebSiteStyle.entries.keys, 'Specify the style which should be used' ) {|@style|}
-        opts.separator ""
-        opts.separator "Arguments:"
-        opts.separator opts.summary_indent + "DIR: the base directory for the website"
-        opts.separator ""
-        opts.separator "Available templates and styles:"
-        opts.separator ""
-        opts.separator opts.summary_indent + "#{Color.bold( 'Templates' )}"
-        Webgen::WebSiteTemplate.entries.sort.each {|name, entry| CliUtils.dirinfo_output( opts, name, entry ) }
-        opts.separator opts.summary_indent + "#{Color.bold( 'Styles' )}"
-        Webgen::WebSiteStyle.entries.sort.each {|name, entry| CliUtils.dirinfo_output( opts, name, entry ) }
-      end
-      @template = 'default'
-      @style = 'default'
-    end
-
-    def usage
-      "Usage: #{commandparser.program_name} [global options] create [options] DIR"
-    end
-
-    def execute( args )
-      if args.length == 0
-        raise OptionParser::MissingArgument.new( 'DIR' )
-      else
-        files = Webgen::WebSite.create_website( args[0], @template, @style )
-        if (0..1) === commandparser.verbosity
-          puts "The following files were created:"
-          puts files.collect {|f| "- " + f }.join("\n")
+        self.add_command(CmdParse::HelpCommand.new)
+        self.add_command(CmdParse::VersionCommand.new)
+        Webgen::CLI.constants.select {|c| c =~ /.+Command$/ }.each do |c|
+          self.add_command(Webgen::CLI.const_get(c).new, (c == 'RunCommand' ? true : false))
         end
       end
-    end
-
-  end
-
-  class UseCommand < CmdParse::Command
-
-    def initialize( cmdparser )
-      super( 'use', true )
-      self.short_desc = "Changes the used website or gallery styles"
-
-      @force = false
-      self.options = CmdParse::OptionParserWrapper.new do |opts|
-        opts.separator "Options:"
-        opts.on( '-f', '--[no-]force', 'If specified, existing files are overwritten without asking.' ) {|@force|}
-      end
 
-      # Use website style command.
-      useWebsiteStyle = CmdParse::Command.new( 'website_style', false )
-      useWebsiteStyle.short_desc = "Changes the used website style"
-      useWebsiteStyle.description =
-        CliUtils.format("\nCopies the style files for the website style STYLE to the website " +
-                        "directory defined by the global directory option, overwritting existing " +
-                        "files. If the global verbosity level is set to 0 or 1, the copied files are listed.")
-      useWebsiteStyle.options = CmdParse::OptionParserWrapper.new do |opts|
-        opts.separator "Available styles:"
-        opts.separator ""
-        Webgen::WebSiteStyle.entries.sort.each {|name, entry| CliUtils.dirinfo_output( opts, name, entry ) }
-      end
-      def useWebsiteStyle.usage
-        "Usage: #{commandparser.program_name} [global options] use website_style STYLE"
-      end
-      useWebsiteStyle.set_execution_block do |args|
-        if args.length == 0
-          raise OptionParser::MissingArgument.new( 'STYLE' )
-        else
-          if @force || ask_overwrite
-            files = Webgen::WebSite.use_website_style( cmdparser.directory, args[0] )
-            if (0..1) === cmdparser.verbosity
-              puts "The following files were created or overwritten:"
-              puts files.collect {|f| "- " + f }.join("\n")
-            end
-          end
+      # Utility method for sub-commands to create the correct Webgen::Website object.
+      def create_website
+        website = Webgen::Website.new(@directory) do |config|
+          config['logger.mask'] = @log_filter
         end
+        website.logger.level = @log_level
+        website.logger.verbosity = @verbosity
+        website
       end
-      self.add_command( useWebsiteStyle )
 
-      # Use gallery style command.
-      useGalleryStyle = CmdParse::Command.new( 'gallery_style', false )
-      useGalleryStyle.short_desc = "Changes the used gallery style"
-      useGalleryStyle.description =
-        CliUtils.format("\nCopies the gallery templates for the gallery style STYLE to the website " +
-                        "directory defined by the global directory option, overwritting existing files. " +
-                        "If the global verbosity level is set to 0 or 1, the copied files are listed.")
-      useGalleryStyle.options = CmdParse::OptionParserWrapper.new do |opts|
-        opts.separator "Available styles:"
-        opts.separator ""
-        Webgen::GalleryStyle.entries.sort.each {|name, entry| CliUtils.dirinfo_output( opts, name, entry ) }
-      end
-      def useGalleryStyle.usage
-        "Usage: #{commandparser.program_name} [global options] use gallery_style STYLE"
-      end
-      useGalleryStyle.set_execution_block do |args|
-        if args.length == 0
-          raise OptionParser::MissingArgument.new( 'STYLE' )
-        else
-          if @force || ask_overwrite
-            files = Webgen::WebSite.use_gallery_style( cmdparser.directory, args[0] )
-            if (0..1) === cmdparser.verbosity
-              puts "The following files were created or overwritten:"
-              puts files.collect {|f| "- " + f }.join("\n")
-            end
-          end
-        end
-      end
-      self.add_command( useGalleryStyle )
-
-      # Use sipttra style command.
-      useSipttraStyle = CmdParse::Command.new( 'sipttra_style', false )
-      useSipttraStyle.short_desc = "Changes the used sipttra style"
-      useSipttraStyle.description =
-        CliUtils.format("\nCopies the sipttra styles files for the sipttra style STYLE to the website " +
-                        "directory defined by the global directory option, overwritting existing files. " +
-                        "If the global verbosity level is set to 0 or 1, the copied files are listed.")
-      useSipttraStyle.options = CmdParse::OptionParserWrapper.new do |opts|
-        opts.separator "Available styles:"
-        opts.separator ""
-        Webgen::SipttraStyle.entries.sort.each {|name, entry| CliUtils.dirinfo_output( opts, name, entry ) }
-      end
-      def useSipttraStyle.usage
-        "Usage: #{commandparser.program_name} [global options] use sipttra_style STYLE"
-      end
-      useSipttraStyle.set_execution_block do |args|
-        if args.length == 0
-          raise OptionParser::MissingArgument.new( 'STYLE' )
-        else
-          if @force || ask_overwrite
-            files = Webgen::WebSite.use_sipttra_style( cmdparser.directory, args[0] )
-            if (0..1) === cmdparser.verbosity
-              puts "The following files were created or overwritten:"
-              puts files.collect {|f| "- " + f }.join("\n")
-            end
-          end
-        end
-      end
-      self.add_command( useSipttraStyle )
-    end
-
-    #######
-    private
-    #######
-
-    def ask_overwrite
-      printf "Existing files may get overwritten, procede (yes/no)? : "
-      $stdin.gets =~ /y|yes/
     end
 
   end
 
-
-  class ShowCommand < CmdParse::Command
-
-    def initialize( cmdparser )
-      super( 'show', true )
-      self.short_desc = "Shows various information"
-
-      # Show plugins command
-      showPlugins = CmdParse::Command.new( 'plugins', false )
-      showPlugins.short_desc = "Shows the available plugins"
-      showPlugins.set_execution_block do |args|
-        puts "List of loaded plugins:"
-        headers = Hash.new {|h,k| h[k] = (k.nil? ? "Other Plugins" : k.gsub(/([A-Z][a-z])/, ' \1').strip) }
-
-        header = ''
-        cmdparser.website.manager.plugin_classes.sort {|a, b| a.plugin_name <=> b.plugin_name }.each do |plugin|
-          newHeader = headers[plugin.plugin_name[/^.*?(?=\/)/]]
-          unless newHeader == header
-            puts "\n" + CliUtils.headline( newHeader )
-            header = newHeader
-          end
-          puts CliUtils.section( plugin.plugin_name[/\w+$/], 33 ) + CliUtils.format( plugin.config.infos[:summary], 33 ).join("\n")
-        end
-      end
-      self.add_command( showPlugins )
-
-      # Show config command
-      showConfig = CmdParse::Command.new( 'config', false )
-      showConfig.short_desc = "Shows information like the parameters for all or the matched plugins"
-      showConfig.description =
-        CliUtils.format( "\nIf no argument is provided, all plugins and their information are listed. If " +
-                         "an argument is specified, all plugin names that match the argument are listed." ).join("\n")
-      showConfig.set_execution_block do |args|
-        puts "List of plugin informations:"
-        puts
-
-        cmdparser.website.manager.plugins.sort {|a, b| a[0] <=> b[0] }.each do |name, plugin|
-          next if args.length > 0 && /#{args[0]}/i !~ name
-
-          config = plugin.class.config
-          puts CliUtils.headline( name )
-          ljust = 25
-
-          puts CliUtils.section( 'Summary', ljust ) + CliUtils.format( config.infos[:summary], ljust ).join("\n") if config.infos[:summary]
-          puts CliUtils.section( 'Author', ljust ) + CliUtils.format( config.infos[:author], ljust ).join("\n") if config.infos[:author]
-          puts CliUtils.section( 'Description', ljust ) + CliUtils.format( config.infos[:description], ljust ).join("\n") if config.infos[:description]
-          puts CliUtils.section( 'Tag names', ljust ) + plugin.tags.join(", ") if plugin.respond_to?( :tags )
-          puts CliUtils.section( 'Handles paths', ljust ) + plugin.path_patterns.collect {|r,f| f}.inspect if plugin.respond_to?( :path_patterns )
-          puts CliUtils.section( 'Dependencies', ljust ) + config.dependencies.join(', ') if !config.dependencies.empty?
-
-          if !config.params.empty?
-            puts "\n" + CliUtils.section( 'Parameters' )
-            config.params.sort.each do |name, item|
-              print "\n" + CliUtils.section( 'Parameter', ljust, 6 )
-              puts Color.lred( item.name ) + ": " + Color.lblue( plugin.instance_eval {param( name )}.inspect ) +
-                " (" + item.default.inspect + ")"
-              puts CliUtils.section( 'Description', ljust, 6 ) + CliUtils.format( item.description, ljust ).join("\n")
-            end
-          end
-
-          otherinfos = config.infos.select {|k,v| ![:name, :author, :summary, :description, :tags, :path_patterns].include?( k ) }
-          puts "\n" +CliUtils.section( 'Other Information' ) unless otherinfos.empty?
-          otherinfos.each {|name, value| puts CliUtils.section( name.to_s.tr('_', ' '), ljust, 6 ) + value.inspect }
-
-          puts
-        end
-      end
-      self.add_command( showConfig )
-    end
-
-  end
-
-
-  class CheckCommand < CmdParse::Command
-
-    def initialize( cmdparser )
-      super( 'check', true )
-      self.short_desc = "Checks things like validity of the config file or the availability of optional libraries"
-
-      # Check configuration file command
-      checkConfig = CmdParse::Command.new( 'config', false )
-      checkConfig.short_desc = "Checks the validity of the configuration and outputs the used options"
-      checkConfig.set_execution_block do |args|
-        begin
-          if File.exists?( File.join( cmdparser.directory, 'config.yaml' ) )
-            print CliUtils.section( "Checking configuration file syntax...", 50, 0, :bold )
-            config_file = ConfigurationFile.new( File.join( cmdparser.directory, 'config.yaml' ) )
-            puts Color.green( 'OK' )
-
-            puts CliUtils.section( "Checking parameters...", 0, 0, :bold )
-            config_file.config.each do |plugin_name, params|
-              params.each do |param_name, value|
-                print CliUtils.section( "#{plugin_name}:#{param_name}", 50, 2, :reset )
-                if cmdparser.website.manager.plugin_class_for_name( plugin_name ).nil?
-                  puts Color.lred( 'NOT OK' ) + ': no such plugin'
-                else
-                  begin
-                    cmdparser.website.manager.param_for_plugin( plugin_name, param_name )
-                    puts Color.green( 'OK' )
-                  rescue PluginParamNotFound => e
-                    puts Color.lred( 'NOT OK' ) + ': no such parameter'
-                  end
-                end
-              end
-            end
-          else
-            print CliUtils.section( "No configuration file found!", 50, 0, :bold )
-          end
-        rescue ConfigurationFileInvalid => e
-          puts Color.lred( 'NOT OK' ) + ': ' + e.message
-        end
-      end
-      self.add_command( checkConfig, true )
-
-      # Check optional libraries
-      checkLibs = CmdParse::Command.new( 'libs', false )
-      checkLibs.short_desc = "Checks the availability of optional libraries used by plugins"
-      checkLibs.set_execution_block do |args|
-        puts CliUtils.format( "List of optional libraries (the info line specifies which functionality will be available " +
-                              "if the needed gems are installed):" ).join("\n")
-        puts
-
-        cmdparser.website.manager.plugin_loaders.each do |loader|
-          loader.optional_parts.sort.each do |name, options|
-            puts CliUtils.headline( name )
-            puts CliUtils.section( 'Info', 25 ) + CliUtils.format( options[:info], 25 ).join("\n")
-            puts CliUtils.section( 'Needed gems', 25 ) + options[:needed_gems].join( ', ' )
-            puts CliUtils.section( 'Loaded', 25 ) + ( options[:loaded] ? Color.green( 'yes' ) : Color.lred( 'no' ) )
-            puts CliUtils.section( 'Error message', 25 ) + CliUtils.format( options[:error_msg], 25 ).join("\n") unless options[:loaded]
-            puts
-          end
-        end
-      end
-      self.add_command( checkLibs )
-    end
-
-  end
-
-
-  class CommandParser < CmdParse::CommandParser
-
-    VERBOSITY_UNUSED = -1
-
-    attr_reader :directory
-    attr_reader :website
-    attr_reader :verbosity
-    attr_reader :config_file
-
-    def initialize
-      super( true )
-      @directory = Dir.pwd
-      @verbosity = VERBOSITY_UNUSED
-
-      self.program_name = "webgen"
-      self.program_version = Webgen::VERSION
-      self.options = CmdParse::OptionParserWrapper.new do |opts|
-        opts.separator "Global options:"
-        opts.on( "--directory DIR", "-d", String, "The website directory, if none specified, current directory is used." ) {|@directory|}
-        opts.on( "--verbosity LEVEL", "-V", Integer, "The verbosity level (0-3)" ) {|@verbosity|}
-      end
-
-      # Run command
-      run = CmdParse::Command.new( 'run', false )
-      run.short_desc = "Runs webgen, ie. generates the HTML files"
-      run.description = CliUtils.format("\nWith no arguments, renders the whole site. If file names are " +
-                                        "specified (don't include the path/to/src/ part), only those are rendered." )
-      run.set_execution_block do |args|
-        @website.render( args )
-      end
-      self.add_command( run, true )
-
-      self.add_command( CreateCommand.new )
-      self.add_command( ShowCommand.new( self ) )
-      self.add_command( UseCommand.new( self ) )
-      self.add_command( CmdParse::HelpCommand.new )
-      self.add_command( CmdParse::VersionCommand.new )
-      self.add_command( CheckCommand.new( self ) )
-    end
-
-    def param_for_plugin( plugin_name, param )
-      if [plugin_name, param] == ['Core/Configuration', 'loggerLevel'] && @verbosity != VERBOSITY_UNUSED
-        @verbosity
-      elsif @config_file
-        @config_file.param_for_plugin( plugin_name, param )
-      else
-        Webgen::PluginParamValueNotFound
-      end
-    end
-
-    def parse( argv = ARGV )
-      super do |level, cmd_name|
-        if level == 0
-          @config_file = Webgen::WebSite.load_config_file( @directory )
-          @website = Webgen::WebSite.new( @directory, self )
-          @website.manager.init
-          @website.manager.plugins.
-            each {|name,plugin| self.add_command( plugin ) if plugin.kind_of?( Webgen::CommandPlugin ) }
-        end
-      end
-    end
-
-  end
-
-
-  # Main program for the webgen CLI.
-  def self.cli_main
-    Color.colorify if $stdout.isatty && !Config::CONFIG['arch'].include?( 'mswin32' )
-    cmdparser = CommandParser.new
-    cmdparser.parse
-  end
-
 end