Class: Bundler::Thor (Ruby 2.7.2)
Description: Class : Bundler::Thor - Ruby 2.7.2

### Home Classes Methods

### In Files

- bundler/vendor/thor/lib/thor.rb
- bundler/vendor/thor/lib/thor/actions.rb
- bundler/vendor/thor/lib/thor/actions/create_file.rb
- bundler/vendor/thor/lib/thor/actions/create_link.rb
- bundler/vendor/thor/lib/thor/actions/directory.rb
- bundler/vendor/thor/lib/thor/actions/empty_directory.rb
- bundler/vendor/thor/lib/thor/actions/file_manipulation.rb
- bundler/vendor/thor/lib/thor/actions/inject_into_file.rb
- bundler/vendor/thor/lib/thor/base.rb
- bundler/vendor/thor/lib/thor/command.rb
- bundler/vendor/thor/lib/thor/core_ext/hash_with_indifferent_access.rb
- bundler/vendor/thor/lib/thor/core_ext/ordered_hash.rb
- bundler/vendor/thor/lib/thor/error.rb
- bundler/vendor/thor/lib/thor/group.rb
- bundler/vendor/thor/lib/thor/invocation.rb
- bundler/vendor/thor/lib/thor/line_editor.rb
- bundler/vendor/thor/lib/thor/line_editor/basic.rb
- bundler/vendor/thor/lib/thor/line_editor/readline.rb
- bundler/vendor/thor/lib/thor/nested_context.rb
- bundler/vendor/thor/lib/thor/parser/argument.rb
- bundler/vendor/thor/lib/thor/parser/arguments.rb
- bundler/vendor/thor/lib/thor/parser/option.rb
- bundler/vendor/thor/lib/thor/parser/options.rb
- bundler/vendor/thor/lib/thor/rake_compat.rb
- bundler/vendor/thor/lib/thor/runner.rb
- bundler/vendor/thor/lib/thor/shell.rb
- bundler/vendor/thor/lib/thor/shell/basic.rb
- bundler/vendor/thor/lib/thor/shell/color.rb
- bundler/vendor/thor/lib/thor/shell/html.rb
- bundler/vendor/thor/lib/thor/util.rb
- bundler/vendor/thor/lib/thor/version.rb

### Parent

Object

### Namespace

- MODULE Bundler::Thor::Actions
- MODULE Bundler::Thor::Base
- MODULE Bundler::Thor::CoreExt
- MODULE Bundler::Thor::DidYouMean
- MODULE Bundler::Thor::Invocation
- MODULE Bundler::Thor::LineEditor
- MODULE Bundler::Thor::RakeCompat
- MODULE Bundler::Thor::Shell
- MODULE Bundler::Thor::Util
- CLASS Bundler::Thor::Command
- CLASS Bundler::Thor::DynamicCommand
- CLASS Bundler::Thor::DynamicTask
- CLASS Bundler::Thor::Group
- CLASS Bundler::Thor::HiddenCommand
- CLASS Bundler::Thor::HiddenTask
- CLASS Bundler::Thor::NestedContext
- CLASS Bundler::Thor::Task

### Methods

- ::banner
- ::check_unknown_options!
- ::command_help
- ::default_command
- ::default_task
- ::desc
- ::disable_required_check!
- ::find_command_possibilities
- ::find_task_possibilities
- ::help
- ::long_desc
- ::map
- ::method_option
- ::method_options
- ::option
- ::options
- ::package_name
- ::printable_commands
- ::printable_tasks
- ::register
- ::stop_on_unknown_option!
- ::subcommand
- ::subcommand_classes
- ::subcommand_help
- ::subcommands
- ::subtask
- ::subtask_help
- ::subtasks
- ::task_help
- #help

### Included Modules

- Bundler::Thor::Base

### Class/Module Index

Quicksearch

