Module: Bundler::Thor::Base::ClassMethods (Ruby 2.7.2)
Description: Module : Bundler::Thor::Base::ClassMethods - Ruby 2.7.2

### Home Classes Methods

### In Files

- bundler/vendor/thor/lib/thor/base.rb

### Methods

- #all_commands
- #all_tasks
- #allow_incompatible_default_type!
- #argument
- #arguments
- #basename
- #check_default_type!
- #check_unknown_options!
- #class_option
- #class_options
- #commands
- #exit_on_failure?
- #from_superclass
- #group
- #inherited
- #method_added
- #namespace
- #no_commands
- #no_commands?
- #no_commands_context
- #no_tasks
- #print_options
- #public_command
- #public_task
- #remove_argument
- #remove_class_option
- #remove_command
- #remove_task
- #start
- #strict_args_position!
- #tasks

### 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::Base::ClassMethods

### Public Instance Methods

all_commands() click to toggle source

Returns the commands for this Bundler::Thor class and all subclasses.

#### Returns¶ ↑

Hash

  An ordered hash with commands names as keys and Bundler::Thor::Command objects as values.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 374
    def all_commands
      @all_commands ||= from_superclass(:all_commands, Hash.new)
      @all_commands.merge!(commands)
    end

Also aliased as: all_tasks
all_tasks() click to toggle source
Alias for: all_commands
allow_incompatible_default_type!() click to toggle source

If you want to use defaults that don’t match the type of an option, either specify `check_default_type: false` or call `allow_incompatible_default_type!`

                   # File bundler/vendor/thor/lib/thor/base.rb, line 164
    def allow_incompatible_default_type!
      @check_default_type = false
    end

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

Adds an argument to the class and creates an attr_accessor for it.

Arguments are different from options in several aspects. The first one is how they are parsed from the command line, arguments are retrieved from position:

    thor command NAME

Instead of:

    thor command --name=NAME

Besides, arguments are used inside your code as an accessor (self.argument), while options are all kept in a hash (self.options).

Finally, arguments cannot have type :default or :boolean but can be optional (supplying :optional => :true or :required => false), although you cannot have a required argument after a non-required argument. If you try it, an error is raised.

#### 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. :optional - If the argument is optional or not. :type - The type of the argument, can be :string, :hash, :array, :numeric. :default - Default value for this argument. It cannot be required and have default values. :banner - String to show on usage notes.

#### Errors¶ ↑

ArgumentError

  Raised if you supply a required argument after a non required one.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 236
    def argument(name, options = {})
      is_thor_reserved_word?(name, :argument)
      no_commands { attr_accessor name }

      required = if options.key?(:optional)
        !options[:optional]
      elsif options.key?(:required)
        options[:required]
      else
        options[:default].nil?
      end

      remove_argument name

      if required
        arguments.each do |argument|
          next if argument.required?
          raise ArgumentError, "You cannot have #{name.to_s.inspect} as required argument after "                                  "the non-required argument #{argument.human_name.inspect}."
        end
      end

      options[:required] = required

      arguments << Bundler::Thor::Argument.new(name, options)
    end

arguments() click to toggle source

Returns this class arguments, looking up in the ancestors chain.

#### Returns¶ ↑

Array

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

check_default_type!() click to toggle source

If you want to raise an error when the default value of an option does not match the type call check_default_type! This will be the default; for compatibility a deprecation warning is issued if necessary.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 158
    def check_default_type!
      @check_default_type = true
    end

check_unknown_options!() click to toggle source

If you want to raise an error for unknown options, call check_unknown_options! This is disabled by default to allow dynamic invocations.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 143
    def check_unknown_options!
      @check_unknown_options = true
    end

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

Adds an option to the set of class options

#### 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.

:group

  – The group for this options. Use by class options to output options in different levels.

:aliases

  – Aliases for this option. Note: Bundler::Thor follows a convention of one-dash-one-letter options. Thus aliases like “-something” wouldn’t be parsed; use either “--something” or “-s” instead.

: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/base.rb, line 303
    def class_option(name, options = {})
      build_option(name, options, class_options)
    end

class_options(options = nil) click to toggle source

Adds a bunch of options to the set of class options.

    class_options :foo => false, :bar => :required, :baz => :string

If you prefer more detailed declaration, check class_option.

#### Parameters¶ ↑

Hash[Symbol => Object]

                   # File bundler/vendor/thor/lib/thor/base.rb, line 281
    def class_options(options = nil)
      @class_options ||= from_superclass(:class_options, {})
      build_options(options, @class_options) if options
      @class_options
    end

