module Thor::Base::ClassMethods

Methods that are mixed in as module/class/singleton methods to modules that include {Thor::Base}.

Public Instance Methods

all_commands() click to toggle source

Returns the commands for this Thor class and all subclasses.

@return [HashWithIndifferentAccess<String, Thor::Command>]

An hash with commands names as keys and {Thor::Command}
objects as values.
# File lib/thor/base/class_methods.rb, line 228
def all_commands
  @all_commands ||= from_superclass(  :all_commands,
                                      HashWithIndifferentAccess.new )
  @all_commands.merge!(commands)
end
Also aliased as: all_tasks
all_tasks()
Alias for: all_commands
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 is disabled by default for compatibility.

# File lib/thor/base/class_methods.rb, line 84
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 lib/thor/base/class_methods.rb, line 66
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: 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 lib/thor/base/class_methods.rb, line 173
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.

@param [Hash<(String | Symbol), Object>] options

New option definitions to add via {#build_options}.

@return [HashWithIndifferentAccess<String, Thor::Option>]

Hash of option names to the option instances.
# File lib/thor/base/class_methods.rb, line 144
def class_options options = nil
  @class_options ||= \
    from_superclass( :class_options, HashWithIndifferentAccess.new )
  build_options(options, @class_options) if options
  @class_options
end
commands() click to toggle source

Returns the commands for this Thor class.

@return [HashWithIndifferentAccess<String, Thor::Command>] An hash with commands names as keys and Thor::Command objects as values.

# File lib/thor/base/class_methods.rb, line 216
def commands
  @commands ||= HashWithIndifferentAccess.new
end
Also aliased as: tasks
exec!(given_args = ARGV, config = {}) click to toggle source

Like {#start}, but explicitly for handling over control in an executable.

For details on why this is here see {file:doc/files/notes/too-broken-to-fail.md Too Broken to Fail}.

# File lib/thor/base/class_methods.rb, line 359
def exec! given_args = ARGV, config = {}
  execution = Thor::Execution.new thor_class:   self,
                                  given_args:   given_args,
                                  thor_config:  config
  execution.exec!
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 lib/thor/base/class_methods.rb, line 202
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) click to toggle source

Called in {Thor::Command#run} when an {ArgumentError} is raised and {Thor::Command#handle_argument_error?} returned `true`.

Assembles a message and raises {Thor::InvocationError}.

Defined on the Thor instance so it can be overridden to customize the message and/or error, as {Thor::Group} does in {Thor::Group#handle_argument_error}.

@param [Thor::Command] command

The command that encountered the {ArgumentError}.

@param [ArgumentError] error

The argument error itself.

@param [Array] args

The arguments the command was run with.

@param [Fixnum?] arity

The arity of the method on the Thor instance that was called, if known.

Not used in this implementation.

@raise [Thor::InvocationError]

Always.
# File lib/thor/base/class_methods.rb, line 423
def handle_argument_error command, error, args, arity
  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).inspect}"
  raise Thor::InvocationError, msg
end
namespace(name = nil) click to toggle source

Sets the namespace for the Thor or Thor::Group class. By default the namespace is retrieved from the class name. If your 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 lib/thor/base/class_methods.rb, line 310
def namespace(name = nil)
  if name
    @namespace = name.to_s
  else
    @namespace ||= Thor::Util.namespace_from_thor_class(self)
  end
end
no_commands() { || ... } click to toggle source

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

So you can do:

class MyScript < 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 < Thor
  def this_is_not_a_command
  end
  remove_command :this_is_not_a_command
end
# File lib/thor/base/class_methods.rb, line 279
def no_commands
  @no_commands = true
  yield
ensure
  @no_commands = false
end
Also aliased as: no_tasks
no_tasks()
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 lib/thor/base/class_methods.rb, line 377
def public_command(*names)
  names.each do |name|
    class_eval "def #{name}(*); super end"
  end
end
Also aliased as: public_task
public_task(*names)
Alias for: public_command
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 lib/thor/base/class_methods.rb, line 188
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 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 lib/thor/base/class_methods.rb, line 248
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)
Alias for: remove_command
start(given_args = ARGV, config = {}) click to toggle source

@depreciated

Use {#exec!} in executable script files.

Without additional configuration, using this method will often result in
executables that return success (exit code `0`) when they fail due to
bad arguments.

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 Thor class, you can simply initialize it:

script = MyScript.new(args, options, config)
script.invoke(:command, first_arg, second_arg, third_arg)
# File lib/thor/base/class_methods.rb, line 334
def start(given_args = ARGV, config = {})
  config[:shell] ||= Thor::Base.shell.new
  dispatch(nil, given_args.dup, nil, config)
rescue Thor::Error => e
  if config[:debug] || ENV["THOR_DEBUG"] == "1"
    raise e
  else
    config[:shell].error(e.message)
  end
  exit(1) 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(0)
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 lib/thor/base/class_methods.rb, line 117
def strict_args_position!
  @strict_args_position = true
end
tasks()
Alias for: commands