nanoc 2.1.6 → 2.2

data/lib/nanoc/helpers/text.rb

@@ -0,0 +1,38 @@
+module Nanoc::Helpers
+
+  # Nanoc::Helpers::Text contains several useful text-related helper functions.
+  module Text
+
+    # Returns an excerpt for the given string. HTML tags are ignored, so if
+    # you don't want them to turn up, they should be stripped from the string
+    # before passing it to the excerpt function.
+    #
+    # +params+ is a hash where the following keys can be set:
+    #
+    # +length+:: The maximum number of characters this excerpt can contain,
+    #            including the omission. Defaults to 25.
+    #
+    # +omission+:: The string to append to the excerpt when the excerpt is
+    #              shorter than the original string. Defaults to '...' (but in
+    #              HTML, you may want to use something more fancy, like
+    #              '…').
+    def excerptize(string, params={})
+      # Initialize params
+      params[:length]   ||= 25
+      params[:omission] ||= '...'
+
+      # Get excerpt
+      length = params[:length] - params[:omission].length
+      length = 0 if length < 0
+      (string.length > params[:length] ? string[0...length] + params[:omission] : string)
+    end
+
+    # Strips all HTML tags out of the given string.
+    def strip_html(string)
+      # FIXME will need something more sophisticated than this, because it sucks
+      string.gsub(/<[^>]*(>+|\s*\z)/m, '').strip
+    end
+
+  end
+
+end

data/lib/nanoc/helpers/xml_sitemap.rb

@@ -43,9 +43,10 @@ module Nanoc::Helpers
       xml.instruct!
       xml.urlset(:xmlns => 'http://www.google.com/schemas/sitemap/0.84') do
         # Add page
-        @pages.reject { |p| p.is_hidden }.each do |page|
+        @pages.reject { |p| p.is_hidden || p.skip_output }.each do |page|
           xml.url do
-            xml.loc         @page.base_url + page.path
+            loc = (@site.config[:base_url] || @page.base_url) + page.path
+            xml.loc         loc
             xml.lastmod     page.mtime.to_iso8601_date unless page.mtime.nil?
             xml.changefreq  page.changefreq unless page.changefreq.nil?
             xml.priority    page.priority unless page.priority.nil?

data/lib/nanoc/routers.rb

@@ -0,0 +1,3 @@
+require 'nanoc/routers/default'
+require 'nanoc/routers/no_dirs'
+require 'nanoc/routers/versioned'

data/vendor/cri/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Denis Defreyne and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/vendor/cri/README

@@ -0,0 +1,4 @@
+Cri
+===
+
+Cri is a library for building easy-to-use commandline tools.

data/vendor/cri/Rakefile

@@ -0,0 +1,25 @@
+##### Requirements
+
+# Rake etc
+require 'rake'
+require 'minitest/unit'
+
+# Cri itself
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/lib'))
+require 'cri'
+
+##### Testing
+
+desc 'Runs all tests'
+task :test do
+  ENV['QUIET'] ||= 'true'
+
+  $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/..'))
+
+  MiniTest::Unit.autorun
+
+  test_files = Dir['test/test_*.rb']
+  test_files.each { |f| require f }
+end
+
+task :default => :test

data/vendor/cri/lib/cri.rb

@@ -0,0 +1,12 @@
+module Cri
+
+  # The current Cri version.
+  VERSION = '1.0'
+
+end
+
+# Load Cri
+require 'cri/base'
+require 'cri/command'
+require 'cri/core_ext'
+require 'cri/option_parser'

data/vendor/cri/lib/cri/base.rb

