Module: Bundler::Thor::Base::ClassMethods

Relationships & Source Files
Defined in:	lib/bundler/vendor/thor/lib/thor/base.rb

Instance Attribute Summary

#exit_on_failure? ⇒ Boolean readonly

A flag that makes the process exit with status 1 if any error happens.
#no_commands? ⇒ Boolean readonly

Instance Method Summary

#all_commands (also: #all_tasks)

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

Alias for #all_commands.
#allow_incompatible_default_type!

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!.
#argument(name, options = {})

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

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

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

If you want to raise an error for unknown options, call check_unknown_options! This is disabled by default to allow dynamic invocations.
#class_at_least_one(*args, &block)

Adds and declares option group for required at least one of options in the block and arguments.
#class_at_least_one_option_names

Returns this class at least one of required options array set, looking up in the ancestors chain.
#class_exclusive(*args, &block)

Adds and declares option group for exclusive options in the block and arguments.
#class_exclusive_option_names

Returns this class exclusive options array set, looking up in the ancestors chain.
#class_option(name, options = {})

Adds an option to the set of class options.
#class_options(options = nil)

Adds a bunch of options to the set of class options.
#commands (also: #tasks)

Returns the commands for this ::Bundler::Thor class.
#group(name = nil)

Defines the group.
#handle_no_task_error(command, has_namespace = $thor_runner)

Alias for #handle_no_command_error.
#namespace(name = nil)

Sets the namespace for the ::Bundler::Thor or ::Bundler::Thor::Group class.
#no_commands(&block) (also: #no_tasks) readonly

All methods defined inside the given block are not added as commands.
#no_commands_context
#no_tasks(&block)

Alias for #no_commands.
#public_command(*names) (also: #public_task)

Allows to use private methods from parent in child classes as commands.
#public_task(*names)

Alias for #public_command.
#remove_argument(*names)

Removes a previous defined argument.
#remove_class_option(*names)

Removes a previous defined class option.
#remove_command(*names) (also: #remove_task)

Removes a given command from this ::Bundler::Thor class.
#remove_task(*names)

Alias for #remove_command.
#start(given_args = ARGV, config = {})

Parses the command and options from the given args, instantiate the class and invoke the command.
#strict_args_position!

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

Alias for #commands.
#basename protected

The basename of the program invoking the thor class.
#create_task(meth) protected

Alias for #create_command.
#find_and_refresh_task(name) protected

Alias for #find_and_refresh_command.
#from_superclass(method, default = nil) protected

Retrieves a value from superclass.
#inherited(klass) protected

Every time someone inherits from a ::Bundler::Thor class, register the klass and file into baseclass.
#method_added(meth) protected

Fire this callback whenever a method is added.
#print_options(shell, options, group_name = nil) protected

Receives a set of options and print them.
#attr_accessor Internal use only
#attr_reader Internal use only
#attr_writer Internal use only
#check_default_type Internal use only
#check_unknown_options Internal use only
#check_unknown_options?(config) ⇒ Boolean Internal use only
#disable_required_check?(command_name) ⇒ Boolean Internal use only

If true, option set will not suspend the execution of the command when a required option is not provided.
#handle_argument_error(command, error, args, arity) Internal use only
#handle_no_command_error(command, has_namespace = $thor_runner) (also: #handle_no_task_error) Internal use only
#stop_on_unknown_option?(command_name) ⇒ Boolean Internal use only

If true, option parsing is suspended as soon as an unknown option or a regular argument is encountered.
#strict_args_position Internal use only
#strict_args_position?(config) ⇒ Boolean Internal use only
#baseclass protected Internal use only

SIGNATURE: Sets the baseclass.
#build_option(name, options, scope) protected Internal use only

Build an option and adds it to the given scope.
#build_options(options, scope) protected Internal use only

Receives a hash of options, parse them and add to the scope.
#built_option_names(target, opt = {}, &block) protected Internal use only

Get target(method_options or class_options) options of before and after by block evaluation.
#class_options_help(shell, groups = {}) protected Internal use only

Prints the class options per group.
#command_scope_member(name, options = {}) protected Internal use only

Get command scope member by name.
#create_command(meth) (also: #create_task) protected Internal use only

SIGNATURE: Creates a new command if valid_command? is true.
#dispatch(command, given_args, given_opts, config) protected Internal use only

