webgen 0.5.17 → 1.0.0.beta1

data/lib/webgen/bundle_loader.rb

@@ -0,0 +1,126 @@
+# -*- encoding: utf-8 -*-
+
+require 'rbconfig'
+require 'yaml'
+
+module Webgen
+
+  # This class is used for loading extension bundles. It provides a DSL for the most commonly needed
+  # commands.
+  #
+  # When an extension bundle is provided by a Rubygem and the Rubygem is not already activated, the
+  # Rubygem is automatically activated. This only works when one follows the standard naming
+  # conventions for webgen extension bundles, i.e. the Rubygem has to be named
+  # 'webgen-BUNDLE_NAME-bundle'.
+  class BundleLoader
+
+    # Create a new BundleLoader object belonging to the website object +website+.
+    def initialize(website, ext_dir)
+      @website = website
+      @website.ext.bundles = {}
+      @ext_dir = ext_dir
+      @loaded = []
+      @stack = []
+    end
+
+    # Load the extension bundle in the context of this BundleLoader object.
+    def load(name)
+      file = resolve_init_file(name)
+      raise(ArgumentError, "Extension bundle '#{name}' not found") if !file
+      file = File.expand_path(file)
+      return if @loaded.include?(file)
+
+      @loaded.push(file)
+      @stack.push(file)
+      self.instance_eval(File.read(file), file)
+      @stack.pop
+
+      if file != File.expand_path(File.join(@ext_dir, 'init.rb'))
+        name = File.basename(File.dirname(file))
+        info_file = File.join(File.dirname(file), 'info.yaml')
+        @website.ext.bundles[name] = (File.file?(info_file) ? info_file : nil)
+      end
+    end
+
+    # Loads all bundles that are marked for auto-loading.
+    def load_autoload_bundles
+      Gem::Specification.map {|s| s.name }.uniq.each do |gem_name|
+        md = /^webgen-(.*)-bundle$/.match(gem_name)
+        next unless md
+
+        bundle_name = md[1]
+        file = resolve_init_file(bundle_name)
+        next unless file
+
+        info_file = File.join(File.dirname(file), 'info.yaml')
+        next unless File.file?(info_file)
+        next unless YAML.load(File.read(info_file))['autoload']
+
+        load(bundle_name)
+      end
+    end
+
+    # Search in the website extension directory and then in the load path to find the initialization
+    # file of the bundle.
+    def resolve_init_file(name)
+      name.sub!(/(\/|^)init\.rb$/, '')
+
+      if name =~ /\A[\w-]+\z/
+        begin
+          Gem::Specification.find_by_name("webgen-#{name}-bundle").activate
+        rescue Gem::LoadError
+        end
+      end
+
+      possible_init_file_names(name).each {|path| return path if File.file?(path)}
+
+      nil
+    end
+    private :resolve_init_file
+
+    # Create all possible initialization file names for the given directory name.
+    def possible_init_file_names(dir_name)
+      [File.join(@ext_dir, dir_name, 'init.rb')] +
+        $LOAD_PATH.map {|path| File.join(path, 'webgen/bundle', dir_name, 'init.rb')}
+    end
+    private :possible_init_file_names
+
+    # :section: DSL methods
+    #
+    # All following method are DSL methods that are provided for convenience and can be used by the
+    # initialization files.
+
+    # Require the file relative to the currently loaded file.
+    def require_relative(file)
+      require(File.join(File.dirname(@stack.last), file))
+    end
+
+    # Define a configuration option.
+    #
+    # See Webgen::Configuration#define_option for more information.
+    def option(name, default, description, &validator)
+      @website.config.define_option(name, default, description, &validator)
+    end
+
+    # Return the website object.
+    def website
+      @website
+    end
+
+    # Mount the directory relative to the currently loaded file on the given mount point as passive
+    # source.
+    #
+    # See Webgen::Source for more information.
+    def mount_passive(dir, mount_point = '/', glob = '**/*')
+      @website.ext.source.passive_sources.unshift([mount_point, :file_system, absolute_path(dir), glob])
+    end
+
+    # Return the absolute path of the given path which is assumed to be relative to the currently
+    # loaded file.
+    def absolute_path(path)
+      File.expand_path(File.join(File.dirname(@stack.last), path))
+    end
+
+  end
+
+end

data/lib/webgen/cache.rb

@@ -1,7 +1,6 @@
 # -*- encoding: utf-8 -*-
 
 require 'set'
-require 'webgen/common'
 
 module Webgen
 
@@ -11,16 +10,17 @@ module 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.
+  #            expensive to do so. This cache is not stored between passes when writing nodes to
+  #            the destination.
   #
   # [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.
   #
-  # The standard cache should be accessed through the <tt>[]</tt> method which returns the correct
-  # value and the <tt>[]=</tt> method should be used for setting the new value. However, if you
-  # really need to access a particular value of the old or new standard cache, you can use the
-  # accessors +old_data+ and +new_data+.
+  # The standard cache should be accessed through the #[] method which returns the correct value and
+  # the #[]= method should be used for setting the new value. However, if you really need to access
+  # a particular value of the old or new standard cache, you can use the accessors +old_data+ and
+  # +new_data+.
   class Cache
 
     # The permanent cache hash.
