crazy-yard 3.2.2

data/lib/engineyard/templates/ey_yml.rb

@@ -0,0 +1,119 @@
+require 'erb'
+
+module EY
+  module Templates
+    class EyYml
+      PATH = Pathname.new(__FILE__).dirname.join('ey.yml.erb').freeze
+
+      attr_reader :existing_config, :existing, :config, :template
+
+      def initialize(existing, template=PATH)
+        @template = template
+
+        @existing        = existing.dup
+        @environments    = @existing.delete('environments') || {}
+        @existing_config = @existing.delete('defaults') || {}
+        @config          = defaults.merge(@existing_config)
+
+        fix_config!
+      end
+
+      def to_str
+        ERB.new(template.read, 0, "<>").result(binding)
+      end
+      alias to_s to_str
+
+      def write(dest)
+        dest = Pathname.new(dest)
+        dir  = dest.dirname
+        temp = dir.join("ey.yml.tmp")
+
+        # generate first so we don't overwrite with a failed generation
+        output = to_str
+        temp.open('w') { |f| f << output }
+
+        FileUtils.mv(dest, dir.join("ey.yml.backup")) if dest.exist?
+        FileUtils.mv(temp, dest)
+      end
+
+      protected
+
+      def fix_config!
+        if config['migrate'] == nil && existing_config['migration_command']
+          config['migrate'] = true
+        end
+      end
+
+      def defaults
+        {
+          "migrate"                         => Pathname.new('db/migrate').exist?,
+          "migration_command"               => "rake db:migrate --trace",
+          "precompile_assets"               => Pathname.new('app/assets').exist?,
+          "precompile_assets_task"          => "assets:precompile",
+          "asset_dependencies"              => nil, # %w[app/assets lib/assets vendor/assets Gemfile.lock config/application.rb config/routes.rb],
+          "asset_strategy"                  => "shifting",
+          "precompile_unchanged_assets"     => false,
+          "bundle_without"                  => nil,
+          "bundle_options"                  => nil,
+          "maintenance_on_migrate"          => true,
+          "maintenance_on_restart"          => nil,
+          "verbose"                         => false,
+          "ignore_database_adapter_warning" => false,
+        }
+      end
+
+      def option_unless_default(key)
+        value = config[key]
+        if value != nil && value != defaults[key]
+          option(key, value)
+        else
+          commented_option key
+        end
+      end
+
+      def option(key, value = nil)
+        value ||= config[key]
+        dump_indented_yaml key => value
+      end
+
+      def commented_option(key)
+        data = {key => defaults[key]}
+        "  ##{dump_indented_yaml(data, 0)}"
+      end
+
+      def extra_root_options
+        out = ""
+
+        extra_defaults = config.reject { |k,v| defaults.key?(k) }
+        extra_defaults.each do |key,val|
+          out << option(key, val) << "\n"
+        end
+
+        unless existing.empty?
+          out << dump_indented_yaml(existing, 0)
+        end
+
+        out
+      end
+
+      def environment_options
+        if @environments && !@environments.empty?
+          dump_indented_yaml(@environments)
+        end
+      end
+
+      def dump_indented_yaml(data, indent=2)
+        YAML.dump(data).sub(/^---/, '').lstrip.gsub(/^/,' '*indent)
+      end
+
+      def string_to_boolean(str)
+        case str
+        when "true"  then true
+        when "false" then false
+        else str
+        end
+      end
+
+    end
+  end
+end

data/lib/engineyard/thor.rb

