nanoc 2.2.2 → 3.0.0a1

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

@@ -1,8 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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/vendor/cri/lib/cri/option_parser.rb

@@ -1,186 +0,0 @@
-module Cri
-
-  # Cri::OptionParser is used for parsing commandline options.
-  class OptionParser
-
-    # Error that will be raised when an unknown option is encountered.
-    class IllegalOptionError < RuntimeError ; end
-
-    # Error that will be raised when an option without argument is
-    # encountered.
-    class OptionRequiresAnArgumentError < RuntimeError ; end
-
-    # Parses the commandline arguments in +arguments_and_options+, using the
-    # commandline option definitions in +definitions+.
-    #
-    # +arguments_and_options+ is an array of commandline arguments and
-    # options. This will usually be +ARGV+.
-    #
-    # +definitions+ contains a list of hashes defining which options are
-    # allowed and how they will be handled. Such a hash has three keys:
-    #
-    # :short:: The short name of the option, e.g. +a+. Do not include the '-'
-    #          prefix.
-    #
-    # :long:: The long name of the option, e.g. +all+. Do not include the '--'
-    #         prefix.
-    #
-    # :argument:: Whether this option's argument is required (:required),
-    #             optional (:optional) or forbidden (:forbidden).
-    #
-    # A sample array of definition hashes could look like this:
-    #
-    #     [
-    #       { :short => 'a', :long => 'all',  :argument => :forbidden },
-    #       { :short => 'p', :long => 'port', :argument => :required  },
-    #     ]
-    #
-    # During parsing, two errors can be raised:
-    #
-    # IllegalOptionError:: An unrecognised option was encountered, i.e. an
-    #                      option that is not present in the list of option
-    #                      definitions.
-    #
-    # OptionRequiresAnArgumentError:: An option was found that did not have a
-    #                                 value, even though this value was
-    #                                 required.
-    #
-    # What will be returned, is a hash with two keys, :arguments and :options.
-    # The :arguments value contains a list of arguments, and the :options
-    # value contains a hash with key-value pairs for each option. Options
-    # without values will have a +nil+ value instead.
-    #
-    # For example, the following commandline options (which should not be
-    # passed as a string, but as an array of strings):
-    #
-    #     foo -xyz -a hiss -s -m please --level 50 --father=ani -n luke squeak
-    #
-    # with the following option definitions:
-    #
-    #     [
-    #       { :short => 'x', :long => 'xxx',    :argument => :forbidden },
-    #       { :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  }
-    #     ]
-    #
-    # will be translated into:
-    #
-    #     {
-    #       :arguments => [ 'foo', 'hiss', 'squeak' ],
-    #       :options => {
-    #         :xxx    => true,
-    #         :yyy    => true,
-    #         :zzz    => true,
-    #         :all    => true,
-    #         :stuff  => true,
-    #         :more   => 'please',
-    #         :level  => '50',
-    #         :father => 'ani',
-    #         :name   => 'luke'
-    #       }
-    #     }
-    def self.parse(arguments_and_options, definitions)
-      # Don't touch original argument
-      unprocessed_arguments_and_options = arguments_and_options.dup
-
-      # Initialize
-      arguments = []
-      options   = {}
-
-      # Determines whether we've passed the '--' marker or not
-      no_more_options = false
-
-      loop do
-        # Get next item
-        e = unprocessed_arguments_and_options.shift
-        break if e.nil?
-
-        # Handle end-of-options marker
-        if e == '--'
-          no_more_options = true
-        # Handle incomplete options
-        elsif e =~ /^--./ and !no_more_options
-          # Get option key, and option value if included
-          if e =~ /^--([^=]+)=(.+)$/
-            option_key   = $1
-            option_value = $2
-          else
-            option_key    = e[2..-1]
-            option_value  = nil
-          end
-
-          # Find definition
-          definition = definitions.find { |d| d[:long] == option_key }
-          raise IllegalOptionError.new(option_key) if definition.nil?
-
-          if [ :required, :optional ].include?(definition[:argument])
-            # Get option value if necessary
-            if option_value.nil?
-              option_value = unprocessed_arguments_and_options.shift
-              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] = true
-          end
-        # Handle -xyz options
-        elsif e =~ /^-./ and !no_more_options
-          # Get option keys
-          option_keys = e[1..-1].scan(/./)
-
-          # For each key
-          option_keys.each do |option_key|
-            # Find definition
-            definition = definitions.find { |d| d[:short] == option_key }
-            raise IllegalOptionError.new(option_key) if definition.nil?
-
-            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)
-            elsif [ :required, :optional ].include?(definition[:argument])
-              # Get option value
-              option_value = unprocessed_arguments_and_options.shift
-              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] = true
-            end
-          end
-        # Handle normal arguments
-        else
-          arguments << e
-        end
-      end
-
-      { :options => options, :arguments => arguments }
-    end
-
-  end
-
-end

