webgen 0.3.8 → 0.4.0

data/lib/webgen/plugins/tags/wikilink.rb

@@ -1,7 +1,7 @@
 #
 #--
 #
-# $Id: wikilink.rb 369 2005-12-24 11:37:40Z thomas $
+# $Id: wikilink.rb 563 2006-12-29 08:59:41Z thomas $
 #
 # webgen: template based static website generator
 # Copyright (C) 2004 Thomas Leitner
@@ -20,36 +20,41 @@
 #++
 #
 
-require 'webgen/plugins/tags/tags'
+load_plugin 'webgen/plugins/tags/tag_processor'
 
 module Tags
 
   class WikiLinkTag < DefaultTag
 
-    summary 'Adds a link to wiki page'
-    add_param 'title', nil, 'The title of the link. If it is not specified, the title of the current page is used.'
-    add_param 'rootURL', '/wiki/wiki.pl?', 'The root URL for the wiki link, ie. the path to the wiki CGI.'
-    add_param 'relURL', nil, 'The relativ URL for the wiki link (the varying part that is appended to rootURL). ' \
-    'If it is not specified, the title of the current page is used.'
-    add_param 'invalidChars', ' &;', 'The characters which are invalid as wiki URLs.'
-    add_param 'replacementChar', '_', 'The character(s) which should be used instead of the invalid characters.'
-
-    used_meta_info 'title'
-
-    tag 'wikilink'
-
-    def process_tag( tag, node, refNode )
-      "<a href=\"#{get_link( node )}\">#{get_param( 'title' ) || node['title']}</a>"
+    infos( :name => 'Tag/WikiLink',
+           :author => Webgen::AUTHOR,
+           :summary => 'Adds a link to a wiki page'
+           )
+
+    param 'linkText', nil, 'The text of the link. If it is not specified, the title of the current page is used.'
+    param 'rootURL', '/wiki/wiki.pl?', 'The root URL for the wiki link, ie. the path to the wiki CGI.'
+    param 'relURL', nil, 'The relativ URL for the wiki link (the varying part that is appended to rootURL). ' +
+      'If it is not specified, the title of the current page is used.'
+    param 'invalidChars', ' &;', 'The characters which are invalid in wiki URLs.'
+    param 'replacementChar', '_', 'The character(s) which should be used instead of the invalid characters.'
+    set_mandatory 'rootURL'
+    set_mandatory 'invalidChars'
+    set_mandatory 'replacementChar'
+
+    register_tag 'wikilink'
+
+    def process_tag( tag, chain )
+      "<a href=\"#{link( chain.last )}\">#{param( 'linkText' ) || chain.last['title']}</a>"
     end
 
     #######
     private
     #######
 
-    def get_link( node )
-      link = get_param( 'rootURL' )
-      relURL = get_param( 'relURL' ) || node['title']
-      link + relURL.tr( get_param( 'invalidChars' ), get_param( 'replacementChar' ) )
+    def link( node )
+      rootURL = param( 'rootURL' )
+      relURL = param( 'relURL' ) || node['title']
+      rootURL + relURL.tr( param( 'invalidChars' ), param( 'replacementChar' ) )
     end
 
   end

data/lib/webgen/test.rb