SIGNATURE: The hook invoked by start.
#find_and_refresh_command(name) (also: #find_and_refresh_task) protected Internal use only

Finds a command with the given name.
#initialize_added protected Internal use only

SIGNATURE: Defines behavior when the initialize method is added to the class.
#is_thor_reserved_word?(word, type) ⇒ Boolean protected Internal use only

Raises an error if the word given is a ::Bundler::Thor reserved word.
#register_options_relation_for(target, relation, *args, &block) protected Internal use only

Register a relation of options for target(method_option/class_option) by args and block.

Instance Attribute Details

#exit_on_failure? ⇒ `Boolean` (readonly)

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

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 628


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

#no_commands? ⇒ `Boolean` (readonly)

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 540


def no_commands?
  no_commands_context.entered?
end

Instance Method Details

#all_commands Also known as: #all_tasks

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.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 482


def all_commands
  @all_commands ||= from_superclass(:all_commands, Hash.new)
  @all_commands.merge!(commands)
end

#all_tasks

Alias for #all_commands.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 486


alias_method :all_tasks, :all_commands

#allow_incompatible_default_type!

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!

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 189


def allow_incompatible_default_type!
  @check_default_type = false
end

#argument(name, options = {})

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

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

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 261


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

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

Returns

Array

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 293


def arguments
  @arguments ||= from_superclass(:arguments, [])
end

#attr_accessor

This method is for internal use only.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 162


def attr_accessor(*) #:nodoc:
  no_commands { super }
end

#attr_reader

This method is for internal use only.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 154


def attr_reader(*) #:nodoc:
  no_commands { super }
end

#attr_writer

This method is for internal use only.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 158


def attr_writer(*) #:nodoc:
  no_commands { super }
end

#baseclass (protected)

This method is for internal use only.

SIGNATURE: Sets the baseclass. This is where the superclass lookup finishes.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 777


def baseclass #:nodoc:
end

#basename (protected)

The basename of the program invoking the thor class.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 771


def basename
  File.basename($PROGRAM_NAME).split(" ").first
end

#build_option(name, options, scope) (protected)

This method is for internal use only.

Build an option and adds it to the given scope.

Parameters

name<Symbol>: The name of the argument.
options<Hash>: Described in both class_option and method_option.
scope<Hash>: ::Bundler::Thor::Options hash that is being built up

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 688


def build_option(name, options, scope) #:nodoc:
  scope[name] = Bundler::Thor::Option.new(name, {check_default_type: check_default_type}.merge!(options))
end

#build_options(options, scope) (protected)

This method is for internal use only.

Receives a hash of options, parse them and add to the scope. This is a fast way to set a bunch of options:

build_options :foo => true, :bar => :required, :baz => :string

Parameters

Hash[Symbol => Object]

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 699


def build_options(options, scope) #:nodoc:
  options.each do |key, value|
    scope[key] = Bundler::Thor::Option.parse(key, value)
  end
end

#built_option_names(target, opt = {}, &block) (protected)

This method is for internal use only.

Get target(method_options or class_options) options of before and after by block evaluation.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 808


def built_option_names(target, opt = {}, &block) # :nodoc:
  before = command_scope_member(target, opt).map{ |k,v| v.name }
  instance_eval(&block)
  after  = command_scope_member(target, opt).map{ |k,v| v.name }
  after - before
end

#check_default_type

This method is for internal use only.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 193


def check_default_type #:nodoc:
  @check_default_type = from_superclass(:check_default_type, nil) unless defined?(@check_default_type)
  @check_default_type
end

#check_default_type!

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.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 183


def check_default_type!
  @check_default_type = true
end

#check_unknown_options

This method is for internal use only.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 172


def check_unknown_options #:nodoc:
  @check_unknown_options ||= from_superclass(:check_unknown_options, false)
end

#check_unknown_options!

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

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 168


def check_unknown_options!
  @check_unknown_options = true
end

#check_unknown_options?(config) ⇒ `Boolean`

This method is for internal use only.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 176


def check_unknown_options?(config) #:nodoc:
  !!check_unknown_options
end

#class_at_least_one(*args, &block)

Adds and declares option group for required at least one of options in the block and arguments. You can declare options as the outside of the block.

Examples

