groovenauts-thor 0.19.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 50bf117f0d68ddcfe5e636f1870b2fbd2dad3fef
+  data.tar.gz: 855428579e458e1ea6a90b31af2241225b2df5f1
+SHA512:
+  metadata.gz: e972d72e4fb95c8d2ec7eeb7778c7ec827061712134202fb762aaca9e406d0fde272dd736cc2a141f32ea9ee46e7e4c8568bffc0ff45f2cea359d75a7df62d53
+  data.tar.gz: 5765b1f7284d310098ffcb9f2e7a76ff077d15ab85aec4e1a6fc9595d883b09f50fd8d2645de7c8823b59bf023fd147085b407392cb720459de3be692ba3be2c

data/.document

@@ -0,0 +1,5 @@
+lib/*.rb
+lib/**/*.rb
+-
+CHANGELOG.rdoc
+LICENSE.md

data/CHANGELOG.md

@@ -0,0 +1,163 @@
+## 0.19.1, release 2014-03-24
+* Fix `say` non-String break regression
+
+## 0.19.0, release 2014-03-22
+* Add support for a default to #ask
+* Avoid @namespace not initialized warning
+* Avoid private attribute? warning
+* Fix initializing with unknown options
+* Loosen required_rubygems_version for compatibility with Ubuntu 10.04
+* Shell#ask: support a noecho option for stdin
+* Shell#ask: change API to be :echo => false
+* Display a message without a stack trace for ambiguous commands
+* Make say and say_status thread safe
+* Dependency for console io version check
+* Alias --help to help on subcommands
+* Use mime-types 1.x for Ruby 1.8.7 compatibility for Ruby 1.8 only
+* Accept .tt files as templates
+* Check if numeric value is in enum
+* Use Readline for user input
+* Fix dispatching of subcommands (concerning :help and *args)
+* Fix warnings when running specs with `$VERBOSE = true`
+* Make subcommand help more consistent
+* Make the current command chain accessible in command
+
+## 0.18.1, release 2013-03-30
+* Revert regressions found in 0.18.0
+
+## 0.18.0, release 2013-03-26
+* Remove rake2thor
+* Only display colors if output medium supports colors
+* Pass parent_options to subcommands
+* Fix non-dash-prefixed aliases
+* Make error messages more helpful
+* Rename "task" to "command"
+* Add the method to allow for custom package name
+
+## 0.17.0, release 2013-01-24
+* Add better support for tasks that accept arbitrary additional arguments (e.g. things like `bundle exec`)
+* Add #stop_on_unknown_option!
+* Only strip from stdin.gets if it wasn't ended with EOF
+* Allow "send" as a task name
+* Allow passing options as arguments after "--"
+* Autoload Thor::Group
+
+## 0.16.0, release 2012-08-14
+* Add enum to string arguments
+
+## 0.15.4, release 2012-06-29
+* Fix regression when destination root contains reserved regexp characters
+
+## 0.15.3, release 2012-06-18
+* Support strict_args_position! for backwards compatibility
+* Escape Dir glob characters in paths
+
+## 0.15.2, released 2012-05-07
+* Added print_in_columns
+* Exposed terminal_width as a public API
+
+## 0.15.1, release 2012-05-06
+* Fix Ruby 1.8 truncation bug with unicode chars
+* Fix shell delegate methods to pass their block
+* Don't output trailing spaces when printing the last column in a table
+
+## 0.15, released 2012-04-29
+* Alias method_options to options
+* Refactor say to allow multiple colors
+* Exposed error as a public API
+* Exposed file_collision as a public API
+* Exposed print_wrapped as a public API
+* Exposed set_color as a public API
+* Fix number-formatting bugs in print_table
+* Fix "indent" typo in print_table
+* Fix Errno::EPIPE when piping tasks to `head`
+* More friendly error messages
+
+## 0.14, released 2010-07-25
+* Added CreateLink class and #link_file method
+* Made Thor::Actions#run use system as default method for system calls
+* Allow use of private methods from superclass as tasks
+* Added mute(&block) method which allows to run block without any output
+* Removed config[:pretend]
+* Enabled underscores for command line switches
+* Added Thor::Base.basename which is used by both Thor.banner and Thor::Group.banner
+* Deprecated invoke() without arguments
+* Added :only and :except to check_unknown_options
+
+## 0.13, released 2010-02-03
+* Added :lazy_default which is only triggered if a switch is given
+* Added Thor::Shell::HTML
+* Added subcommands
+* Decoupled Thor::Group and Thor, so it's easier to vendor
+* Added check_unknown_options! in case you want error messages to be raised in valid switches
+* run(command) should return the results of command
+
+## 0.12, released 2010-01-02
+* Methods generated by attr_* are automatically not marked as tasks
+* inject_into_file does not add the same content twice, unless :force is set
+* Removed rr in favor to rspec mock framework
+* Improved output for thor -T
+* [#7] Do not force white color on status
+* [#8] Yield a block with the filename on directory
+
+## 0.11, released 2009-07-01
+* Added a rake compatibility layer. It allows you to use spec and rdoc tasks on
+  Thor classes.
+* BACKWARDS INCOMPATIBLE: aliases are not generated automatically anymore
+  since it may cause wrong behavior in the invocation system.
+* thor help now show information about any class/task. All those calls are
+  possible:
+
+      thor help describe
+      thor help describe:amazing
+  Or even with default namespaces:
+
+      thor help :spec
+* Thor::Runner now invokes the default task if none is supplied:
+
+      thor describe # invokes the default task, usually help
+* Thor::Runner now works with mappings:
+
+      thor describe -h
+* Added some documentation and code refactoring.
+
+## 0.9.8, released 2008-10-20
+* Fixed some tiny issues that were introduced lately.
+
+## 0.9.7, released 2008-10-13
+* Setting global method options on the initialize method works as expected:
+  All other tasks will accept these global options in addition to their own.
+* Added 'group' notion to Thor task sets (class Thor); by default all tasks
+  are in the 'standard' group. Running 'thor -T' will only show the standard
+  tasks - adding --all will show all tasks. You can also filter on a specific
+  group using the --group option: thor -T --group advanced
+
+## 0.9.6, released 2008-09-13
+* Generic improvements
+
+## 0.9.5, released 2008-08-27
+* Improve Windows compatibility
+* Update (incorrect) README and task.thor sample file
+* Options hash is now frozen (once returned)
+* Allow magic predicates on options object. For instance: `options.force?`
+* Add support for :numeric type
+* BACKWARDS INCOMPATIBLE: Refactor Thor::Options. You cannot access shorthand forms in options hash anymore (for instance, options[:f])
+* Allow specifying optional args with default values: method_options(:user => "mislav")
+* Don't write options for nil or false values. This allows, for example, turning color off when running specs.
+* Exit with the status of the spec command to help CI stuff out some.
+
+## 0.9.4, released 2008-08-13
+* Try to add Windows compatibility.
+* BACKWARDS INCOMPATIBLE: options hash is now accessed as a property in your class and is not passed as last argument anymore
+* Allow options at the beginning of the argument list as well as the end.
+* Make options available with symbol keys in addition to string keys.
+* Allow true to be passed to Thor#method_options to denote a boolean option.
+* If loading a thor file fails, don't give up, just print a warning and keep going.
+* Make sure that we re-raise errors if they happened further down the pipe than we care about.
+* Only delete the old file on updating when the installation of the new one is a success
+* Make it Ruby 1.8.5 compatible.
+* Don't raise an error if a boolean switch is defined multiple times.
+* Thor::Options now doesn't parse through things that look like options but aren't.
+* Add URI detection to install task, and make sure we don't append ".thor" to URIs
+* Add rake2thor to the gem binfiles.
+* Make sure local Thorfiles override system-wide ones.

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Yehuda Katz, Eric Hodel, et al.
+
+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/README.md

@@ -0,0 +1,41 @@
+Thor
+====
+
+[![Gem Version](http://img.shields.io/gem/v/thor.svg)][gem]
+[![Build Status](http://img.shields.io/travis/erikhuda/thor.svg)][travis]
+[![Dependency Status](http://img.shields.io/gemnasium/erikhuda/thor.svg)][gemnasium]
+[![Code Climate](http://img.shields.io/codeclimate/github/erikhuda/thor.svg)][codeclimate]
+[![Coverage Status](http://img.shields.io/coveralls/erikhuda/thor.svg)][coveralls]
+
+[gem]: https://rubygems.org/gems/thor
+[travis]: http://travis-ci.org/erikhuda/thor
+[gemnasium]: https://gemnasium.com/erikhuda/thor
+[codeclimate]: https://codeclimate.com/github/erikhuda/thor
+[coveralls]: https://coveralls.io/r/erikhuda/thor
+
+Description
+-----------
+Thor is a simple and efficient tool for building self-documenting command line
+utilities.  It removes the pain of parsing command line options, writing
+"USAGE:" banners, and can also be used as an alternative to the [Rake][rake]
+build tool.  The syntax is Rake-like, so it should be familiar to most Rake
+users.
+
+[rake]: https://github.com/jimweirich/rake
+
+Installation
+------------
+    gem install thor
+
+Usage and documentation
+-----------------------
+Please see the [wiki][] for basic usage and other documentation on using Thor. You can also checkout the [official homepage][homepage].
+
+[wiki]: https://github.com/erikhuda/thor/wiki
+[homepage]: http://whatisthor.com/
+
+License
+-------
+Released under the MIT License.  See the [LICENSE][] file for further details.
+
+[license]: LICENSE.md

data/bin/groovenauts-thor

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+
+require "thor/runner"
+$thor_runner = true
+Thor::Runner.start

data/groovenauts-thor.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path("../lib/", __FILE__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
+require "thor/version"
+
+Gem::Specification.new do |spec|
+  spec.add_development_dependency "bundler", "~> 1.0"
+  # spec.authors = ["Yehuda Katz", "José Valim"]
+  spec.authors = ["Takeshi Akima"]
+  spec.description = "Thor is a toolkit for building powerful command-line interfaces."
+  # spec.email = "ruby-thor@googlegroups.com"
+  spec.email = "t-akima@groovenauts.jp"
+  # spec.executables = %w[thor]
+  spec.executables = %w[groovenauts-thor]
+  spec.files = %w[.document groovenauts-thor.gemspec] + Dir['*.md', 'bin/*', 'lib/**/*.rb']
+  # spec.homepage = "http://whatisthor.com/"
+  spec.homepage = "https://github.com/groovenauts/thor"
+  spec.licenses = %w[MIT]
+  spec.name = "groovenauts-thor"
+  spec.require_paths = %w[lib]
+  spec.required_rubygems_version = ">= 1.3.5"
+  spec.summary = spec.description
+  spec.version = Thor::VERSION
+end

data/lib/thor.rb

@@ -0,0 +1,487 @@
+require "set"
+require "thor/base"
+
+class Thor # rubocop:disable ClassLength
+  class << self
+    # Allows for custom "Command" package naming.
+    #
+    # === Parameters
+    # name<String>
+    # options<Hash>
+    #
+    def package_name(name, options = {})
+      @package_name = name.nil? || name == "" ? nil : name
+    end
+
+    # Sets the default command when thor is executed without an explicit command to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the default command
+    #
+    def default_command(meth = nil)
+      if meth
+        @default_command = meth == :none ? "help" : meth.to_s
+      else
+        @default_command ||= from_superclass(:default_command, "help")
+      end
+    end
+    alias_method :default_task, :default_command
+
+    # Registers another Thor subclass as a command.
+    #
+    # ==== Parameters
+    # klass<Class>:: Thor subclass to register
+    # command<String>:: Subcommand name to use
+    # usage<String>:: Short usage for the subcommand
+    # description<String>:: Description for the subcommand
+    def register(klass, subcommand_name, usage, description, options = {})
+      if klass <= Thor::Group
+        desc usage, description, options
+        define_method(subcommand_name) { |*args| invoke(klass, args) }
+      else
+        desc usage, description, options
+        subcommand subcommand_name, klass
+      end
+    end
+
+    # Defines the usage and the description of the next command.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<String>
+    # options<String>
+    #
+    def desc(usage, description, options = {})
+      if options[:for]
+        command = find_and_refresh_command(options[:for])
+        command.usage = usage             if usage
+        command.description = description if description
+      else
+        @usage, @desc, @hide = usage, description, options[:hide] || false
+      end
+    end
+
+    # Defines the long description of the next command.
+    #
+    # ==== Parameters
+    # long description<String>
+    #
+    def long_desc(long_description, options = {})
+      if options[:for]
+        command = find_and_refresh_command(options[:for])
+        command.long_description = long_description if long_description
+      else
+        @long_desc = long_description
+      end
+    end
+
+    # Maps an input to a command. If you define:
+    #
+    #   map "-T" => "list"
+    #
+    # Running:
+    #
+    #   thor -T
+    #
+    # Will invoke the list command.
+    #
+    # ==== Parameters
+    # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given command.
+    #
+    def map(mappings = nil)
+      @map ||= from_superclass(:map, {})
+
+      if mappings
+        mappings.each do |key, value|
+          if key.respond_to?(:each)
+            key.each { |subkey| @map[subkey] = value }
+          else
+            @map[key] = value
+          end
+        end
+      end
+
+      @map
+    end
+
+    # Declares the options for the next command to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    #
+    def method_options(options = nil)
+      @method_options ||= {}
+      build_options(options, @method_options) if options
+      @method_options
+    end
+
+    alias_method :options, :method_options
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined command.
+    #
+    #   def previous_command
+    #     # magic
+    #   end
+    #
+    #   method_option :foo => :bar, :for => :previous_command
+    #
+    #   def next_command
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    # :hide     - If you want to hide this option from the help.
+    #
+    def method_option(name, options = {})
+      scope = if options[:for]
+        find_and_refresh_command(options[:for]).options
+      else
+        method_options
+      end
+
+      build_option(name, options, scope)
+    end
+    alias_method :option, :method_option
+
+    # Prints help information for the given command.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # command_name<String>
+    #
+    def command_help(shell, command_name)
+      meth = normalize_command_name(command_name)
+      command = all_commands[meth]
+      handle_no_command_error(meth) unless command
+
+      shell.say "Usage:"
+      shell.say "  #{banner(command)}"
+      shell.say
+      class_options_help(shell, nil => command.options.map { |_, o| o })
+      if command.long_description
+        shell.say "Description:"
+        shell.print_wrapped(command.long_description, :indent => 2)
+      else
+        shell.say command.description
+      end
+    end
+    alias_method :task_help, :command_help
+
+    # Prints help information for this class.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    #
+    def help(shell, subcommand = false)
+      list = printable_commands(true, subcommand)
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_commands(false)
+      end
+      list.sort! { |a, b| a[0] <=> b[0] }
+
+      if defined?(@package_name) && @package_name
+        shell.say "#{@package_name} commands:"
+      else
+        shell.say "Commands:"
+      end
+
+      shell.print_table(list, :indent => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+    end
+
+    # Returns commands ready to be printed.
+    def printable_commands(all = true, subcommand = false)
+      (all ? all_commands : commands).map do |_, command|
+        next if command.hidden?
+        item = []
+        item << banner(command, false, subcommand)
+        item << (command.description ? "# #{command.description.gsub(/\s+/m, ' ')}" : "")
+        item
+      end.compact
+    end
+    alias_method :printable_tasks, :printable_commands
+
+    def subcommands
+      @subcommands ||= from_superclass(:subcommands, [])
+    end
+    alias_method :subtasks, :subcommands
+
+    def subcommand_classes
+      @subcommand_classes ||= {}
+    end
+
+    def subcommand(subcommand, subcommand_class)
+      subcommands << subcommand.to_s
+      subcommand_class.subcommand_help subcommand
+      subcommand_classes[subcommand.to_s] = subcommand_class
+
+      define_method(subcommand) do |*args|
+        args, opts = Thor::Arguments.split(args)
+        args.unshift("help") if opts.include? "--help" or opts.include? "-h"
+        invoke subcommand_class, args, opts, :invoked_via_subcommand => true, :class_options => options
+      end
+      subcommand_class.commands.each do |meth, command|
+        command.ancestor_name = subcommand
+      end
+    end
+    alias_method :subtask, :subcommand
+
+    # Extend check unknown options to accept a hash of conditions.
+    #
+    # === Parameters
+    # options<Hash>: A hash containing :only and/or :except keys
+    def check_unknown_options!(options = {})
+      @check_unknown_options ||= {}
+      options.each do |key, value|
+        if value
+          @check_unknown_options[key] = Array(value)
+        else
+          @check_unknown_options.delete(key)
+        end
+      end
+      @check_unknown_options
+    end
+
+    # Overwrite check_unknown_options? to take subcommands and options into account.
+    def check_unknown_options?(config) #:nodoc:
+      options = check_unknown_options
+      return false unless options
+
+      command = config[:current_command]
+      return true unless command
+
+      name = command.name
+
+      if subcommands.include?(name)
+        false
+      elsif options[:except]
+        !options[:except].include?(name.to_sym)
+      elsif options[:only]
+        options[:only].include?(name.to_sym)
+      else
+        true
+      end
+    end
+
+    # Stop parsing of options as soon as an unknown option or a regular
+    # argument is encountered.  All remaining arguments are passed to the command.
+    # This is useful if you have a command that can receive arbitrary additional
+    # options, and where those additional options should not be handled by
+    # Thor.
+    #
+    # ==== Example
+    #
+    # To better understand how this is useful, let's consider a command that calls
+    # an external command.  A user may want to pass arbitrary options and
+    # arguments to that command.  The command itself also accepts some options,
+    # which should be handled by Thor.
+    #
+    #   class_option "verbose",  :type => :boolean
+    #   stop_on_unknown_option! :exec
+    #   check_unknown_options!  :except => :exec
+    #
+    #   desc "exec", "Run a shell command"
+    #   def exec(*args)
+    #     puts "diagnostic output" if options[:verbose]
+    #     Kernel.exec(*args)
+    #   end
+    #
+    # Here +exec+ can be called with +--verbose+ to get diagnostic output,
+    # e.g.:
+    #
+    #   $ thor exec --verbose echo foo
+    #   diagnostic output
+    #   foo
+    #
+    # But if +--verbose+ is given after +echo+, it is passed to +echo+ instead:
+    #
+    #   $ thor exec echo --verbose foo
+    #   --verbose foo
+    #
+    # ==== Parameters
+    # Symbol ...:: A list of commands that should be affected.
+    def stop_on_unknown_option!(*command_names)
+      stop_on_unknown_option.merge(command_names)
+    end
+
+    def stop_on_unknown_option?(command) #:nodoc:
+      command && stop_on_unknown_option.include?(command.name.to_sym)
+    end
+
+  protected
+    def stop_on_unknown_option #:nodoc:
+      @stop_on_unknown_option ||= Set.new
+    end
+
+    # The method responsible for dispatching given the args.
+    def dispatch(meth, given_args, given_opts, config) #:nodoc: # rubocop:disable MethodLength
+      meth ||= retrieve_command_name(given_args)
+      command = all_commands[normalize_command_name(meth)]
+
+      if !command && config[:invoked_via_subcommand]
+        # We're a subcommand and our first argument didn't match any of our
+        # commands. So we put it back and call our default command.
+        given_args.unshift(meth)
+        command = all_commands[normalize_command_name(default_command)]
+      end
+
+      if command
+        args, opts = Thor::Options.split(given_args)
+        if stop_on_unknown_option?(command) && !args.empty?
+          # given_args starts with a non-option, so we treat everything as
+          # ordinary arguments
+          args.concat opts
+          opts.clear
+        end
+      else
+        args, opts = given_args, nil
+        command = dynamic_command_class.new(meth)
+      end
+
+      opts = given_opts || opts || []
+      config.merge!(:current_command => command, :command_options => command.options)
+
+      instance = new(args, opts, config)
+      yield instance if block_given?
+      args = instance.args
+      trailing = args[Range.new(arguments.size, -1)]
+      instance.invoke_command(command, trailing || [])
+    end
+
+    # The banner for this class. You can customize it if you are invoking the
+    # thor class by another ways which is not the Thor::Runner. It receives
+    # the command that is going to be invoked and a boolean which indicates if
+    # the namespace should be displayed as arguments.
+    #
+    def banner(command, namespace = nil, subcommand = false)
+      "#{basename} #{command.formatted_usage(self, $thor_runner, subcommand)}"
+    end
+
+    def baseclass #:nodoc:
+      Thor
+    end
+
+    def dynamic_command_class #:nodoc:
+      Thor::DynamicCommand
+    end
+
+    def create_command(meth) #:nodoc:
+      @usage ||= nil
+      @desc ||= nil
+      @long_desc ||= nil
+
+      if @usage && @desc
+        base_class = @hide ? Thor::HiddenCommand : Thor::Command
+        commands[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
+        @usage, @desc, @long_desc, @method_options, @hide = nil
+        true
+      elsif all_commands[meth] || meth == "method_missing"
+        true
+      else
+        puts "[WARNING] Attempted to create command #{meth.inspect} without usage or description. " <<
+             "Call desc if you want this method to be available as command or declare it inside a " <<
+             "no_commands{} block. Invoked from #{caller[1].inspect}."
+        false
+      end
+    end
+    alias_method :create_task, :create_command
+
+    def initialize_added #:nodoc:
+      class_options.merge!(method_options)
+      @method_options = nil
+    end
+
+    # Retrieve the command name from given args.
+    def retrieve_command_name(args) #:nodoc:
+      meth = args.first.to_s unless args.empty?
+      if meth && (map[meth] || meth !~ /^\-/)
+        args.shift
+      else
+        nil
+      end
+    end
+    alias_method :retrieve_task_name, :retrieve_command_name
+
+    # receives a (possibly nil) command name and returns a name that is in
+    # the commands hash. In addition to normalizing aliases, this logic
+    # will determine if a shortened command is an unambiguous substring of
+    # a command or alias.
+    #
+    # +normalize_command_name+ also converts names like +animal-prison+
+    # into +animal_prison+.
+    def normalize_command_name(meth) #:nodoc:
+      return default_command.to_s.gsub("-", "_") unless meth
+
+      possibilities = find_command_possibilities(meth)
+      if possibilities.size > 1
+        fail AmbiguousTaskError, "Ambiguous command #{meth} matches [#{possibilities.join(', ')}]"
+      elsif possibilities.size < 1
+        meth = meth || default_command
+      elsif map[meth]
+        meth = map[meth]
+      else
+        meth = possibilities.first
+      end
+
+      meth.to_s.gsub("-", "_") # treat foo-bar as foo_bar
+    end
+    alias_method :normalize_task_name, :normalize_command_name
+
+    # this is the logic that takes the command name passed in by the user
+    # and determines whether it is an unambiguous substrings of a command or
+    # alias name.
+    def find_command_possibilities(meth)
+      len = meth.to_s.length
+      possibilities = all_commands.merge(map).keys.select { |n| meth == n[0, len] }.sort
+      unique_possibilities = possibilities.map { |k| map[k] || k }.uniq
+
+      if possibilities.include?(meth)
+        [meth]
+      elsif unique_possibilities.size == 1
+        unique_possibilities
+      else
+        possibilities
+      end
+    end
+    alias_method :find_task_possibilities, :find_command_possibilities
+
+    def subcommand_help(cmd)
+      desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
+      class_eval "
+        def help(command = nil, subcommand = true); super; end
+"
+    end
+    alias_method :subtask_help, :subcommand_help
+  end
+
+  include Thor::Base
+
+  map HELP_MAPPINGS => :help
+
+  desc "help [COMMAND]", "Describe available commands or one specific command"
+  def help(command = nil, subcommand = false)
+    if command
+      if self.class.subcommands.include? command
+        self.class.subcommand_classes[command].help(shell, true)
+      else
+        self.class.command_help(shell, command)
+      end
+    else
+      self.class.help(shell, subcommand)
+    end
+  end
+end