- AmbiguousCommandError
- AmbiguousTaskError
- Bundler
- Bundler::APIResponseMismatchError
- Bundler::BuildMetadata
- Bundler::BundlerError
- Bundler::CLI
- Bundler::CLI::Add
- Bundler::CLI::Binstubs
- Bundler::CLI::Cache
- Bundler::CLI::Check
- Bundler::CLI::Clean
- Bundler::CLI::Common
- Bundler::CLI::Config
- Bundler::CLI::Config::Base
- Bundler::CLI::Console
- Bundler::CLI::Doctor
- Bundler::CLI::Exec
- Bundler::CLI::Gem
- Bundler::CLI::Info
- Bundler::CLI::Init
- Bundler::CLI::Inject
- Bundler::CLI::Install
- Bundler::CLI::Issue
- Bundler::CLI::List
- Bundler::CLI::Lock
- Bundler::CLI::Open
- Bundler::CLI::Outdated
- Bundler::CLI::Package
- Bundler::CLI::Platform
- Bundler::CLI::Plugin
- Bundler::CLI::Pristine
- Bundler::CLI::Remove
- Bundler::CLI::Show
- Bundler::CLI::Update
- Bundler::CLI::Viz
- Bundler::CompactIndexClient
- Bundler::CompactIndexClient::Cache
- Bundler::CompactIndexClient::Error
- Bundler::CompactIndexClient::Updater
- Bundler::CompactIndexClient::Updater::MisMatchedChecksumError
- Bundler::ConnectionPool
- Bundler::ConnectionPool::Error
- Bundler::ConnectionPool::PoolShuttingDownError
- Bundler::ConnectionPool::Process
- Bundler::ConnectionPool::TimedStack
- Bundler::ConnectionPool::Wrapper
- Bundler::CurrentRuby
- Bundler::CyclicDependencyError
- Bundler::Definition
- Bundler::DepProxy
- Bundler::Dependency
- Bundler::Deployment
- Bundler::Deprecate
- Bundler::DeprecatedError
- Bundler::Dsl
- Bundler::Dsl::DSLError
- Bundler::EndpointSpecification
- Bundler::Env
- Bundler::EnvironmentPreserver
- Bundler::FeatureFlag
- Bundler::Fetcher
- Bundler::Fetcher::AuthenticationRequiredError
- Bundler::Fetcher::BadAuthenticationError
- Bundler::Fetcher::Base
- Bundler::Fetcher::CertificateFailureError
- Bundler::Fetcher::CompactIndex
- Bundler::Fetcher::Dependency
- Bundler::Fetcher::Downloader
- Bundler::Fetcher::FallbackError
- Bundler::Fetcher::Index
- Bundler::Fetcher::NetworkDownError
- Bundler::Fetcher::SSLError
- Bundler::Fetcher::TooManyRequestsError
- Bundler::FileUtils
- Bundler::FileUtils::DryRun
- Bundler::FileUtils::Entry_
- Bundler::FileUtils::Entry_::File
- Bundler::FileUtils::NoWrite
- Bundler::FileUtils::StreamUtils_
- Bundler::FileUtils::StreamUtils_::RbConfig
- Bundler::FileUtils::Verbose
- Bundler::FriendlyErrors
- Bundler::GemHelper
- Bundler::GemHelper::Rake
- Bundler::GemHelpers
- Bundler::GemHelpers::PlatformMatch
- Bundler::GemInstaller
- Bundler::GemNotFound
- Bundler::GemRemoteFetcher
- Bundler::GemRequireError
- Bundler::GemVersionPromoter
- Bundler::Gemdeps
- Bundler::GemfileError
- Bundler::GemfileEvalError
- Bundler::GemfileLockNotFound
- Bundler::GemfileNotFound
- Bundler::GemspecError
- Bundler::GenericSystemCallError
- Bundler::GitError
- Bundler::Graph
- Bundler::Graph::GraphVizClient
- Bundler::HTTPError
- Bundler::Index
- Bundler::Injector
- Bundler::InstallError
- Bundler::InstallHookError
- Bundler::Installer
- Bundler::InvalidOption
- Bundler::LazySpecification
- Bundler::LazySpecification::Identifier
- Bundler::LockfileError
- Bundler::LockfileGenerator
- Bundler::LockfileParser
- Bundler::MarshalError
- Bundler::MatchPlatform
- Bundler::MirrorSockets
- Bundler::Molinillo
- Bundler::Molinillo::CircularDependencyError
- Bundler::Molinillo::Compatibility
- Bundler::Molinillo::Delegates
- Bundler::Molinillo::Delegates::ResolutionState
- Bundler::Molinillo::Delegates::SpecificationProvider
- Bundler::Molinillo::DependencyGraph
- Bundler::Molinillo::DependencyGraph::Action
- Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular
- Bundler::Molinillo::DependencyGraph::DeleteEdge
- Bundler::Molinillo::DependencyGraph::DetachVertexNamed
- Bundler::Molinillo::DependencyGraph::Log
- Bundler::Molinillo::DependencyGraph::Tag
- Bundler::Molinillo::DependencyGraph::Vertex
- Bundler::Molinillo::DependencyState
- Bundler::Molinillo::NoSuchDependencyError
- Bundler::Molinillo::PossibilityState
- Bundler::Molinillo::ResolutionState
- Bundler::Molinillo::Resolver
- Bundler::Molinillo::Resolver::Resolution
- Bundler::Molinillo::Resolver::Resolution::Conflict
- Bundler::Molinillo::Resolver::Resolution::PossibilitySet
- Bundler::Molinillo::Resolver::Resolution::UnwindDetails
- Bundler::Molinillo::ResolverError
- Bundler::Molinillo::SpecificationProvider
- Bundler::Molinillo::UI
- Bundler::Molinillo::VersionConflict
- Bundler::NoSpaceOnDeviceError
- Bundler::OperationNotSupportedError
- Bundler::ParallelInstaller
- Bundler::ParallelInstaller::SpecInstallation
- Bundler::PathError
- Bundler::PermissionError
- Bundler::Persistent
- Bundler::Persistent::Net
- Bundler::Persistent::Net::HTTP
- Bundler::Persistent::Net::HTTP::Persistent
- Bundler::Persistent::Net::HTTP::Persistent::Error
- Bundler::PersistentHTTP
- Bundler::Plugin
- Bundler::Plugin::API
- Bundler::Plugin::API::Source
- Bundler::Plugin::DSL
- Bundler::Plugin::DSL::PluginGemfileError
- Bundler::Plugin::Events
- Bundler::Plugin::Index
- Bundler::Plugin::Index::CommandConflict
- Bundler::Plugin::Index::SourceConflict
- Bundler::Plugin::Installer
- Bundler::Plugin::Installer::Git
- Bundler::Plugin::Installer::Rubygems
- Bundler::Plugin::MalformattedPlugin
- Bundler::Plugin::SourceList
- Bundler::Plugin::UndefinedCommandError
- Bundler::Plugin::UnknownSourceError
- Bundler::PluginError
- Bundler::ProcessLock
- Bundler::ProductionError
- Bundler::Psych
- Bundler::RemoteSpecification
- Bundler::Resolver
- Bundler::Resolver::SpecGroup
- Bundler::Retry
- Bundler::RubyDsl
- Bundler::RubyGemsGemInstaller
- Bundler::RubyVersion
- Bundler::RubyVersionMismatch
- Bundler::RubygemsIntegration
- Bundler::RubygemsIntegration::Gem
- Bundler::Runtime
- Bundler::SecurityError
- Bundler::Settings
- Bundler::Settings::Mirror
- Bundler::Settings::MirrorConfig
- Bundler::Settings::Mirrors
- Bundler::Settings::TCPSocketProbe
- Bundler::Settings::Validator
- Bundler::Settings::Validator::Rule
- Bundler::SharedHelpers
- Bundler::SimilarityDetector
- Bundler::SocketAddress
- Bundler::Source
- Bundler::Source::Gemspec
- Bundler::Source::Git
- Bundler::Source::Git::GitCommandError
- Bundler::Source::Git::GitNotAllowedError
- Bundler::Source::Git::GitNotInstalledError
- Bundler::Source::Git::GitProxy
- Bundler::Source::Git::MissingGitRevisionError
- Bundler::Source::Metadata
- Bundler::Source::Path
- Bundler::Source::Path::Installer
- Bundler::Source::Rubygems
- Bundler::Source::Rubygems::Remote
- Bundler::SourceList
- Bundler::SpecSet
- Bundler::Standalone
- Bundler::StubSpecification
- Bundler::SudoNotPermittedError
- Bundler::TemporaryResourceError
- Bundler::Thor::Actions
- Bundler::Thor::Actions::CapturableERB
- Bundler::Thor::Actions::ClassMethods
- Bundler::Thor::Base
- Bundler::Thor::Base::ClassMethods
- Bundler::Thor::Command
- Bundler::Thor::CoreExt
- Bundler::Thor::CoreExt::OrderedHash
- Bundler::Thor::DidYouMean
- Bundler::Thor::DynamicCommand
- Bundler::Thor::DynamicTask
- Bundler::Thor::Group
- Bundler::Thor::HiddenCommand
- Bundler::Thor::HiddenTask
- Bundler::Thor::Invocation
- Bundler::Thor::Invocation::ClassMethods
- Bundler::Thor::LineEditor
- Bundler::Thor::LineEditor::Basic
- Bundler::Thor::LineEditor::Readline
- Bundler::Thor::LineEditor::Readline::PathCompletion
- Bundler::Thor::NestedContext
- Bundler::Thor::RakeCompat
- Bundler::Thor::RakeCompat::Rake
- Bundler::Thor::Shell
- Bundler::Thor::Shell::Basic
- Bundler::Thor::Shell::Color
- Bundler::Thor::Shell::HTML
- Bundler::Thor::Task
- Bundler::Thor::Util
- Bundler::ThreadCreationError
- Bundler::UI
- Bundler::UI::RGProxy
- Bundler::UI::Shell
- Bundler::UI::Silent
- Bundler::URI
- Bundler::URI::BadURIError
- Bundler::URI::Error
- Bundler::URI::Escape
- Bundler::URI::FTP
- Bundler::URI::File
- Bundler::URI::Generic
- Bundler::URI::HTTP
- Bundler::URI::HTTPS
- Bundler::URI::InvalidComponentError
- Bundler::URI::InvalidURIError
- Bundler::URI::LDAP
- Bundler::URI::LDAPS
- Bundler::URI::MailTo
- Bundler::URI::REGEXP
- Bundler::URI::RFC2396_Parser
- Bundler::URI::RFC2396_REGEXP
- Bundler::URI::RFC2396_REGEXP::PATTERN
- Bundler::URICredentialsFilter
- Bundler::VersionConflict
- Bundler::VersionRanges
- Bundler::VersionRanges::ReqR
- Bundler::VirtualProtocolError
- Bundler::Worker
- Bundler::Worker::WrappedException
- Bundler::YAMLSerializer
- Bundler::YamlSyntaxError
- Capistrano
- DidYouMean
- Error
- Gem
- Gem::Dependency
- Gem::Ext
- Gem::Ext::Builder
- Gem::Platform
- Gem::Specification
- InvocationError
- Kernel
- MalformattedArgumentError
- Object
- Rake
- RequiredArgumentMissingError
- UndefinedCommandError
- UndefinedCommandError::SpellChecker
- UndefinedTaskError
- UnknownArgumentError
- UnknownArgumentError::SpellChecker