@@ -0,0 +1,215 @@
+$:.unshift(File.expand_path('../vendor/thor/lib/', File.dirname(__FILE__)))
+require 'thor'
+
+module EY
+  module UtilityMethods
+    protected
+    def api
+      @api ||= EY::CLI::API.new(config.endpoint, ui, options[:api_token])
+    end
+
+    def config
+      @config ||= EY::Config.new
+    end
+
+    # engineyard gem uses ui everywhere, thore supplies shell
+    def ui
+      shell
+    end
+
+    def in_repo?
+      EY::Repo.exist?
+    end
+
+    def repo
+      @repo ||= EY::Repo.new
+    end
+
+    def serverside_version
+      respond_to?(:options) && options[:serverside_version] || EY::ENGINEYARD_SERVERSIDE_VERSION
+    end
+
+    def serverside_runner(app_env, verbose, serverside_version = serverside_version(), ignore_bad_bridge = false)
+      ServersideRunner.new({
+        bridge:             app_env.environment.bridge!(ignore_bad_bridge).hostname,
+        app:                app_env.app,
+        environment:        app_env.environment,
+        verbose:            verbose,
+        serverside_version: serverside_version
+      })
+    end
+
+    def use_default_environment
+      if env = config.default_environment
+        ui.info "Using default environment #{config.default_environment.inspect} from ey.yml."
+        env
+      end
+    end
+
+    def fetch_environment(environment_name, account_name)
+      ui.info "Loading application data from Engine Yard Cloud..."
+
+      environment_name ||= use_default_environment
+      remotes = repo.remotes if in_repo?
+      constraints = {
+        environment_name: environment_name,
+        account_name:     account_name,
+        remotes:          remotes,
+      }
+
+      resolver = api.resolve_environments(constraints)
+
+      resolver.one_match { |match| return match  }
+
+      resolver.no_matches do |errors, suggestions|
+        raise_no_matches(errors, suggestions)
+      end
+
+      resolver.many_matches do |matches|
+        if environment_name
+          message = "Multiple environments possible, please be more specific:\n\n"
+          matches.each do |env|
+            message << "\t#{env.name.ljust(25)} # ey <command> --environment='#{env.name}' --account='#{env.account.name}'\n"
+          end
+          raise EY::MultipleMatchesError.new(message)
+        else
+          raise EY::AmbiguousEnvironmentGitUriError.new(matches)
+        end
+      end
+    end
+
+    def fetch_app_environment(app_name, environment_name, account_name)
+      ui.info "Loading application data from Engine Yard Cloud..."
+
+      environment_name ||= use_default_environment
+      remotes = repo.remotes if in_repo?
+      constraints = {
+        app_name:         app_name,
+        environment_name: environment_name,
+        account_name:     account_name,
+        remotes:          remotes,
+      }
+
+      if constraints.all? { |k,v| v.nil? || v.empty? || v.to_s.empty? }
+        raise EY::NoMatchesError.new <<-ERROR
+Unable to find application without a git remote URI or app name.
+
+Please specify --app=app_name or add this application at #{config.endpoint}"
+        ERROR
+      end
+
+      resolver = api.resolve_app_environments(constraints)
+
+      resolver.one_match { |match| return match }
+      resolver.no_matches do |errors, suggestions|
+        raise_no_matches(errors, suggestions)
+      end
+      resolver.many_matches do |app_envs|
+        raise EY::MultipleMatchesError.new(too_many_app_environments_error(app_envs))
+      end
+    end
+
+    def raise_no_matches(errors, suggestions)
+      message = "We found the following suggestions:\n" if suggestions.any?
+
+      suggestions.each do |suggest|
+        message << " # ey <command> --account='#{suggest['account_name']}' --app='#{suggest['app_name']}' --environment='#{suggest['env_name']}'\n"
+      end
+
+      raise EY::NoMatchesError.new([errors,message].compact.join("\n").strip)
+    end
+
+      def too_many_app_environments_error(app_envs)
+        message = "Multiple application environments possible, please be more specific:\n\n"
+
+        app_envs.group_by do |app_env|
+          [app_env.account_name, app_env.app_name]
+        end.sort_by { |k,v| k.join }.each do |(account_name, app_name), grouped_app_envs|
+          message << "\n"
+          message << account_name << "/" << app_name << "\n"
+          grouped_app_envs.map { |ae| ae.environment_name }.uniq.sort.each do |env_name|
+            message << "\t#{env_name.ljust(25)}"
+            message << " # ey <command> --account='#{account_name}' --app='#{app_name}' --environment='#{env_name}'\n"
+          end
+        end
+        message
+      end
+  end # UtilityMethods
+
+  class Thor < ::Thor
+    include UtilityMethods
+
+    check_unknown_options!
+
+    no_tasks do
+      def self.subcommand_help(cmd)
+        desc "#{cmd} help [COMMAND]", "Describe all subcommands or one specific subcommand."
+        class_eval <<-RUBY
+          def help(*args)
+            if args.empty?
+              ui.say "usage: #{banner_base} #{cmd} COMMAND"
+              ui.say
+              subcommands = self.class.printable_tasks.sort_by{|s| s[0] }
+              subcommands.reject!{|t| t[0] =~ /#{cmd} help$/}
+              ui.print_help(subcommands)
+              ui.say self.class.send(:class_options_help, ui)
+              ui.say "See #{banner_base} #{cmd} help COMMAND" +
+                " for more information on a specific subcommand." if args.empty?
+            else
+              super
+            end
+          end
+        RUBY
+      end
+
+      def self.banner_base
+        "ey"
+      end
+
+      def self.banner(task, task_help = false, subcommand = false)
+        subcommand_banner = to_s.split(/::/).map{|s| s.downcase}[2..-1]
+        subcommand_banner = if subcommand_banner.size > 0
+                              subcommand_banner.join(' ')
+                            else
+                              nil
+                            end
+
+        task = (task_help ? task.formatted_usage(self, false, subcommand) : task.name)
+        [banner_base, subcommand_banner, task].compact.join(" ")
+      end
+
+      def self.handle_no_task_error(task)
+        raise UndefinedTaskError, "Could not find command #{task.inspect}."
+      end
+
+      def self.subcommand(name, klass)
+        @@subcommand_class_for ||= {}
+        @@subcommand_class_for[name] = klass
+        super
+      end
+
+      def self.subcommand_class_for(name)
+        @@subcommand_class_for ||= {}
+        @@subcommand_class_for[name]
+      end
+
+    end
+
+    protected
+
+    def self.exit_on_failure?
+      true
+    end
+
+  end
+
+  # patch handle_no_method_error? to work with rubinius' error text.
+  class ::Thor::Task
+    def handle_no_method_error?(instance, error, caller)
+      not_debugging?(instance) && (
+        error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/ ||
+        error.message =~ /undefined method `#{name}' on an instance of #{Regexp.escape(instance.class.name)}/
+      )
+    end
+  end
+end

data/lib/engineyard/version.rb

@@ -0,0 +1,4 @@
+module EY
+  VERSION = '3.2.2'
+  ENGINEYARD_SERVERSIDE_VERSION = ENV['ENGINEYARD_SERVERSIDE_VERSION'] || '2.6.3'
+end

data/lib/vendor/thor/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+gemspec
+
+platforms :mri_18 do
+  gem 'ruby-debug', '>= 0.10.3'
+end
+
+platforms :mri_19 do
+  gem 'ruby-debug19'
+end
+
+group :development do
+  gem 'pry'
+end

data/lib/vendor/thor/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/lib/vendor/thor/README.md

@@ -0,0 +1,35 @@
+[![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. You can also checkout the [official homepage][homepage].
+
+[wiki]: https://github.com/wycats/thor/wiki
+[homepage]: http://whatisthor.com/
+
+License
+-------
+Released under the MIT License.  See the [LICENSE][] file for further details.
+
+[license]: LICENSE.md

data/lib/vendor/thor/lib/thor.rb

@@ -0,0 +1,473 @@
+require 'set'
+require 'thor/base'
+
+class Thor
+  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)
+      @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] }
+
+      if @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 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