@@ -40,7 +40,7 @@ module Webgen
       @old_data = {}
       @new_data = {}
       @volatile = {}
-      @permanent = {:classes => []}
+      @permanent = {}
     end
 
     # Return the cached data (or, if it is not available, the new data) identified by +key+ from the
@@ -58,10 +58,9 @@ module Webgen
       @new_data[key] = value
     end
 
-    # Restore the caches from +data+ and recreate all cached instances (see #instance).
+    # Restore the cache from +data+.
     def restore(data)
       @old_data, @permanent = *data
-      @permanent[:classes].each {|klass| instance(klass)}
     end
 
     # Return all caches that should be available between webgen runs.
@@ -71,15 +70,7 @@ module Webgen
 
     # Reset the volatile cache.
     def reset_volatile_cache
-      @volatile = {:classes => @volatile[:classes]}
-    end
-
-    # Return the unique instance of the class +name+ (a String). 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] ||= Common.const_for_name(name).new
+      @volatile = {}
     end
 
   end

data/lib/webgen/cli.rb

@@ -1,8 +1,15 @@
 # -*- encoding: utf-8 -*-
 
 require 'cmdparse'
+require 'yaml'
 require 'webgen/website'
 require 'webgen/version'
+require 'webgen/cli/logger'
+require 'webgen/cli/utils'
+require 'webgen/cli/generate_command'
+require 'webgen/cli/show_command'
+require 'webgen/cli/bundle_command'
+require 'webgen/cli/create_command'
 
 module Webgen
 
@@ -10,30 +17,28 @@ module Webgen
   #
   # == 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!
+  # A CLI command is an extension that can be invoked from the webgen CLI 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
+  # == Sample CLI command extension
   #
-  # Here is a sample CLI command extension which could be put, for example, into the
-  # <tt>ext/init.rb</tt> of a webgen website:
+  # Here is a sample CLI command extension:
   #
-  #   require 'webgen/cli'
-  #
-  #   class Webgen::CLI::SampleCommand < CmdParse::Command
+  #   class SampleCommand < CmdParse::Command
   #
   #     def initialize
   #       super('sample', false)
   #       self.short_desc = "This sample command just outputs its parameters"
-  #       self.description = Webgen::CLI::Utils.format("Uses the global verbosity level and outputs additional " +
-  #         "information when the level is set to verbose!")
+  #       self.description = Webgen::CLI::Utils.format_command_desc("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| @username = username}
+  #                 *Webgen::CLI::Util.format_option_desc('Specify an additional user name to output')) do |username|
+  #           @username = username
+  #         end
   #       end
   #     end
   #
@@ -43,8 +48,8 @@ module Webgen
   #       else
   #         puts "Command line arguments:"
   #         args.each {|arg| puts arg}
-  #         if commandparser.verbosity == :verbose
-  #           puts "Yeah, some additional information is always cool!"
+  #         if commandparser.log_level <= 1
+  #           puts "Some debug information here"
   #         end
   #         puts "The entered username: #{@username}" if @username
   #       end
@@ -52,77 +57,145 @@ module Webgen
   #
   #   end
   #
+  #   website.ext.cli.add_command(SampleCommand.new)
+  #
   # Note the use of Webgen::CLI::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 :WebguiCommand, 'webgen/cli/webgui_command'
-    autoload :ApplyCommand, 'webgen/cli/apply_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
+    # This is the command parser class used for handling the webgen command line interface.
+    #
+    # After creating an instance, the #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.
+      # This error is thrown when an invalid configuration option is encountered.
+      class ConfigurationOptionError < CmdParse::ParseError
+        reason 'Problem with configuration option'
+      end
+
+
+      # The website directory. Default: the value of the WEBGEN_WEBSITE environment variable or the
+      # current working directory.
+      #
+      # *Note*: Only available after the #website method has been called (which is always the case
+      # when a command is executed).
       attr_reader :directory
 
-      # The verbosity level. Default: <tt>:normal</tt>
-      attr_reader :verbosity
+      # Specifies whether verbose output should be used.
+      attr_reader :verbose
 
-      # The log level. Default: <tt>Logger::WARN</tt>
+      # The log level. Default: Logger::INFO
       attr_reader :log_level
 
-      # Create a new CommandParser class. The default webgen website (if not specified via the
-      # <tt>-d</tt> option) is taken from the environment variable +WEBGEN_WEBSITE+ or, if it is not
-      # set or empty, the current working directory.
-      def initialize # :nodoc:
-        super(true)
+      # Create a new CommandParser class.
+      def initialize
+        super(true, true, false)
         @directory = nil
-        @verbosity = :normal
-        @log_level = ::Logger::WARN
-        @log_filter = nil
+        @verbose = false
+        @do_search = false
+        @log_level = ::Logger::INFO
+        @config_options = {}
+
+        self.add_command(CmdParse::VersionCommand.new)
+        self.add_command(CmdParse::HelpCommand.new)
 
         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)") {|p| @directory = p}