No matching classes.

# Bundler::Thor

### Constants

DynamicTask

  A dynamic command that handles method missing scenarios.

HELP_MAPPINGS

  Shortcuts for help.

HiddenTask

  A command that is hidden in help messages but still invocable.

TEMPLATE_EXTNAME
THOR_RESERVED_WORDS

  Bundler::Thor methods that should not be overwritten by the user.

Task
VERSION

### Public Class Methods

check_unknown_options!(options = {}) click to toggle source

Extend check unknown options to accept a hash of conditions.

### Parameters¶ ↑

options<Hash>: A hash containing :only and/or :except keys

                   # File bundler/vendor/thor/lib/thor.rb, line 255
    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

command_help(shell, command_name) click to toggle source

Prints help information for the given command.

#### Parameters¶ ↑

shell<Bundler::Thor::Shell> command_name<String>

                   # File bundler/vendor/thor/lib/thor.rb, line 172
    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).split("\n").join("\n  ")}"
      shell.say
      class_options_help(shell, nil => command.options.values)
      if command.long_description
        shell.say "Description:"
        shell.print_wrapped(command.long_description, :indent => 2)
      else
        shell.say command.description
      end
    end

Also aliased as: task_help
default_command(meth = nil) click to toggle source

Sets the default command when thor is executed without an explicit command to be called.

