webgen 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4549cd7e320897cf555980fefa9d6f11a29c7d73
-  data.tar.gz: 1e5fcd72bc28df47eb681939fe34c562f11fb09e
+  metadata.gz: 8a60ac4c86998c240ed99fd35a34d68d4c58a9ab
+  data.tar.gz: 36a48c6b290e92da90225f76b3dda06557fe57c9
 SHA512:
-  metadata.gz: 8b30674ab19c718895f896a880b2a3d1c3d1416ab2234b9ccff7abced4cac9ae8aba8d63a8737f60da328e7eedbaa743d5196ca3a5c4e248bfa457bb535b6e09
-  data.tar.gz: 8241e6eecf941a6232d7a0744d4ced310c63d42a11ddecb769ff59488c06512930784e92068ced694a52955fb9a75032a7bdfd5993d9d9a86a593a35a2456cad
+  metadata.gz: 54a4999cee44f7498f01c7e1131e8d64a17c0a8581cda6c4f79577541a436df7d2f9624a1ba79407fec581c923115ad01fca3037c1804c5f8c47e12fe4aeb9e5
+  data.tar.gz: fdcecf0497be5d33dc7514aab8775326132c8addfcc5d1fcf4c55e2742edcfff3007c789de6a63b37170a9bfac78bc9fd118920699a06bcd4048a2b73b83c7f0

data/Rakefile

@@ -105,9 +105,9 @@ EOF
 
     #### Dependencies, requirements and files
 
-    s.required_ruby_version = '>= 1.9.3'
+    s.required_ruby_version = '>= 2.0.0'
 
-    s.add_dependency('cmdparse', '~> 2.0', '>= 2.0.5')
+    s.add_dependency('cmdparse', '~> 3.0', '>= 3.0.1')
     s.add_dependency('systemu', '~> 2.5')
     s.add_dependency('kramdown', '~> 1.3')
     s.add_development_dependency('rake', '>= 0.8.3')

data/VERSION

@@ -1 +1 @@
-1.3.0
+1.4.0

data/data/webgen/passive_sources/stylesheets/api.css

