thor-exclude_pattern 0.18.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bca235a33ea1da0e66ade94053dcc06ecf023834
+  data.tar.gz: 23542b8124bf8d5fc94df1d2314f176837886dcd
+SHA512:
+  metadata.gz: f215dcddc3918634188e7c926d47c375e33d655ce4639df69e5ab605b7b8ba1558948317082d6d8381aa70b8127133979a3fa2b282f1bae09bf6a008518e27e0
+  data.tar.gz: 21b949470809c576cc0b17fa74455b7645f2d0c1fb15516ba4e05657b868276889a2db310a2ecf6c9d893a5ae48ca46dd069e656aa5f7b4b8235adbba624ac88

data/.document

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

data/CHANGELOG.md

@@ -0,0 +1,130 @@
+## In git
+* Add directory() config[:exclude_pattern] to prevent copying files that match certain regexp
+
+## 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,34 @@
+[![Gem Version](https://badge.fury.io/rb/thor.png)](https://rubygems.org/gems/thor)
+[![Build Status](https://secure.travis-ci.org/wycats/thor.png?branch=master)](http://travis-ci.org/wycats/thor)
+[![Dependency Status](https://gemnasium.com/wycats/thor.png?travis)](https://gemnasium.com/wycats/thor)
+[![Code Climate](https://codeclimate.com/github/wycats/thor.png)](https://codeclimate.com/github/wycats/thor)
+[![Coverage Status](https://coveralls.io/repos/wycats/thor/badge.png?branch=master)](https://coveralls.io/r/wycats/thor)
+
+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.
+
+[wiki]: https://github.com/wycats/thor/wiki
+
+License
+-------
+Released under the MIT License.  See the [LICENSE][] file for further details.
+
+[license]: LICENSE.md

data/Thorfile

@@ -0,0 +1,30 @@
+# encoding: utf-8
+$:.unshift File.expand_path("../lib", __FILE__)
+
+require 'bundler'
+require 'thor/rake_compat'
+
+class Default < Thor
+  include Thor::RakeCompat
+  Bundler::GemHelper.install_tasks
+
+  desc "build", "Build thor-#{Thor::VERSION}.gem into the pkg directory"
+  def build
+    Rake::Task["build"].execute
+  end
+
+  desc "install", "Build and install thor-#{Thor::VERSION}.gem into system gems"
+  def install
+    Rake::Task["install"].execute
+  end
+
+  desc "release", "Create tag v#{Thor::VERSION} and build and push thor-#{Thor::VERSION}.gem to Rubygems"
+  def release
+    Rake::Task["release"].execute
+  end
+
+  desc "spec", "Run RSpec code examples"
+  def spec
+    exec "rspec --color --format=documentation spec"
+  end
+end

data/bin/rake2thor

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+require 'ruby2ruby'
+require 'parse_tree'
+if Ruby2Ruby::VERSION >= "1.2.0"
+  require 'parse_tree_extensions'
+end
+require 'rake'
+
+input  = ARGV[0] || 'Rakefile'
+output = ARGV[1] || 'Thorfile'
+
+$requires = []
+
+module Kernel
+  def require_with_record(file)
+    $requires << file if caller[1] =~ /rake2thor:/
+    require_without_record file
+  end
+  alias_method :require_without_record, :require
+  alias_method :require, :require_with_record
+end
+
+load input
+
+@private_methods = []
+
+def file_task_name(name)
+  "compile_" + name.gsub('/', '_slash_').gsub('.', '_dot_').gsub(/\W/, '_')
+end
+
+def method_for_task(task)
+  file_task = task.is_a?(Rake::FileTask)
+  comment = task.instance_variable_get('@comment')
+  prereqs = task.instance_variable_get('@prerequisites').select(&Rake::Task.method(:task_defined?))
+  actions = task.instance_variable_get('@actions')
+  name = task.name.gsub(/^([^:]+:)+/, '')
+  name = file_task_name(name) if file_task
+  meth = ''
+
+  meth << "desc #{name.inspect}, #{comment.inspect}\n" if comment
+  meth << "def #{name}\n"
+
+  meth << prereqs.map do |pre|
+    pre = pre.to_s
+    pre = file_task_name(pre) if Rake::Task[pre].is_a?(Rake::FileTask)
+    '  ' + pre
+  end.join("\n")
+
+  meth << "\n\n" unless prereqs.empty? || actions.empty?
+
+  meth << actions.map do |act|
+    act = act.to_ruby
+    unless act.gsub!(/^proc \{ \|(\w+)\|\n/,
+                     "  \\1 = Struct.new(:name).new(#{name.inspect}) # A crude mock Rake::Task object\n")
+      act.gsub!(/^proc \{\n/, '')
+    end
+    act.gsub(/\n\}$/, '')
+  end.join("\n")
+
+  meth << "\nend"
+
+  if file_task
+    @private_methods << meth
+    return
+  end
+
+  meth
+end
+
+body = Rake::Task.tasks.map(&method(:method_for_task)).compact.map { |meth| meth.gsub(/^/, '  ') }.join("\n\n")
+
+unless @private_methods.empty?
+  body << "\n\n  private\n\n"
+  body << @private_methods.map { |meth| meth.gsub(/^/, '  ') }.join("\n\n")
+end
+
+requires = $requires.map { |r| "require #{r.inspect}" }.join("\n")
+
+File.open(output, 'w') { |f| f.write(<<END.lstrip) }
+#{requires}
+
+class Default < Thor
+#{body}
+end
+END

data/bin/thor

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

data/lib/thor.rb

@@ -0,0 +1,458 @@
+require 'set'
+require 'thor/base'
+
+class Thor
+  class << self
+    # 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)
+      @default_command = case meth
+      when :none
+        'help'
+      when nil
+        @default_command || from_superclass(:default_command, 'help')
+      else
+        meth.to_s
+      end
+    end
+    alias 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 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 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 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] }
+
+      shell.say "Commands:"
+      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 printable_tasks printable_commands
+
+    def subcommands
+      @subcommands ||= from_superclass(:subcommands, [])
+    end
+    alias subtasks subcommands
+
+    def subcommand(subcommand, subcommand_class)
+      self.subcommands << subcommand.to_s
+      subcommand_class.subcommand_help subcommand
+
+      define_method(subcommand) do |*args|
+        args, opts = Thor::Arguments.split(args)
+        invoke subcommand_class, args, opts, :invoked_via_subcommand => true, :class_options => options
+      end
+    end
+    alias 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 ||= Hash.new
+      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 ||= Set.new
+      @stop_on_unknown_option.merge(command_names)
+    end
+
+    def stop_on_unknown_option?(command) #:nodoc:
+      !!@stop_on_unknown_option && @stop_on_unknown_option.include?(command.name.to_sym)
+    end
+
+  protected
+
+    # The method responsible for dispatching given the args.
+    def dispatch(meth, given_args, given_opts, config) #:nodoc:
+      # There is an edge case when dispatching from a subcommand.
+      # A problem occurs invoking the default command. This case occurs
+      # when arguments are passed and a default command is defined, and
+      # the first given_args does not match the default command.
+      # Thor use "help" by default so we skip that case.
+      # Note the call to retrieve_command_name. It's called with
+      # given_args.dup since that method calls args.shift. Then lookup
+      # the command normally. If the first item in given_args is not
+      # a command then use the default command. The given_args will be
+      # intact later since dup was used.
+      if config[:invoked_via_subcommand] && given_args.size >= 1 && default_command != "help" && given_args.first != default_command
+        meth ||= retrieve_command_name(given_args.dup)
+        command = all_commands[normalize_command_name(meth)]
+        command ||= all_commands[normalize_command_name(default_command)]
+      else
+        meth ||= retrieve_command_name(given_args)
+        command = all_commands[normalize_command_name(meth)]
+      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 = Thor::DynamicCommand.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 create_command(meth) #:nodoc:
+      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 self.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 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 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
+        raise ArgumentError, "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 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 find_task_possibilities find_command_possibilities
+
+    def subcommand_help(cmd)
+      desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
+      class_eval <<-RUBY
+        def help(command = nil, subcommand = true); super; end
+      RUBY
+    end
+    alias 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)
+    command ? self.class.command_help(shell, command) : self.class.help(shell, subcommand)
+  end
+end