data/vendor/cri/test/test_base.rb

@@ -1,6 +0,0 @@
-class Cri::BaseTest < MiniTest::Unit::TestCase
-
-  def test_stub
-  end
-
-end

data/vendor/cri/test/test_command.rb

@@ -1,6 +0,0 @@
-class Cri::CommandTest < MiniTest::Unit::TestCase
-
-  def test_stub
-  end
-
-end

data/vendor/cri/test/test_core_ext.rb

@@ -1,21 +0,0 @@
-class Cri::CoreExtTest < MiniTest::Unit::TestCase
-
-  def test_string_wrap_and_indent
-    assert_equal(
-      "Lorem ipsum dolor sit amet, consectetur\n" +
-      "adipisicing elit, sed do eiusmod tempor\n" +
-      "incididunt ut labore et dolore magna\n" +
-      "aliqua.",
-      "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.".wrap_and_indent(40, 0)
-    )
-
-    assert_equal(
-      "    Lorem ipsum dolor sit amet,\n" +
-      "    consectetur adipisicing elit, sed\n" +
-      "    do eiusmod tempor incididunt ut\n" +
-      "    labore et dolore magna aliqua.",
-      "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.".wrap_and_indent(36, 4)
-    )
-  end
-
-end

data/vendor/cri/test/test_option_parser.rb