@@ -0,0 +1,202 @@
+require 'webgen/config'
+
+Webgen::LOAD_DEFAULT_PLUGINS = false
+
+require 'test/unit'
+require 'webgen/plugin'
+
+module Webgen
+
+  # Base class for all webgen test cases. It specifies some auxilary methods helpful when developing
+  # tests.
+  class TestCase < Test::Unit::TestCase
+
+    # Sets the base fixture path and the fixture path for the test case.
+    def self.inherited( klass )
+      path = caller[0][/^.*?:/][0..-2]
+      dir, file = File.split( path )
+      parent_path, unit_tests = File.split( dir )
+
+      fpath = if dir == '.'
+                File.join( '..', 'fixtures' )
+              else
+                File.join( parent_path, 'fixtures' )
+              end
+
+      klass.instance_variable_set( :@fixture_path, File.join( fpath, File.basename( file, '.*' ) ) )
+      klass.instance_variable_set( :@base_fixture_path, fpath + '/' )
+    end
+
+    # Reimplemented to hide the base test case.
+    def self.suite
+      if self == TestCase
+        return Test::Unit::TestSuite.new('Webgen::TestCase')
+      else
+        super
+      end
+    end
+
+    # Helper method for retrieving a path name with an optionally appended filename.
+    def self.path_helper( var, filename = nil )
+      var = instance_variable_get( var )
+      (filename.nil? ? var : File.join( var, filename ) )
+    end
+
+    # If +filename+ is not specified, returns the fixture path for the test case. If +filename+ is
+    # specified, it is appended to the fixture path.
+    def self.fixture_path( filename = nil )
+      path_helper( :@fixture_path, filename )
+    end
+
+    # See TestCase.fixture_path
+    def fixture_path( filename = nil )
+      self.class.fixture_path( filename )
+    end
+
+    # Returns the base fixture path for the test case. If +filename+ is specified, it is appended to
+    # the base fixture path.
+    def self.base_fixture_path( filename = nil )
+      path_helper( :@base_fixture_path, filename )
+    end
+
+    # See TestCase.base_fixture_path
+    def base_fixture_path( filename = nil )
+      self.class.base_fixture_path( filename )
+    end
+
+  end
+
+
+  # Base class for all plugin test cases. It ensures that all needed plugins are loaded and
+  # initalized before each test and that the original environment is restored afterwards.
+  class PluginTestCase < TestCase
+
+    class << self
+
+      # Specifies +files+ as the plugin files which define the plugin which should be tested and its
+      # dependencies.
+      def plugin_files( files = nil )
+        (files.nil? ? @plugin_files.to_a + ['webgen/plugins/coreplugins/configuration.rb'] : @plugin_files = files )
+      end
+
+      # The name of the plugin which should be tested.
+      def plugin_to_test( plugin = nil )
+        @plugin_name ||= nil
+        (plugin.nil? ? @plugin_name : @plugin_name = plugin )
+      end
+
+    end
+
+    # required stdlib files sothat no warnings etc. are shown when re-requiring files
+    require 'set'
+    require 'fileutils'
+
+    def setup
+      @loader = PluginLoader.new( @wrapper = Module.new )
+
+      begin
+        self.class.plugin_files.each {|p| @loader.load_from_file( p ) }
+      rescue Exception => e
+        puts "Caught exception during loading of plugins in #setup: #{e.message} - #{e.backtrace.first}"
+      end
+
+      @manager = PluginManager.new( [@loader], @loader.plugin_classes )
+      if $VERBOSE
+        @manager.logger = Webgen::Logger.new
+        @manager.logger.level = ::Logger::DEBUG
+      end
+      @manager.plugin_config = self
+      @manager.init
+
+      if !@manager.plugins.has_key?( 'ContentConverter/Default' )
+        x = @manager.plugins['ContentConverter/Default'] = Object.new
+        def x.registered_handlers
+          formatters = Hash.new {|h, k| h[k] = proc {|c| c} }
+          def formatters.has_key?( value ); true; end
+          formatters
+        end
+      end
+
+      @plugin = @manager[self.class.plugin_to_test] if self.class.plugin_to_test
+    end
+
+    def teardown
+      @manager = nil
+      @loader = nil
+    end
+
+    def self.sample_site( filename = '' )
+      path_helper( :@base_fixture_path, File.join( 'sample_site', filename ) )
+    end
+
+    def sample_site( filename = '' )
+      self.class.sample_site( filename )
+    end
+
+    def param_for_plugin( plugin_name, param )
+      case [plugin_name, param]
+      when ['Core/Configuration', 'srcDir'] then sample_site( Webgen::SRC_DIR )
+      when ['Core/Configuration', 'outDir'] then sample_site( 'out' )
+      when ['Core/Configuration', 'websiteDir'] then sample_site
+      else PluginParamValueNotFound
+      end
+    end
+
+    def find_in_sample_site
+      files = Set.new
+      Find.find( sample_site( Webgen::SRC_DIR ) ) do |path|
+        Find.prune if File.basename( path ) =~ /^\./
+        path += '/' if FileTest.directory?(path)
+        files << path if yield( path )
+      end
+      files
+    end
+
+    def remove_consts( obj, constants )
+      constants.each do |c|
+        obj.remove_const( c )
+      end
+    end
+
+    def self.suite
+      if self == PluginTestCase
+        return Test::Unit::TestSuite.new('Webgen::TestCase')
+      else
+        super
+      end
+    end
+
+  end
+
+
+  # Base class for all plugin test cases. It ensures that all needed plugins are loaded and
+  # initalized before each test and that the original environment is restored afterwards.
+  class TagTestCase < PluginTestCase
+
+    def self.suite
+      if self == TagTestCase
+        return Test::Unit::TestSuite.new('Webgen::TestCase')
+      else
+        super
+      end
+    end
+
+    def set_config( config )
+      @plugin.set_tag_config( config, Dummy.new )
+    end
+
+  end
+
+  class Dummy
+
+    def method_missing( name, *args, &block )
+      Dummy.new
+    end
+
+  end
+
+end
+
+class Module
+  public :remove_const
+end