@@ -0,0 +1,153 @@
+module Cri
+
+  # Cri::Base is the central class representing a commandline tool. It has a
+  # list of commands.
+  class Base
+
+    # The CLI's list of commands (should also contain the help command)
+    attr_reader :commands
+
+    # The CLI's help command (required)
+    attr_accessor :help_command
+
+    # Creates a new instance of the commandline tool.
+    def initialize(tool_name)
+      @tool_name = tool_name
+
+      @commands = []
+    end
+
+    # Parses the given commandline arguments and executes the requested
+    # command.
+    def run(args)
+      # Check arguments
+      if args.length == 0
+        @help_command.run([], [])
+        exit 1
+      end
+
+      # Partition options
+      opts_before_command         = []
+      command_name                = nil
+      opts_and_args_after_command = []
+      stage = 0
+      args.each do |arg|
+        # Update stage if necessary
+        stage = 1 if stage == 0 && !is_option?(arg)
+
+        # Add
+        opts_before_command << arg         if stage == 0
+        command_name = arg                 if stage == 1
+        opts_and_args_after_command << arg if stage == 2
+
+        # Update stage if necessary
+        stage = 2 if stage == 1
+      end
+
+      # Handle options before command
+      begin
+        parsed_arguments = Cri::OptionParser.parse(opts_before_command, global_option_definitions)
+      rescue Cri::OptionParser::IllegalOptionError => e
+        $stderr.puts "illegal option -- #{e}"
+        exit 1
+      end
+      parsed_arguments[:options].keys.each do |option|
+        handle_option(option)
+      end
+
+      # Get command
+      if command_name.nil?
+        $stderr.puts "no command given"
+        exit 1
+      end
+      command = command_named(command_name)
+      if command.nil?
+        $stderr.puts "no such command: #{command_name}"
+        exit 1
+      end
+
+      # Parse arguments
+      option_definitions = command.option_definitions + global_option_definitions
+      begin
+        parsed_arguments = Cri::OptionParser.parse(opts_and_args_after_command, option_definitions)
+      rescue Cri::OptionParser::IllegalOptionError => e
+        $stderr.puts "illegal option -- #{e}"
+        exit 1
+      rescue Cri::OptionParser::OptionRequiresAnArgumentError => e
+        $stderr.puts "option requires an argument -- #{e}"
+        exit 1
+      end
+
+      # Handle global options
+      global_options = global_option_definitions.map { |o| o[:long] }
+      global_options.delete_if { |o| !parsed_arguments[:options].keys.include?(o.to_sym) }
+      global_options.each { |o| handle_option(o.to_sym) }
+
+      if parsed_arguments[:options].has_key?(:help)
+        # Show help for this command
+        show_help(command)
+      else
+        # Run command
+        command.run(parsed_arguments[:options], parsed_arguments[:arguments])
+      end
+    end
+
+    # Returns the command with the given name.
+    def command_named(name)
+      # Find by exact name or alias
+      command = @commands.find { |c| c.name == name or c.aliases.include?(name) }
+      return command unless command.nil?
+
+      # Find by approximation
+      commands = @commands.select { |c| c.name[0, name.length] == name }
+      if commands.length > 1
+        $stderr.puts "#{@tool_name}: '#{name}' is ambiguous:"
+        $stderr.puts "  #{commands.map { |c| c.name }.join(' ') }"
+        exit 1
+      elsif commands.length == 0
+        $stderr.puts "#{@tool_name}: unknown command '#{name}'\n"
+        show_help
+        exit 1
+      else
+        return commands[0]
+      end
+    end
+
+    # Shows the help text for the given command, or shows the general help
+    # text if no command is given.
+    def show_help(command=nil)
+      if command.nil?
+        @help_command.run([], [])
+      else
+        @help_command.run([], [ command.name ])
+      end
+    end
+
+    # Returns the list of global option definitionss.
+    def global_option_definitions
+      []
+    end
+
+    # Adds the given command to the list of commands. Adding a command will
+    # also cause the command's +base+ to be set to this instance.
+    def add_command(command)
+      @commands << command
+      command.base = self
+    end
+
+    # Handles the given optio
+    def handle_option(option)
+      false
+    end
+
+  private
+
+    # Returns true if the given string is an option (i.e. -foo or --foo),
+    # false otherwise.
+    def is_option?(string)
+      string =~ /^-/
+    end
+
+  end
+
+end

data/{lib/nanoc/cli → vendor/cri/lib/cri}/command.rb

@@ -1,7 +1,7 @@
-module Nanoc::CLI
+module Cri
 
-  # Nanoc::CLI::Command represents a command that can be executed on the
-  # commandline. It is an abstract superclass for all commands.
+  # Cri::Command represents a command that can be executed on the commandline.
+  # It is an abstract superclass for all commands.
   class Command
 
     attr_accessor :base
@@ -39,7 +39,7 @@ module Nanoc::CLI
     end
 
     # Returns an array containing this command's option definitions. See the
-    # documentation for Nanoc::CLI::OptionParser for details on what option
+    # documentation for Cri::OptionParser for details on what option
     # definitions look like. Subclasses may implement this method if the
     # command has options.
     def option_definitions
@@ -51,8 +51,7 @@ module Nanoc::CLI
     #
     # +options+:: A hash containing the parsed commandline options. For
     #             example, '--foo=bar' will be converted into { :foo => 'bar'
-    #             }. See the Nanoc::CLI::OptionParser documentation for
-    #             details.
+    #             }. See the Cri::OptionParser documentation for details.
     #
     # +arguments+:: An array of strings representing the commandline arguments
     #               given to this command.

data/vendor/cri/lib/cri/core_ext.rb

@@ -0,0 +1,8 @@
+module Cri::CoreExtensions
+end
+
+require 'cri/core_ext/string'
+
+class String
+  include Cri::CoreExtensions::String
+end

data/vendor/cri/lib/cri/core_ext/string.rb

@@ -0,0 +1,41 @@
+module Cri::CoreExtensions
+
+  module String
+
+    # Word-wraps and indents the string.
+    #
+    # +width+:: The maximal width of each line. This also includes indentation,
+    #           i.e. the actual maximal width of the text is width-indentation.
+    #
+    # +indentation+:: The number of spaces to indent each wrapped line.
+    def wrap_and_indent(width, indentation)
+      # Split into paragraphs
+      paragraphs = self.split("\n").map { |p| p.strip }.reject { |p| p == '' }
+
+      # Wrap and indent each paragraph
+      paragraphs.map do |paragraph|
+        # Initialize
+        lines = []
+        line = ''
+
+        # Split into words
+        paragraph.split(/\s/).each do |word|
+          # Begin new line if it's too long
+          if (line + ' ' + word).length >= width
+            lines << line
+            line = ''
+          end
+
+          # Add word to line
+          line += (line == '' ? '' : ' ' ) + word
+        end
+        lines << line
+
+        # Join lines
+        lines.map { |l| ' '*indentation + l }.join("\n")
+      end.join("\n\n")
+    end
+
+  end
+
+end