#### Parameters¶ ↑

meth<Symbol>

  name of the default command

                   # File bundler/vendor/thor/lib/thor.rb, line 21
    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

Also aliased as: default_task
default_task(meth = nil) click to toggle source
Alias for: default_command
desc(usage, description, options = {}) click to toggle source

Defines the usage and the description of the next command.

#### Parameters¶ ↑

usage<String> description<String> options<String>

                   # File bundler/vendor/thor/lib/thor.rb, line 54
    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 = usage
        @desc = description
        @hide = options[:hide] || false
      end
    end

disable_required_check!(*command_names) click to toggle source

Disable the check for required options for the given commands. This is useful if you have a command that does not need the required options to work, like help.

#### Parameters¶ ↑

Symbol …

  A list of commands that should be affected.

                   # File bundler/vendor/thor/lib/thor.rb, line 339
    def disable_required_check!(*command_names)
      disable_required_check.merge(command_names)
    end

help(shell, subcommand = false) click to toggle source

Prints help information for this class.

#### Parameters¶ ↑

shell<Bundler::Thor::Shell>

                   # File bundler/vendor/thor/lib/thor.rb, line 195
    def help(shell, subcommand = false)
      list = printable_commands(true, subcommand)
      Bundler::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

long_desc(long_description, options = {}) click to toggle source

Defines the long description of the next command.

#### Parameters¶ ↑

long description<String>

                   # File bundler/vendor/thor/lib/thor.rb, line 71
    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