data/lib/webgen/website.rb

@@ -0,0 +1,310 @@
+#
+#--
+#
+# $Id: website.rb 576 2007-01-03 19:41:12Z 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 'pathname'
+require 'yaml'
+require 'fileutils'
+require 'webgen/config'
+require 'webgen/plugin'
+
+module Webgen
+
+
+  # Base class for directories which have a README file with information stored in YAML format.
+  # Should not be used directly, use its child classes!
+  class DirectoryInfo
+
+    # The unique name.
+    attr_reader :name
+
+    # Contains additional information, like a description or the creator.
+    attr_reader :infos
+
+    # Returns a new object for the given +name+.
+    def initialize( name )
+      @name = name
+      raise ArgumentError.new( "'#{name}' is not a directory!" ) if !File.directory?( path )
+      @infos = YAML::load( File.read( File.join( path, 'README' ) ) )
+      raise ArgumentError.new( "'#{name}/README' does not contain key-value pairs in YAML format!" ) unless @infos.kind_of?( Hash )
+    end
+
+    # The absolute directory path. Requires that child classes have defined a constant +BASE_PATH+.
+    def path
+      File.expand_path( File.join( self.class::BASE_PATH, name ) )
+    end
+
+    # The files under the directory.
+    def files
+      Dir[File.join( path, '**', '*' )]
+    end
+
+    # Copies the files returned by +#files+ into the directory +dest+, preserving the directory
+    # hierarchy.
+    def copy_to( dest )
+      files.collect do |file|
+        destpath = File.join( dest, File.dirname( file ).sub( /^#{path}/, '' ) )
+        FileUtils.mkdir_p( File.dirname( destpath ) )
+        if File.directory?( file )
+          FileUtils.mkdir_p( File.join( destpath, File.basename( file ) ) )
+        else
+          FileUtils.cp( file, destpath )
+        end
+        File.join( destpath, File.basename( file ) )
+      end
+    end
+
+    # Returns all available entries.
+    def self.entries
+      unless defined?( @entries )
+        @entries = {}
+        Dir[File.join( self::BASE_PATH, '*' )].each do |f|
+          next unless File.directory?( f )
+          name = File.basename( f );
+          @entries[name] = self.new( name )
+        end
+      end
+      @entries
+    end
+
+  end
+
+
+  # A Web site template is a collection of files which provide a starting point for a Web site.
+  # These files provide stubs for the content and should not contain any style information.
+  class WebSiteTemplate < DirectoryInfo
+
+    # Base path for the templates.
+    BASE_PATH = File.join( Webgen.data_dir, 'website_templates' )
+
+  end
+
+
+  # A Web site style provides style information for a Web site. This means it contains, at least, a
+  # template file and a CSS file.
+  class WebSiteStyle < DirectoryInfo
+
+    # Base path for the styles.
+    BASE_PATH = File.join( Webgen.data_dir, 'website_styles' )
+
+    # See DirectoryInfo#files
+    def files
+      super.select {|f| f != File.join( path, 'README' )}
+    end
+
+  end
+
+
+  # A gallery style provides style information for gallery pages. It should contains the files
+  # +gallery_main.template+, +gallery_gallery.template+ and +gallery_image.template+ and an optional
+  # readme file.
+  class GalleryStyle < DirectoryInfo
+
+    # Base path for the styles.
+    BASE_PATH = File.join( Webgen.data_dir, 'gallery_styles' )
+
+    # See DirectoryInfo#files
+    def files
+      super.select {|f| f != File.join( path, 'README' )} - plugin_files
+    end
+
+    def plugin_files
+      plugin_files = []
+      @infos['plugin files'].each do |pfile|
+        plugin_files += Dir[File.join( path, pfile )]
+      end if @infos['plugin files']
+      plugin_files
+    end
+
+  end
+
+
+  # A WebSite object represents a webgen website directory and is used for manipulating it.
+  class WebSite
+
+    # The website directory.
+    attr_reader :directory
+
+    # The logger used for the website
+    attr_reader :logger
+
+    # The plugin manager used for this website.
+    attr_reader :manager
+
+    # Creates a new WebSite object for the given +directory+ and loads its plugins. If the
+    # +plugin_config+ parameter is given, it is used to resolve the values for plugin parameters.
+    # Otherwise, a ConfigurationFile instance is used as plugin configuration.
+    def initialize( directory = Dir.pwd, plugin_config = nil )
+      @directory = File.expand_path( directory )
+      @logger = Webgen::Logger.new
+
+      wrapper_mod = Module.new
+      wrapper_mod.module_eval { include DEFAULT_WRAPPER_MODULE }
+      @loader = PluginLoader.new( wrapper_mod )
+      @loader.load_from_dir( File.join( @directory, Webgen::PLUGIN_DIR ) )
+
+      @manager = PluginManager.new( [DEFAULT_PLUGIN_LOADER, @loader], DEFAULT_PLUGIN_LOADER.plugin_classes + @loader.plugin_classes )
+      @manager.logger = @logger
+      set_plugin_config( plugin_config )
+    end
+
+    # Returns a modified value for Configuration:srcDir, Configuration:outDir and Configuration:websiteDir.
+    def param_for_plugin( plugin_name, param )
+      case [plugin_name, param]
+      when ['Core/Configuration', 'srcDir'] then @srcDir
+      when ['Core/Configuration', 'outDir'] then @outDir
+      when ['Core/Configuration', 'websiteDir'] then @directory
+      else
+        (@plugin_config ? @plugin_config.param_for_plugin( plugin_name, param ) : PluginParamValueNotFound)
+      end
+    end
+
+    # Initializes all plugins and renders the website.
+    def render( files = [] )
+      @logger.level = @manager.param_for_plugin( 'Core/Configuration', 'loggerLevel' )
+      @manager.init
+
+      @logger.info( 'WebSite#render' ) { "Starting rendering of website <#{directory}>..." }
+      if files.empty?
+        @manager['Core/FileHandler'].render_site
+      else
+        @manager['Core/FileHandler'].render_files( files )
+      end
+      @logger.info( 'WebSite#render' ) { "Rendering of website <#{directory}> finished" }
+    end
+
+    # Loads the configuration file from the +directory+.
+    def self.load_config_file( directory = Dir.pwd )
+      begin
+        ConfigurationFile.new( File.join( directory, 'config.yaml' ) )
+      rescue ConfigurationFileInvalid => e
+        nil
+      end
+    end
+
+    # Create a website in the +directory+, using the template +template_name+ and the style +style_name+.
+    def self.create_website( directory, template_name = 'default', style_name = 'default' )
+      template = WebSiteTemplate.entries[template_name]
+      style = WebSiteStyle.entries[style_name]
+      raise ArgumentError.new( "Invalid website template '#{template}'" ) if template.nil?
+      raise ArgumentError.new( "Invalid website style '#{style}'" ) if style.nil?
+
+      raise ArgumentError.new( "Directory <#{directory}> does already exist!") if File.exists?( directory )
+      FileUtils.mkdir( directory )
+      return template.copy_to( directory ) + style.copy_to( File.join( directory, Webgen::SRC_DIR) )
+    end
+
+    # Copies the style files for +style+ to the source directory of the website +directory+
+    # overwritting exisiting files.
+    def self.use_website_style( directory, style_name )
+      style = WebSiteStyle.entries[style_name]
+      raise ArgumentError.new( "Invalid website style '#{style_name}'" ) if style.nil?
+      src_dir = File.join( directory, Webgen::SRC_DIR )
+      raise ArgumentError.new( "Directory <#{src_dir}> does not exist!") unless File.exists?( src_dir )
+      return style.copy_to( src_dir )
+    end
+
+    # Copies the gallery style files for +style+ to the source directory of the website +directory+
+    # overwritting exisiting files.
+    def self.use_gallery_style( directory, style_name )
+      style = GalleryStyle.entries[style_name]
+      raise ArgumentError.new( "Invalid gallery style '#{style_name}'" ) if style.nil?
+      src_dir = File.join( directory, Webgen::SRC_DIR )
+      plugin_dir = File.join( directory, Webgen::PLUGIN_DIR )
+      raise ArgumentError.new( "Directory <#{src_dir}> does not exist!") unless File.exists?( src_dir )
+      plugin_files = style.plugin_files
+      FileUtils.mkdir( plugin_dir ) unless File.exists?( plugin_dir )
+      FileUtils.cp( plugin_files, plugin_dir )
+      return style.copy_to( src_dir ) + plugin_files.collect {|f| File.join( plugin_dir, File.basename( f ) )}
+    end
+
+    #######
+    private
+    #######
+
+    def set_plugin_config( plugin_config )
+      @manager.plugin_config = ( plugin_config ? plugin_config : self.class.load_config_file( @directory ) )
+      @srcDir = File.join( @directory, Webgen::SRC_DIR )
+      outDir = @manager.param_for_plugin(  'Core/Configuration', 'outDir' )
+      @outDir = (/^(\/|[A-Za-z]:)/ =~ outDir ? outDir : File.join( @directory, outDir ) )
+      @plugin_config = @manager.plugin_config
+      @manager.plugin_config = self
+    end
+
+  end
+
+
+  # Raised when a configuration file has an invalid structure
+  class ConfigurationFileInvalid < RuntimeError; end
+
+  # Represents the configuration file of a website.
+  class ConfigurationFile
+
+    # Returns the whole configuration.
+    attr_reader :config
+
+    # Reads the content of the given configuration file and initialize a new object with it.
+    def initialize( config_file )
+      if File.exists?( config_file )
+        begin
+          @config = YAML::load( File.read( config_file ) )
+        rescue ArgumentError => e
+          raise ConfigurationFileInvalid, e.message
+        end
+      else
+        @config = {}
+      end
+      check_config
+    end
+
+    # See PluginManager#param_for_plugin .
+    def param_for_plugin( plugin_name, param )
+      if @config.has_key?( plugin_name ) && @config[plugin_name].has_key?( param )
+        @config[plugin_name][param]
+      else
+        PluginParamValueNotFound
+      end
+    end
+
+    #######
+    private
+    #######
+
+    def check_config
+      if !@config.kind_of?( Hash ) || !@config.all? {|k,v| v.kind_of?( Hash )}
+        raise ConfigurationFileInvalid.new( 'Structure of config file is not valid, has to be a Hash of Hashes' )
+      end
+
+      if !@config.has_key?( 'Core/FileHandler' ) || !@config['Core/FileHandler'].has_key?( 'defaultMetaInfo' )
+        @config.each_key do |plugin_name|
+          next unless plugin_name =~ /File\//
+          if @config[plugin_name]['defaultMetaInfo'].kind_of?( Hash )
+            ((@config['Core/FileHandler'] ||= {})['defaultMetaInfo'] ||= {})[plugin_name] = @config[plugin_name]['defaultMetaInfo']
+            @config[plugin_name].delete( 'defaultMetaInfo' )
+          end
+        end
+      end
+
+    end
+
+  end
+
+end