commands() click to toggle source

Returns the commands for this Bundler::Thor class.

#### Returns¶ ↑

Hash

  An ordered hash with commands names as keys and Bundler::Thor::Command objects as values.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 363
    def commands
      @commands ||= Hash.new
    end

Also aliased as: tasks
exit_on_failure?() click to toggle source

A flag that makes the process exit with status 1 if any error happens.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 520
    def exit_on_failure?
      Bundler::Thor.deprecation_warning "Bundler::Thor exit with status 0 on errors. To keep this behavior, you must define `exit_on_failure?` in `#{self.name}`"
      false
    end

group(name = nil) click to toggle source

Defines the group. This is used when thor list is invoked so you can specify that only commands from a pre-defined group will be shown. Defaults to standard.

#### Parameters¶ ↑

name<String|Symbol>

                   # File bundler/vendor/thor/lib/thor/base.rb, line 349
    def group(name = nil)
      if name
        @group = name.to_s
      else
        @group ||= from_superclass(:group, "standard")
      end
    end

namespace(name = nil) click to toggle source

Sets the namespace for the Bundler::Thor or Bundler::Thor::Group class. By default the namespace is retrieved from the class name. If your Bundler::Thor class is named Scripts::MyScript, the help method, for example, will be called as:

    thor scripts:my_script -h

If you change the namespace:

    namespace :my_scripts

You change how your commands are invoked:

    thor my_scripts -h

Finally, if you change your namespace to default:

    namespace :default

Your commands can be invoked with a shortcut. Instead of:

    thor :my_command

                   # File bundler/vendor/thor/lib/thor/base.rb, line 458
    def namespace(name = nil)
      if name
        @namespace = name.to_s
      else
        @namespace ||= Bundler::Thor::Util.namespace_from_thor_class(self)
      end
    end

no_commands(&block) click to toggle source

All methods defined inside the given block are not added as commands.

So you can do:

    class MyScript < Bundler::Thor
      no_commands do
        def this_is_not_a_command
        end
      end
    end

You can also add the method and remove it from the command list:

    class MyScript < Bundler::Thor
      def this_is_not_a_command
      end
      remove_command :this_is_not_a_command
    end

                   # File bundler/vendor/thor/lib/thor/base.rb, line 422
    def no_commands(&block)
      no_commands_context.enter(&block)
    end

Also aliased as: no_tasks
no_commands?() click to toggle source

                   # File bundler/vendor/thor/lib/thor/base.rb, line 432
    def no_commands?
      no_commands_context.entered?
    end

no_commands_context() click to toggle source

                   # File bundler/vendor/thor/lib/thor/base.rb, line 428
    def no_commands_context
      @no_commands_context ||= NestedContext.new
    end

no_tasks(&block) click to toggle source
Alias for: no_commands
public_command(*names) click to toggle source

Allows to use private methods from parent in child classes as commands.

#### Parameters¶ ↑

    names<Array>:: Method names to be used as commands

#### Examples¶ ↑

    public_command :foo
    public_command :foo, :bar, :baz

                   # File bundler/vendor/thor/lib/thor/base.rb, line 498
    def public_command(*names)
      names.each do |name|
        class_eval "def #{name}(*); super end"
      end
    end

Also aliased as: public_task
public_task(*names) click to toggle source
Alias for: public_command
remove_argument(*names) click to toggle source

Removes a previous defined argument. If :undefine is given, undefine accessors as well.

#### Parameters¶ ↑

names<Array>

  Arguments to be removed

#### Examples¶ ↑

    remove_argument :foo
    remove_argument :foo, :bar, :baz, :undefine => true

                   # File bundler/vendor/thor/lib/thor/base.rb, line 318
    def remove_argument(*names)
      options = names.last.is_a?(Hash) ? names.pop : {}

      names.each do |name|
        arguments.delete_if { |a| a.name == name.to_s }
        undef_method name, "#{name}=" if options[:undefine]
      end
    end

remove_class_option(*names) click to toggle source

Removes a previous defined class option.

#### Parameters¶ ↑

names<Array>

  Class options to be removed

#### Examples¶ ↑

    remove_class_option :foo
    remove_class_option :foo, :bar, :baz

                   # File bundler/vendor/thor/lib/thor/base.rb, line 337
    def remove_class_option(*names)
      names.each do |name|
        class_options.delete(name)
      end
    end