@@ -61,7 +61,7 @@
 }
 
 .api-documentation .description p {
-  margin: 1em 0.4em;
+  margin: 1em 0;
 }
 
 .api-documentation .description li p {
@@ -183,9 +183,8 @@
 .api-documentation .method-detail {
   margin: 0.5em 0;
   padding: 0.5em 0;
-  cursor: pointer;
 }
-.api-documentation .method-detail:hover {
+.api-documentation .method-detail:hover, .api-documentation :target {
   background-color: #f1edba;
 }
 .api-documentation .method-heading {
@@ -244,7 +243,6 @@
 }
 
 .api-documentation #attribute-method-details .method-detail:hover {
-  background-color: transparent;
   cursor: default;
 }
 .api-documentation .attribute-access-type {

data/data/webgen/passive_sources/templates/api.template

@@ -15,7 +15,7 @@ end
 --- name:klass pipeline:erb
 <% klass = context.node.node_info[:rdoc_object] %>
 <div class="api-documentation api-<%= klass.type %>">
-  <h1 class="<%= klass.type %>"><%= klass.type %> <%= klass.full_name %></h1>
+  <h2 class="<%= klass.type %>"><%= klass.type %> <%= klass.full_name %></h2>
 
   <div class="description">
     <%= klass.description %>

data/data/webgen/passive_sources/templates/feed.template

@@ -42,7 +42,7 @@
 <rss version="2.0">
   <channel>
     <title><%= h(context.node['title']) %></title>
-    <link><%= context.node.feed_link %>"</link>
+    <link><%= context.node.feed_link %></link>
     <description><%= h(context.node['description']) %></description>
     <% if context.node['created_at'].kind_of?(Time) %>
     <pubdate><%= context.node['created_at'].rfc822 %></pubdate>

data/lib/webgen/cli.rb

@@ -19,7 +19,7 @@ module Webgen
   #
   # 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!
+  # package have a look at http://cmdparse.gettalong.org!
   #
   # == Sample CLI command extension
   #
@@ -28,39 +28,31 @@ module Webgen
   #   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_command_desc("Uses the global verbosity level " +
-  #         "and outputs additional "information when the level is set to verbose!")
+  #       super('sample', takes_commands: false)
+  #       short_desc("This sample command just outputs its parameters")
+  #       description("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,
-  #                 *Webgen::CLI::Util.format_option_desc('Specify an additional user name to output')) do |username|
-  #           @username = username
-  #         end
+  #       options.on('-u', '--user USER', String, 'Specify an additional user name to output') do |username|
+  #         @username = 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.log_level <= 1
-  #           puts "Some debug information here"
-  #         end
-  #         puts "The entered username: #{@username}" if @username
+  #     def execute(required, *optional)
+  #       puts "Command line arguments:"
+  #       ([required] + optional).each {|arg| puts arg}
+  #       if command_parser.log_level <= 1
+  #         puts "Some debug information here"
   #       end
+  #       puts "The entered username: #{@username}" if @username
   #     end
   #
   #   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!
+  # The Webgen::CLI::Utils module provides some useful methods for outputting formatted or
+  # highlighted text.
   #
   module CLI
 
@@ -91,65 +83,67 @@ module Webgen
 
       # Create a new CommandParser class.
       def initialize
-        super(false, true, false)
+        super(handle_exceptions: :no_help)
         @directory = nil
         @verbose = false
         @do_search = false
         @log_level = ::Logger::INFO
         @config_options = {}
 
-        self.add_command(CmdParse::VersionCommand.new)
-        self.add_command(CmdParse::HelpCommand.new)
+        add_command(CmdParse::VersionCommand.new(add_switches: false))
+        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,
-                  *Utils.format_option_desc("The website directory to use")) do |d|
+        main_options.program_name = "webgen"
+        main_options.version = Webgen::VERSION
+        main_options do |opts|
+          opts.on("--directory DIR", "-d", String, "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|
+          opts.on("--search-dirs", "-s", "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|
+          opts.on("--version", "-V", "Show webgen version information") do
+            main_command.commands['version'].execute
+          end
+        end
+
+        global_options do |opts|
+          opts.on("-c", "--[no-]color", "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|
+          opts.on("-v", "--[no-]verbose", "Verbose output (default: no)") do |v|
             @verbose = v
+            update_logger(@website.logger) unless @website.nil?
           end
-          opts.on("-q", "--[no-]quiet",
-                  *Utils.format_option_desc("Quiet output (default: no)")) do |v|
+          opts.on("-q", "--[no-]quiet", "Quiet output (default: no)") do |v|
             @log_level = (v ? ::Logger::WARN : :Logger::INFO)
+            update_logger(@website.logger) unless @website.nil?
           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|
+          opts.on("-n", "--[no-]dry-run", "Do a dry run, i.e. don't actually write anything (default: no)") do |v|
             @config_options['website.dry_run'] = v
+            unless @website.nil?
+              update_config(@website.config)
+              update_logger(@website.logger)
+            end
           end
-          opts.on("-o", "--option CONFIG_OPTION", String,
-                  *Utils.format_option_desc("Specify a simple configuration option (key=value)")) do |v|
+          opts.on("-o", "--option CONFIG_OPTION", String, "Specify a simple configuration option (key=value)") do |v|
             k, v = v.split('=')
             begin
               @config_options[k.to_s] = YAML.load(v.to_s)
             rescue YAML::SyntaxError
               raise ConfigurationOptionError.new("Couldn't parse value for '#{k}': #{$!}")
             end
+            update_config(@website.config) unless @website.nil?
           end
-          opts.on("--[no-]debug",
-                  *Utils.format_option_desc("Enable debugging")) do |v|
+          opts.on("--[no-]debug", "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([])
+            update_logger(@website.logger) unless @website.nil?
           end
         end
-        self.add_command(Webgen::CLI::GenerateCommand.new, true)
-        self.add_command(Webgen::CLI::ShowCommand.new)
-        self.add_command(Webgen::CLI::CreateCommand.new)
-        self.add_command(Webgen::CLI::InstallCommand.new)
+        add_command(Webgen::CLI::GenerateCommand.new, default: true)
+        add_command(Webgen::CLI::ShowCommand.new)
+        add_command(Webgen::CLI::CreateCommand.new)
+        add_command(Webgen::CLI::InstallCommand.new)
       end
 
       # Utility method for getting the Webgen::Website object.
@@ -169,20 +163,30 @@ module Webgen
         @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']
+            update_logger(site.logger)
           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
+            update_config(site.config)
+          end
+        end
+      end
+
+      def update_logger(logger)
+        logger.level = @log_level
+        logger.verbose = @verbose
+        logger.prefix = '[DRY-RUN] ' if @config_options['website.dry_run']
+      end
+      private :update_logger
+
+      def update_config(config)
+        @config_options.each do |k, v|
+          if config.option?(k)
+            config[k] = v
+          else
+            raise ConfigurationOptionError.new("Unknown option '#{k}'")
           end
         end
       end
+      private :update_config
 
       # Parse the command line arguments.
       #

data/lib/webgen/cli/commands/create.rb

@@ -11,12 +11,10 @@ module Webgen
     class CreateCommand < CmdParse::Command
 
       def initialize # :nodoc:
-        super('create', true, true, false)
-        self.short_desc = 'Create some product'
-        self.description = Webgen::CLI::Utils.format_command_desc(<<DESC)
-Groups various commands together that are used for creating products, like a
-website or an extension bundle.
-DESC
+        super('create')
+        short_desc('Create a website or an extension bundle')
+        long_desc("Groups various commands together that are used for creating products, like a " +
+                  "website or an extension bundle")
         add_command(CreateWebsiteCommand.new)
         add_command(CreateBundleCommand.new)
       end

data/lib/webgen/cli/commands/create_bundle.rb

@@ -11,33 +11,23 @@ module Webgen
     class CreateBundleCommand < CmdParse::Command
 
       def initialize # :nodoc:
-        super('bundle', false, false, true)
-        self.short_desc = 'Create an extension bundle'
-        self.description = Utils.format_command_desc(<<DESC)
+        super('bundle', takes_commands: false)
+        short_desc('Create an extension bundle')
+        long_desc(<<DESC)
 Creates a new extension bundle. This command can either create a local bundle in the
 website's ext/ directory or a bundle that can be distributed via Rubygems. In the
 latter case you can optionally specify the directory under which the bundle should
 be created.
 DESC
-        self.options = CmdParse::OptionParserWrapper.new do |opts|
-          opts.separator "Options:"
-          opts.on("-d", "--distribution-format",
-                  *Utils.format_option_desc("Create the bundle in distribution format")) do
-            @type = :gem
-          end
+        options.on("-d", "--distribution-format", "Create the bundle in distribution format") do
+          @type = :gem
         end
         @type = :local
       end
 
-      def usage # :nodoc:
-        "Usage: webgen [global options] create bundle [options] BUNDLE_NAME [DIRECTORY]"
-      end
-
-      def execute(args) # :nodoc:
-        bundle_name = args.shift
-        raise "The argument NAME is mandatory" if bundle_name.to_s.empty?
-        directory = args.shift || bundle_name
-        commandparser.website.execute_task(:create_bundle, bundle_name, @type, directory)
+      def execute(bundle_name, directory = nil) # :nodoc:
+        directory ||= bundle_name
+        command_parser.website.execute_task(:create_bundle, bundle_name, @type, directory)
       end
 
     end

data/lib/webgen/cli/commands/create_website.rb

@@ -10,9 +10,9 @@ module Webgen
     class CreateWebsiteCommand < CmdParse::Command
 
       def initialize # :nodoc:
-        super('website', false)
-        self.short_desc = 'Create a basic webgen website'
-        self.description = Utils.format_command_desc(<<DESC)
+        super('website', takes_commands: false)
+        short_desc('Create a basic webgen website')
+        long_desc(<<DESC)
 Creates a webgen website at the specified directory. If the --template
 option is not used, a basic website is created. Otherwise the template
 defines the content of website.
@@ -22,36 +22,30 @@ displayed.
 DESC
 
         @template = nil
-        self.options = CmdParse::OptionParserWrapper.new do |opts|
-          opts.separator "Options:"
-          opts.on('-t', '--template TEMPLATE', String, "A website template (optional)") do |val|
-            @template = val
-          end
-          opts.separator ""
-          opts.separator "Arguments:"
-          opts.separator opts.summary_indent + "DIR: the directory in which the website should be created"
+        options.on('-t', '--template TEMPLATE', String, "A website template (optional)") do |val|
+          @template = val
         end
       end
 
-      def show_help #:nodoc:
-        super
-        templates = commandparser.website.ext.task.data(:create_website)[:templates].keys.sort
-        puts "Available templates:"
+      def help #:nodoc:
+        help_output = super
+        templates = command_parser.website.ext.task.data(:create_website)[:templates].keys.sort
+        help_output << "Available templates:\n"
         output = if templates.empty?
                    "No templates available"
                  else
                    templates.join(', ')
                  end
-        puts Utils.format(output, Utils::DEFAULT_WIDTH - 4, 4, true).join("\n")
+        help_output << Utils.format(output, command_parser.help_line_width - command_parser.help_indent, 
+                                    command_parser.help_indent, true).join("\n")
       end
 
-      def execute(args) # :nodoc:
-        raise OptionParser::MissingArgument.new('DIR') if args.length == 0
-        Webgen::Website.new(args[0], Webgen::CLI::Logger.new) do |website|
-          website.logger.verbose = commandparser.verbose
+      def execute(dir) # :nodoc:
+        Webgen::Website.new(dir, Webgen::CLI::Logger.new) do |website|
+          website.logger.verbose = command_parser.verbose
           website.config['website.tmpdir'] = Dir.tmpdir
         end.execute_task(:create_website, @template)
-        puts "Created a new webgen website in <#{args[0]}>" + (@template ? " using the '#{@template}' template" : '')
+        puts "Created a new webgen website in <#{dir}>" + (@template ? " using the '#{@template}' template" : '')
       rescue Webgen::Task::CreateWebsite::Error => e
         puts "An error occured while creating the website: #{e.message}"
       end

data/lib/webgen/cli/commands/generate.rb

@@ -9,24 +9,18 @@ module Webgen
     class GenerateCommand < CmdParse::Command
 
       def initialize # :nodoc:
-        super('generate', false, false, false)
-        self.short_desc = 'Generate the webgen website'
-        self.description = Webgen::CLI::Utils.format_command_desc(<<EOF)
-This command is executed by default when no other command was specified.
-EOF
-        self.options = CmdParse::OptionParserWrapper.new do |opts|
-          opts.separator "Options:"
-          opts.on('-a', '--auto [SEC]', Integer,
-                  *Utils.format_option_desc("Auto-generate the website every SEC seconds (5=default, 0=off)")) do |val|
-            @auto_generate_secs = val || 5
-          end
+        super('generate', takes_commands: false)
+        short_desc('Generate the webgen website')
+        long_desc("This command is executed by default when no other command was specified.")
+        options.on('-a', '--auto [SEC]', Integer, "Auto-generate the website every SEC seconds (5=default, 0=off)") do |val|
+          @auto_generate_secs = val || 5
         end
         @auto_generate_secs = 0
       end
 
-      def execute(args) # :nodoc:
+      def execute # :nodoc:
         if @auto_generate_secs <= 0
-          commandparser.website.execute_task(:generate_website)
+          command_parser.website.execute_task(:generate_website)
         else
           auto_generate
         end
@@ -38,8 +32,8 @@ EOF
         time = Time.now
         abort = false
         old_paths = []
-        dirs = "{" << commandparser.website.config['sources'].map do |mp, type, *args|
-          type == :file_system ? File.join(commandparser.website.directory, args[0], args[1] || '**/*') : nil
+        dirs = "{" << command_parser.website.config['sources'].map do |mp, type, *args|
+          type == :file_system ? File.join(command_parser.website.directory, args[0], args[1] || '**/*') : nil
         end.compact.join(',') << "}"
 
         Signal.trap('INT') {abort = true}
@@ -48,7 +42,7 @@ EOF
           paths = Dir[dirs].sort
           if old_paths != paths || paths.any? {|p| File.file?(p) && File.mtime(p) > time}
             begin
-              commandparser.website(true).execute_task(:generate_website)
+              command_parser.website(true).execute_task(:generate_website)
             rescue Webgen::Error => e
               puts e.message
             end