-          opts.on("--verbose", "-v", "Print more output") { @verbosity = :verbose }
-          opts.on("--quiet", "-q", "No output") { @verbosity = :quiet }
-          opts.on("--log-level LEVEL", "-l", Integer, "The logging level (0..debug, 3..error)") {|p| @log_level = p}
-          opts.on("--log-filter", "-f", Regexp, 'Filter for logging events') {|p| @log_filter = p}
+          opts.on("--directory DIR", "-d", String,
+                  *Utils.format_option_desc("The website directory to use")) do |d|
+            @directory = d
+          end
+          opts.on("--search-dirs", "-s",
+                  *Utils.format_option_desc("Search parent directories for website directory")) do |s|
+            @do_search = s
+          end
+          opts.on("-c", "--[no-]color",
+                  *Utils.format_option_desc("Colorize output (default: #{Webgen::CLI::Utils.use_colors ? "yes" : "no"})")) do |a|
+            Webgen::CLI::Utils.use_colors = a
+          end
+          opts.on("-v", "--[no-]verbose",
+                  *Utils.format_option_desc("Verbose output (default: no)")) do |v|
+            @verbose = v
+          end
+          opts.on("-q", "--[no-]quiet",
+                  *Utils.format_option_desc("Quiet output (default: no)")) do |v|
+            @log_level = (v ? ::Logger::WARN : :Logger::INFO)
+          end
+          opts.on("-n", "--[no-]dry-run",
+                  *Utils.format_option_desc("Do a dry run, i.e. don't actually write anything (default: no)")) do |v|
+            @config_options['website.dry_run'] = v
+          end
+          opts.on("-o", "--option CONFIG_OPTION", String,
+                  *Utils.format_option_desc("Specify a simple configuration option (key=value)")) do |v|
+            k, v = v.split('=')
+            begin
+              @config_options[k] = YAML.load(v)
+            rescue YAML::SyntaxError
+              raise ConfigurationOptionError.new("Couldn't parse value for '#{k}': #{$!}")
+            end
+          end
+          opts.on("--[no-]debug",
+                  *Utils.format_option_desc("Enable debugging")) do |v|
+            @log_level = (v ? ::Logger::DEBUG : :Logger::INFO)
+          end
+          opts.on_tail("--version", "-V", "Show webgen version information") do
+            main_command.commands['version'].execute([])
+          end
         end
-        self.add_command(CmdParse::HelpCommand.new)
-        self.add_command(CmdParse::VersionCommand.new)
+        self.add_command(Webgen::CLI::GenerateCommand.new, true)
+        self.add_command(Webgen::CLI::ShowCommand.new)
+        self.add_command(Webgen::CLI::BundleCommand.new)
+        self.add_command(Webgen::CLI::CreateCommand.new)
       end
 
-      # Utility method for sub-commands to create the correct Webgen::Website object.
-      def create_website
-        if !defined?(@website)
-          @website = Webgen::Website.new(@directory) do |config|
-            config['logger.mask'] = @log_filter
+      # Utility method for getting the Webgen::Website object.
+      def website
+        @directory = ENV['WEBGEN_WEBSITE'] if @directory.nil? && !ENV['WEBGEN_WEBSITE'].to_s.empty?
+        if @directory.nil? && @do_search
+          dir = Dir.pwd
+          file_missing = nil
+          dir = File.dirname(dir) while dir != '/' && (file_missing = !File.exist?(File.join(dir, Webgen::Website::CONFIG_FILENAME)))
+          @directory = dir if !file_missing
+        end
+        @directory = Dir.pwd if @directory.nil?
+        @website ||= Webgen::Website.new(@directory, Webgen::CLI::Logger.new) do |site, before_init|
+          if before_init
+            site.ext.cli = self
+            site.logger.level = @log_level
+            site.logger.verbose = @verbose
+            site.logger.prefix = '[DRY-RUN] ' if @config_options['website.dry_run']
+          else
+            @config_options.each do |k, v|
+              if site.config.option?(k)
+                site.config[k] = v
+              else
+                raise ConfigurationOptionError.new("Unknown option '#{k}'")
+              end
+            end
           end
-          @website.logger.level = @log_level
-          @website.logger.verbosity = @verbosity
         end
-        @website
       end
 
-      # :nodoc:
+      # Parse the command line arguments.
+      #
+      # Once the website directory information is gathered, the Webgen::Website is initialized to
+      # allow additional CLI commands to be added by extensions.
       def parse(argv = ARGV)
-        Webgen::CLI.constants.select {|c| c =~ /.+Command$/ }.each do |c|
-          self.add_command(Webgen::CLI.const_get(c).new, (c.to_s == 'RunCommand' ? true : false))
+        super do |level, name|
+          if level == 0
+            # Create website object/automatically performs initialization; needed so that custom
+            # commands can be added
+            website
+          end
         end
-        super
+      rescue
+        puts "webgen encountered a problem:\n  " + $!.message
+        puts $!.backtrace if @log_level == ::Logger::DEBUG
+        exit(1)
       end
 
     end