class_at_least_one do
  class_option :one
  class_option :two
 end

class_option :one
class_option :two
class_at_least_one :one, :two

If you do not give “–one” and “–two” ::Bundler::Thor::AtLeastOneRequiredArgumentError will be raised.

You can use class_at_least_one and class_exclusive at the same time.

class_exclusive do
  class_at_least_one do
    class_option :one
    class_option :two
  end
end

Then it is required either only one of “–one” or “–two”.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 392


def class_at_least_one(*args, &block)
  register_options_relation_for(:class_options,
                                :class_at_least_one_option_names, *args, &block)
end

#class_at_least_one_option_names

Returns this class at least one of required options array set, looking up in the ancestors chain.

Returns

Array[Array]

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 411


def class_at_least_one_option_names
  @class_at_least_one_option_names ||= from_superclass(:class_at_least_one_option_names, [])
end

#class_exclusive(*args, &block)

Adds and declares option group for exclusive options in the block and arguments. You can declare options as the outside of the block.

Parameters

Array

Examples

class_exclusive do
  class_option :one
  class_option :two
 end

class_option :one
class_option :two
class_exclusive :one, :two

If you give “–one” and “–two” at the same time ExclusiveArgumentsError will be raised.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 357


def class_exclusive(*args, &block)
  register_options_relation_for(:class_options,
                                :class_exclusive_option_names, *args, &block)
end

#class_exclusive_option_names

Returns this class exclusive options array set, looking up in the ancestors chain.

Returns

Array[Array]

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 402


def class_exclusive_option_names
  @class_exclusive_option_names ||= from_superclass(:class_exclusive_option_names, [])
end

#class_option(name, options = {})

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.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 328


def class_option(name, options = {})
  unless [ Symbol, String ].any? { |klass| name.is_a?(klass) }
    raise ArgumentError, "Expected a Symbol or String, got #{name.inspect}"
  end
  build_option(name, options, class_options)
end

#class_options(options = nil)

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]

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 306


def class_options(options = nil)
  @class_options ||= from_superclass(:class_options, {})
  build_options(options, @class_options) if options
  @class_options
end

#class_options_help(shell, groups = {}) (protected)

This method is for internal use only.

Prints the class options per group. If an option does not belong to any group, it’s printed as Class option.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 638


def class_options_help(shell, groups = {}) #:nodoc:
  # Group options by group
  class_options.each do |_, value|
    groups[value.group] ||= []
    groups[value.group] << value
  end

  # Deal with default group
  global_options = groups.delete(nil) || []
  print_options(shell, global_options)

  # Print all others
  groups.each do |group_name, options|
    print_options(shell, options, group_name)
  end
end

#command_scope_member(name, options = {}) (protected)

This method is for internal use only.

Get command scope member by name.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 816


def command_scope_member(name, options = {}) # :nodoc:
  if options[:for]
    find_and_refresh_command(options[:for]).send(name)
  else
    send(name)
  end
end

#commands Also known as: #tasks

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.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 471


def commands
  @commands ||= Hash.new
end

#create_command(meth) (protected) Also known as: #create_task

This method is for internal use only.

SIGNATURE: Creates a new command if valid_command? is true. This method is called when a new method is added to the class.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 782


def create_command(meth) #:nodoc:
end

#create_task(meth) (protected)

Alias for #create_command.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 784


alias_method :create_task, :create_command

#disable_required_check?(command_name) ⇒ `Boolean`

This method is for internal use only.

If true, option set will not suspend the execution of the command when a required option is not provided.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 207


def disable_required_check?(command_name) #:nodoc:
  false
end

#dispatch(command, given_args, given_opts, config) (protected)

This method is for internal use only.

SIGNATURE: The hook invoked by start.

Raises:

(NotImplementedError)

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 792


def dispatch(command, given_args, given_opts, config) #:nodoc:
  raise NotImplementedError
end

#find_and_refresh_command(name) (protected) Also known as: #find_and_refresh_task

This method is for internal use only.

Finds a command with the given name. If the command belongs to the current class, just return it, otherwise dup it and add the fresh copy to the current command hash.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 708


def find_and_refresh_command(name) #:nodoc:
  if commands[name.to_s]
    commands[name.to_s]
  elsif command = all_commands[name.to_s] # rubocop:disable Lint/AssignmentInCondition
    commands[name.to_s] = command.clone
  else
    raise ArgumentError, "You supplied :for => #{name.inspect}, but the command #{name.inspect} could not be found."
  end