@@ -1,279 +0,0 @@
-class Cri::OptionParserTest < MiniTest::Unit::TestCase
-
-  def test_parse_without_options
-    input       = %w( foo bar baz )
-    definitions = []
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert_equal({},                      result[:options])
-    assert_equal([ 'foo', 'bar', 'baz' ], result[:arguments])
-  end
-
-  def test_parse_with_invalid_option
-    input       = %w( foo -x )
-    definitions = []
-
-    result = nil
-
-    assert_raises(Cri::OptionParser::IllegalOptionError) do
-      result = Cri::OptionParser.parse(input, definitions)
-    end
-  end
-
-  def test_parse_without_options
-    input       = %w( foo )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert(!result[:options][:aaa])
-  end
-
-  def test_parse_with_long_valueless_option
-    input       = %w( foo --aaa bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert(result[:options][:aaa])
-    assert_equal([ 'foo', 'bar' ], result[:arguments])
-  end
-
-  def test_parse_with_long_valueful_option
-    input       = %w( foo --aaa xxx bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert_equal({ :aaa => 'xxx' },  result[:options])
-    assert_equal([ 'foo', 'bar' ], result[:arguments])
-  end
-
-  def test_parse_with_long_valueful_equalsign_option
-    input       = %w( foo --aaa=xxx bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert_equal({ :aaa => 'xxx' },  result[:options])
-    assert_equal([ 'foo', 'bar' ], result[:arguments])
-  end
-
-  def test_parse_with_long_valueful_option_with_missing_value
-    input       = %w( foo --aaa )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
-
-    result = nil
-
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
-    end
-  end
-
-  def test_parse_with_two_long_valueful_options
-    input       = %w( foo --all --port 2 )
-    definitions = [
-      { :long => 'all',  :short => 'a', :argument => :required  },
-      { :long => 'port', :short => 'p', :argument => :required }
-    ]
-
-    result = nil
-
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
-    end
-  end
-
-  def test_parse_with_long_valueless_option_with_optional_value
-    input       = %w( foo --aaa )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert(result[:options][:aaa])
-    assert_equal([ 'foo' ], result[:arguments])
-  end
-
-  def test_parse_with_long_valueful_option_with_optional_value
-    input       = %w( foo --aaa xxx )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert_equal({ :aaa => 'xxx' },  result[:options])
-    assert_equal([ 'foo' ], result[:arguments])
-  end
-
-  def test_parse_with_long_valueless_option_with_optional_value_and_more_options
-    input       = %w( foo --aaa -b -c )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional  },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert(result[:options][:aaa])
-    assert(result[:options][:bbb])
-    assert(result[:options][:ccc])
-    assert_equal([ 'foo' ], result[:arguments])
-  end
-
-  def test_parse_with_short_valueless_options
-    input       = %w( foo -a bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert(result[:options][:aaa])
-    assert_equal([ 'foo', 'bar' ], result[:arguments])
-  end
-
-  def test_parse_with_short_valueful_option_with_missing_value
-    input       = %w( foo -a )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
-
-    result = nil
-
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
-    end
-  end
-
-  def test_parse_with_short_combined_valueless_options
-    input       = %w( foo -abc bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert(result[:options][:aaa])
-    assert(result[:options][:bbb])
-    assert(result[:options][:ccc])
-    assert_equal([ 'foo', 'bar' ], result[:arguments])
-  end
-
-  def test_parse_with_short_combined_valueful_options_with_missing_value
-    input       = %w( foo -abc bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required  },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
-
-    result = nil
-
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
-    end
-  end
-
-  def test_parse_with_two_short_valueful_options
-    input       = %w( foo -a -p 2 )
-    definitions = [
-      { :long => 'all',  :short => 'a', :argument => :required  },
-      { :long => 'port', :short => 'p', :argument => :required }
-    ]
-
-    result = nil
-
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
-    end
-  end
-
-  def test_parse_with_short_valueless_option_with_optional_value
-    input       = %w( foo -a )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert(result[:options][:aaa])
-    assert_equal([ 'foo' ], result[:arguments])
-  end
-
-  def test_parse_with_short_valueful_option_with_optional_value
-    input       = %w( foo -a xxx )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert_equal({ :aaa => 'xxx' },  result[:options])
-    assert_equal([ 'foo' ], result[:arguments])
-  end
-
-  def test_parse_with_short_valueless_option_with_optional_value_and_more_options
-    input       = %w( foo -a -b -c )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional  },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert(result[:options][:aaa])
-    assert(result[:options][:bbb])
-    assert(result[:options][:ccc])
-    assert_equal([ 'foo' ], result[:arguments])
-  end
-
-  def test_parse_with_single_hyphen
-    input       = %w( foo - bar )
-    definitions = []
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert_equal({},                    result[:options])
-    assert_equal([ 'foo', '-', 'bar' ], result[:arguments])
-  end
-
-  def test_parse_with_end_marker
-    input       = %w( foo bar -- -x --yyy -abc )
-    definitions = []
-
-    result = Cri::OptionParser.parse(input, definitions)
-
-    assert_equal({},                                      result[:options])
-    assert_equal([ 'foo', 'bar', '-x', '--yyy', '-abc' ], result[:arguments])
-  end
-
-  def test_parse_with_end_marker_between_option_key_and_value
-    input       = %w( foo --aaa -- zzz )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
-
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      result = Cri::OptionParser.parse(input, definitions)
-    end
-  end
-
-end