data/{lib/nanoc/cli → vendor/cri/lib/cri}/option_parser.rb

@@ -1,6 +1,6 @@
-module Nanoc::CLI
+module Cri
 
-  # Nanoc::CLI::OptionParser is used for parsing commandline options.
+  # Cri::OptionParser is used for parsing commandline options.
   class OptionParser
 
     # Error that will be raised when an unknown option is encountered.
@@ -25,8 +25,8 @@ module Nanoc::CLI
     # :long:: The long name of the option, e.g. +all+. Do not include the '--'
     #         prefix.
     #
-    # :argument:: Whether this option's argument is required (:required) or
-    #             forbidden (:forbidden).
+    # :argument:: Whether this option's argument is required (:required),
+    #             optional (:optional) or forbidden (:forbidden).
     #
     # A sample array of definition hashes could look like this:
     #
@@ -53,7 +53,7 @@ module Nanoc::CLI
     # For example, the following commandline options (which should not be
     # passed as a string, but as an array of strings):
     #
-    #     foo bar -xyz -a hiss --level 50 --father=ani -n luke squeak
+    #     foo -xyz -a hiss -s -m please --level 50 --father=ani -n luke squeak
     #
     # with the following option definitions:
     #
@@ -62,6 +62,8 @@ module Nanoc::CLI
     #       { :short => 'y', :long => 'yyy',    :argument => :forbidden },
     #       { :short => 'z', :long => 'zzz',    :argument => :forbidden },
     #       { :short => 'a', :long => 'all',    :argument => :forbidden },
+    #       { :short => 's', :long => 'stuff',  :argument => :optional  },
+    #       { :short => 'm', :long => 'more',   :argument => :optional  },
     #       { :short => 'l', :long => 'level',  :argument => :required  },
     #       { :short => 'f', :long => 'father', :argument => :required  },
     #       { :short => 'n', :long => 'name',   :argument => :required  }
@@ -70,12 +72,14 @@ module Nanoc::CLI
     # will be translated into:
     #
     #     {
-    #       :arguments => [ 'foo', 'bar', 'hiss', 'squeak' ],
+    #       :arguments => [ 'foo', 'hiss', 'squeak' ],
     #       :options => {
-    #         :xxx    => nil,
-    #         :yyy    => nil,
-    #         :zzz    => nil,
-    #         :all    => nil,
+    #         :xxx    => true,
+    #         :yyy    => true,
+    #         :zzz    => true,
+    #         :all    => true,
+    #         :stuff  => true,
+    #         :more   => 'please',
     #         :level  => '50',
     #         :father => 'ani',
     #         :name   => 'luke'
@@ -115,18 +119,25 @@ module Nanoc::CLI
           definition = definitions.find { |d| d[:long] == option_key }
           raise IllegalOptionError.new(option_key) if definition.nil?
 
-          if definition[:argument] == :required
+          if [ :required, :optional ].include?(definition[:argument])
             # Get option value if necessary
             if option_value.nil?
               option_value = unprocessed_arguments_and_options.shift
-              raise OptionRequiresAnArgumentError.new(option_key) if option_value.nil?
+              if option_value.nil? || option_value =~ /^-/
+                if definition[:argument] == :required
+                  raise OptionRequiresAnArgumentError.new(option_key)
+                else
+                  unprocessed_arguments_and_options.unshift(option_value)
+                  option_value = true
+                end
+              end
             end
 
             # Store option
             options[definition[:long].to_sym] = option_value
           else
             # Store option
-            options[definition[:long].to_sym] = nil
+            options[definition[:long].to_sym] = true
           end
         # Handle -xyz options
         elsif e =~ /^-./ and !no_more_options
@@ -141,17 +152,24 @@ module Nanoc::CLI
 
             if option_keys.length > 1 and definition[:argument] == :required
               # This is a combined option and it requires an argument, so complain
-              raise OptionRequiresAnArgumentError.new(option_key) if option_value.nil?
-            elsif definition[:argument] == :required
+              raise OptionRequiresAnArgumentError.new(option_key)
+            elsif [ :required, :optional ].include?(definition[:argument])
               # Get option value
               option_value = unprocessed_arguments_and_options.shift
-              raise OptionRequiresAnArgumentError.new(option_key) if option_value.nil?
+              if option_value.nil? || option_value =~ /^-/
+                if definition[:argument] == :required
+                  raise OptionRequiresAnArgumentError.new(option_key)
+                else
+                  unprocessed_arguments_and_options.unshift(option_value)
+                  option_value = true
+                end
+              end
 
               # Store option
               options[definition[:long].to_sym] = option_value
             else
               # Store option
-              options[definition[:long].to_sym] = nil
+              options[definition[:long].to_sym] = true
             end
           end
         # Handle normal arguments