map(mappings = nil, **kw) click to toggle source

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.

                   # File bundler/vendor/thor/lib/thor.rb, line 93
    def map(mappings = nil, **kw)
      @map ||= from_superclass(:map, {})

      if mappings && !kw.empty?
        mappings = kw.merge!(mappings)
      else
        mappings ||= kw
      end
      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

method_option(name, options = {}) click to toggle source

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.

                   # File bundler/vendor/thor/lib/thor.rb, line 155
    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

Also aliased as: option
method_options(options = nil) click to toggle source

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.

                   # File bundler/vendor/thor/lib/thor.rb, line 121
    def method_options(options = nil)
      @method_options ||= {}
      build_options(options, @method_options) if options
      @method_options
    end

Also aliased as: options
option(name, options = {}) click to toggle source
Alias for: method_option
options(options = nil) click to toggle source
Alias for: method_options
package_name(name, _ = {}) click to toggle source

Allows for custom “Command” package naming.

### Parameters¶ ↑

name<String> options<Hash>

                   # File bundler/vendor/thor/lib/thor.rb, line 12
    def package_name(name, _ = {})
      @package_name = name.nil? || name == "" ? nil : name
    end

printable_commands(all = true, subcommand = false) click to toggle source

Returns commands ready to be printed.

                   # File bundler/vendor/thor/lib/thor.rb, line 214
    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

Also aliased as: printable_tasks
printable_tasks(all = true, subcommand = false) click to toggle source
Alias for: printable_commands
register(klass, subcommand_name, usage, description, options = {}) click to toggle source

Registers another Bundler::Thor subclass as a command.

#### Parameters¶ ↑

klass<Class>

  Bundler::Thor subclass to register

command<String>

  Subcommand name to use

usage<String>

  Short usage for the subcommand

description<String>

  Description for the subcommand

                   # File bundler/vendor/thor/lib/thor.rb, line 37
    def register(klass, subcommand_name, usage, description, options = {})
      if klass <= Bundler::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

stop_on_unknown_option!(*command_names) click to toggle source

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 Bundler::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 Bundler::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.

                   # File bundler/vendor/thor/lib/thor.rb, line 325
    def stop_on_unknown_option!(*command_names)
      stop_on_unknown_option.merge(command_names)
    end

subcommand(subcommand, subcommand_class) click to toggle source

                   # File bundler/vendor/thor/lib/thor.rb, line 234
    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 = Bundler::Thor::Arguments.split(args)
        invoke_args = [args, opts, {:invoked_via_subcommand => true, :class_options => options}]
        invoke_args.unshift "help" if opts.delete("--help") || opts.delete("-h")
        invoke subcommand_class, *invoke_args
      end
      subcommand_class.commands.each do |_meth, command|
        command.ancestor_name = subcommand
      end
    end

Also aliased as: subtask
subcommand_classes() click to toggle source

                   # File bundler/vendor/thor/lib/thor.rb, line 230
    def subcommand_classes
      @subcommand_classes ||= {}
    end

subcommands() click to toggle source

                   # File bundler/vendor/thor/lib/thor.rb, line 225
    def subcommands
      @subcommands ||= from_superclass(:subcommands, [])
    end

Also aliased as: subtasks
subtask(subcommand, subcommand_class) click to toggle source
Alias for: subcommand
subtasks() click to toggle source
Alias for: subcommands
task_help(shell, command_name) click to toggle source
Alias for: command_help

### Protected Class Methods

banner(command, namespace = nil, subcommand = false) click to toggle source

The banner for this class. You can customize it if you are invoking the thor class by another ways which is not the Bundler::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.

                   # File bundler/vendor/thor/lib/thor.rb, line 407
    def banner(command, namespace = nil, subcommand = false)
      $thor_runner ||= false
      command.formatted_usage(self, $thor_runner, subcommand).split("\n").map do |formatted_usage|
        "#{basename} #{formatted_usage}"
      end.join("\n")
    end

find_command_possibilities(meth) click to toggle source

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.

                   # File bundler/vendor/thor/lib/thor.rb, line 484
    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

Also aliased as: find_task_possibilities
find_task_possibilities(meth) click to toggle source
Alias for: find_command_possibilities
subcommand_help(cmd) click to toggle source

                   # File bundler/vendor/thor/lib/thor.rb, line 499
        def subcommand_help(cmd)
          desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
          class_eval "
            def help(command = nil, subcommand = true); super; end
    "
        end

Also aliased as: subtask_help
subtask_help(cmd) click to toggle source
Alias for: subcommand_help

### Public Instance Methods

help(command = nil, subcommand = false) click to toggle source

                   # File bundler/vendor/thor/lib/thor.rb, line 513
    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