remove_command(*names) click to toggle source

Removes a given command from this Bundler::Thor class. This is usually done if you are inheriting from another class and don’t want it to be available anymore.

By default it only remove the mapping to the command. But you can supply :undefine => true to undefine the method from the class as well.

#### Parameters¶ ↑

name<Symbol|String>

  The name of the command to be removed

options<Hash>

  You can give :undefine => true if you want commands the method to be undefined from the class as well.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 392
    def remove_command(*names)
      options = names.last.is_a?(Hash) ? names.pop : {}

      names.each do |name|
        commands.delete(name.to_s)
        all_commands.delete(name.to_s)
        undef_method name if options[:undefine]
      end
    end

Also aliased as: remove_task
remove_task(*names) click to toggle source
Alias for: remove_command
start(given_args = ARGV, config = {}) click to toggle source

Parses the command and options from the given args, instantiate the class and invoke the command. This method is used when the arguments must be parsed from an array. If you are inside Ruby and want to use a Bundler::Thor class, you can simply initialize it:

    script = MyScript.new(args, options, config)
    script.invoke(:command, first_arg, second_arg, third_arg)

                   # File bundler/vendor/thor/lib/thor/base.rb, line 474
    def start(given_args = ARGV, config = {})
      config[:shell] ||= Bundler::Thor::Base.shell.new
      dispatch(nil, given_args.dup, nil, config)
    rescue Bundler::Thor::Error => e
      config[:debug] || ENV["THOR_DEBUG"] == "1" ? (raise e) : config[:shell].error(e.message)
      exit(false) if exit_on_failure?
    rescue Errno::EPIPE
      # This happens if a thor command is piped to something like `head`,
      # which closes the pipe when it's done reading. This will also
      # mean that if the pipe is closed, further unnecessary
      # computation will not occur.
      exit(true)
    end

strict_args_position!() click to toggle source

If you want only strict string args (useful when cascading thor classes), call strict_args_position! This is disabled by default to allow dynamic invocations.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 189
    def strict_args_position!
      @strict_args_position = true
    end

tasks() click to toggle source
Alias for: commands

### Protected Instance Methods

basename() click to toggle source

The basename of the program invoking the thor class.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 664
    def basename
      File.basename($PROGRAM_NAME).split(" ").first
    end

from_superclass(method, default = nil) click to toggle source

Retrieves a value from superclass. If it reaches the baseclass, returns default.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 642
    def from_superclass(method, default = nil)
      if self == baseclass || !superclass.respond_to?(method, true)
        default
      else
        value = superclass.send(method)

        # Ruby implements `dup` on Object, but raises a `TypeError`
        # if the method is called on immediates. As a result, we
        # don't have a good way to check whether dup will succeed
        # without calling it and rescuing the TypeError.
        begin
          value.dup
        rescue TypeError
          value
        end

      end
    end

inherited(klass) click to toggle source

Everytime someone inherits from a Bundler::Thor class, register the klass and file into baseclass.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 614
    def inherited(klass)
      super(klass)
      Bundler::Thor::Base.register_klass_file(klass)
      klass.instance_variable_set(:@no_commands, 0)
    end

method_added(meth) click to toggle source

Fire this callback whenever a method is added. Added methods are tracked as commands by invoking the create_command method.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 622
    def method_added(meth)
      super(meth)
      meth = meth.to_s

      if meth == "initialize"
        initialize_added
        return
      end

      # Return if it's not a public instance method
      return unless public_method_defined?(meth.to_sym)

      return if no_commands? || !create_command(meth)

      is_thor_reserved_word?(meth, :command)
      Bundler::Thor::Base.register_klass_file(self)
    end

print_options(shell, options, group_name = nil) click to toggle source

Receives a set of options and print them.

                   # File bundler/vendor/thor/lib/thor/base.rb, line 548
    def print_options(shell, options, group_name = nil)
      return if options.empty?

      list = []
      padding = options.map { |o| o.aliases.size }.max.to_i * 4

      options.each do |option|
        next if option.hide
        item = [option.usage(padding)]
        item.push(option.description ? "# #{option.description}" : "")

        list << item
        list << ["", "# Default: #{option.default}"] if option.show_default?
        list << ["", "# Possible values: #{option.enum.join(', ')}"] if option.enum
      end

      shell.say(group_name ? "#{group_name} options:" : "Options:")
      shell.print_table(list, :indent => 2)
      shell.say ""
    end