end

#find_and_refresh_task(name) (protected)

Alias for #find_and_refresh_command.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 717


alias_method :find_and_refresh_task, :find_and_refresh_command

#from_superclass(method, default = nil) (protected)

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

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 749


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

#group(name = nil)

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>

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 457


def group(name = nil)
  if name
    @group = name.to_s
  else
    @group ||= from_superclass(:group, "standard")
  end
end

#handle_argument_error(command, error, args, arity)

This method is for internal use only.

Raises:

(InvocationError)

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 618


def handle_argument_error(command, error, args, arity) #:nodoc:
  name = [command.ancestor_name, command.name].compact.join(" ")
  msg = "ERROR: \"#{basename} #{name}\" was called with ".dup
  msg << "no arguments"               if     args.empty?
  msg << "arguments " << args.inspect unless args.empty?
  msg << "\nUsage: \"#{banner(command).split("\n").join("\"\n       \"")}\""
  raise InvocationError, msg
end

#handle_no_command_error(command, has_namespace = $thor_runner) Also known as: #handle_no_task_error

This method is for internal use only.

Raises:

(UndefinedCommandError)

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 613


def handle_no_command_error(command, has_namespace = $thor_runner) #:nodoc:
  raise UndefinedCommandError.new(command, all_commands.keys, (namespace if has_namespace))
end

#handle_no_task_error(command, has_namespace = $thor_runner)

Alias for #handle_no_command_error.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 616


alias_method :handle_no_task_error, :handle_no_command_error

#inherited(klass) (protected)

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

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 721


def inherited(klass)
  super(klass)
  Bundler::Thor::Base.register_klass_file(klass)
  klass.instance_variable_set(:@no_commands, 0)
end

#initialize_added (protected)

This method is for internal use only.

SIGNATURE: Defines behavior when the initialize method is added to the class.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 788


def initialize_added #:nodoc:
end

#is_thor_reserved_word?(word, type) ⇒ `Boolean` (protected)

This method is for internal use only.

Raises an error if the word given is a ::Bundler::Thor reserved word.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 677


def is_thor_reserved_word?(word, type) #:nodoc:
  return false unless THOR_RESERVED_WORDS.include?(word.to_s)
  raise "#{word.inspect} is a Bundler::Thor reserved word and cannot be defined as #{type}"
end

#method_added(meth) (protected)

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

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 729


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

#namespace(name = nil)

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

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 566


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) (readonly) Also known as: #no_tasks

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

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 530


def no_commands(&block)
  no_commands_context.enter(&block)
end

#no_commands_context

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 536


def no_commands_context
  @no_commands_context ||= NestedContext.new
end

#no_tasks(&block)

Alias for #no_commands.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 534


alias_method :no_tasks, :no_commands

#print_options(shell, options, group_name = nil) (protected)

Receives a set of options and print them.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 656


def print_options(shell, options, group_name = nil)
  return if options.empty?

  list = []
  padding = options.map { |o| o.aliases_for_usage.size }.max.to_i
  options.each do |option|
    next if option.hide
    item = [option.usage(padding)]
    item.push(option.description ? "# #{option.description}" : "")

    list << item
    list << ["", "# Default: #{option.print_default}"] if option.show_default?
    list << ["", "# Possible values: #{option.enum_to_s}"] if option.enum
  end

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

#public_command(*names) Also known as: #public_task

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

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 606


def public_command(*names)
  names.each do |name|
    class_eval "def #{name}(*); super end", __FILE__, __LINE__
  end
end

#public_task(*names)

Alias for #public_command.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 611


alias_method :public_task, :public_command

#register_options_relation_for(target, relation, *args, &block) (protected)

This method is for internal use only.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 798


def register_options_relation_for(target, relation, *args, &block) # :nodoc:
  opt = args.pop if args.last.is_a? Hash
  opt ||= {}
  names = args.map{ |arg| arg.to_s }
  names += built_option_names(target, opt, &block) if block_given?
  command_scope_member(relation, opt) << names
end

#remove_argument(*names)

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

Parameters

names<Array>: ::Bundler::Thor::Arguments to be removed

