module Thor::Base::ClassMethods

Returns the commands for this Thor class and all subclasses.

Returns¶ ↑

Hash

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

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

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 lib/thor/base.rb, line 189
def allow_incompatible_default_type!
  @check_default_type = false
end

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 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 << Thor::Argument.new(name, options)
end

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

Returns¶ ↑

Array

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

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 lib/thor/base.rb, line 183
def check_default_type!
  @check_default_type = true
end

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.rb, line 168
def check_unknown_options!
  @check_unknown_options = true
end

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

Or

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

If you do not give “–one” and “–two” 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”.

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

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

Returns¶ ↑

Array[Array]

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

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

Or

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

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

# File lib/thor/base.rb, line 357
def class_exclusive(*args, &block)
  register_options_relation_for(:class_options,
                                :class_exclusive_option_names, *args, &block)
end

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

Returns¶ ↑

Array[Array]

# File lib/thor/base.rb, line 402
def class_exclusive_option_names
  @class_exclusive_option_names ||= from_superclass(:class_exclusive_option_names, [])
end

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

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

Returns the commands for this Thor class.

Returns¶ ↑

Hash

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

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

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

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

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.rb, line 457
def group(name = nil)
  if name
    @group = name.to_s
  else
    @group ||= from_superclass(:group, "standard")
  end
end

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.rb, line 566
def namespace(name = nil)
  if name
    @namespace = name.to_s
  else
    @namespace ||= Thor::Util.namespace_from_thor_class(self)
  end
end

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.rb, line 530
def no_commands(&block)
  no_commands_context.enter(&block)
end

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.rb, line 606
def public_command(*names)
  names.each do |name|
    class_eval "def #{name}(*); super end", __FILE__, __LINE__
  end
end

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

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.rb, line 445
def remove_class_option(*names)
  names.each do |name|
    class_options.delete(name)
  end
end

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

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.rb, line 582
def start(given_args = ARGV, config = {})
  config[:shell] ||= Thor::Base.shell.new
  dispatch(nil, given_args.dup, nil, config)
rescue 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

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.rb, line 214
def strict_args_position!
  @strict_args_position = true
end

The basename of the program invoking the thor class.

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

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

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

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

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

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

# File 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)
  Thor::Base.register_klass_file(self)
end

Receives a set of options and print them.

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