Examples

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

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 426


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)

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

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 445


def remove_class_option(*names)
  names.each do |name|
    class_options.delete(name)
  end
end

#remove_command(*names) Also known as: #remove_task

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.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 500


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

#remove_task(*names)

Alias for #remove_command.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 509


alias_method :remove_task, :remove_command

#start(given_args = ARGV, config = {})

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)

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 582


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

#stop_on_unknown_option?(command_name) ⇒ `Boolean`

This method is for internal use only.

If true, option parsing is suspended as soon as an unknown option or a regular argument is encountered. All remaining arguments are passed to the command as regular arguments.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 201


def stop_on_unknown_option?(command_name) #:nodoc:
  false
end

#strict_args_position

This method is for internal use only.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 218


def strict_args_position #:nodoc:
  @strict_args_position ||= from_superclass(:strict_args_position, false)
end

#strict_args_position!

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.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 214


def strict_args_position!
  @strict_args_position = true
end

#strict_args_position?(config) ⇒ `Boolean`

This method is for internal use only.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 222


def strict_args_position?(config) #:nodoc:
  !!strict_args_position
end

#tasks

Alias for #commands.

[ GitHub ]

# File 'lib/bundler/vendor/thor/lib/thor/base.rb', line 474


alias_method :tasks, :commands

Module: Bundler::Thor::Base::ClassMethods

Instance Attribute Summary

Instance Method Summary

Instance Attribute Details

#exit_on_failure? ⇒ Boolean (readonly)

#no_commands? ⇒ Boolean (readonly)

Instance Method Details

#all_commands Also known as: #all_tasks

Returns

#all_tasks

#allow_incompatible_default_type!

#argument(name, options = {})

Parameters

Options

Errors

#arguments

Returns

#attr_accessor

#attr_reader

#attr_writer

#baseclass (protected)

#basename (protected)

#build_option(name, options, scope) (protected)

Parameters

#build_options(options, scope) (protected)

Parameters

#built_option_names(target, opt = {}, &block) (protected)

#check_default_type

#check_default_type!

#check_unknown_options

#check_unknown_options!

#check_unknown_options?(config) ⇒ Boolean

#class_at_least_one(*args, &block)

Examples

#class_at_least_one_option_names

Returns

#class_exclusive(*args, &block)

Parameters

Examples

#class_exclusive_option_names

Returns

#class_option(name, options = {})

Parameters

Options

#class_options(options = nil)

Parameters

#class_options_help(shell, groups = {}) (protected)

#command_scope_member(name, options = {}) (protected)

#commands Also known as: #tasks

Returns

#create_command(meth) (protected) Also known as: #create_task

#create_task(meth) (protected)

#disable_required_check?(command_name) ⇒ Boolean

#dispatch(command, given_args, given_opts, config) (protected)

#find_and_refresh_command(name) (protected) Also known as: #find_and_refresh_task

#find_and_refresh_task(name) (protected)

#from_superclass(method, default = nil) (protected)

#group(name = nil)

Parameters

#handle_argument_error(command, error, args, arity)

#handle_no_command_error(command, has_namespace = $thor_runner) Also known as: #handle_no_task_error

#handle_no_task_error(command, has_namespace = $thor_runner)

#inherited(klass) (protected)

#initialize_added (protected)

#is_thor_reserved_word?(word, type) ⇒ Boolean (protected)

#method_added(meth) (protected)

#namespace(name = nil)

#no_commands(&block) (readonly) Also known as: #no_tasks

#no_commands_context

#no_tasks(&block)

#print_options(shell, options, group_name = nil) (protected)

#public_command(*names) Also known as: #public_task

Parameters

Examples

#public_task(*names)

#register_options_relation_for(target, relation, *args, &block) (protected)

#remove_argument(*names)

Parameters

Examples

#remove_class_option(*names)

#exit_on_failure? ⇒ `Boolean` (readonly)

#no_commands? ⇒ `Boolean` (readonly)

#check_unknown_options?(config) ⇒ `Boolean`

#disable_required_check?(command_name) ⇒ `Boolean`

#is_thor_reserved_word?(word, type) ⇒ `Boolean` (protected)

#stop_on_unknown_option?(command_name) ⇒ `Boolean`

#strict_args_position?(config) ⇒ `Boolean`