Module: Thor::Base::ClassMethods

Defined in:
lib/thor/base.rb

Instance Method Summary collapse

Instance Method Details

#all_commands ⇒ Object Also known as: all_tasks

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.



483
484
485
486
 
# File 'lib/thor/base.rb', line 483

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

#allow_incompatible_default_type! ⇒ Object

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



190
191
192
 
# File 'lib/thor/base.rb', line 190

def allow_incompatible_default_type!
  @check_default_type = false
end

#argument(name, options = {}) ⇒ Object

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.



262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
 
# File 'lib/thor/base.rb', line 262

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

#arguments ⇒ Object

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

Returns

Array



294
295
296
 
# File 'lib/thor/base.rb', line 294

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

#attr_accessor ⇒ Object

:nodoc:



163
164
165
 
# File 'lib/thor/base.rb', line 163

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

#attr_reader ⇒ Object

:nodoc:



155
156
157
 
# File 'lib/thor/base.rb', line 155

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

#attr_writer ⇒ Object

:nodoc:



159
160
161
 
# File 'lib/thor/base.rb', line 159

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

#check_default_type ⇒ Object

:nodoc:



194
195
196
197
 
# File 'lib/thor/base.rb', line 194

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! ⇒ Object

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.



184
185
186
 
# File 'lib/thor/base.rb', line 184

def check_default_type!
  @check_default_type = true
end

#check_unknown_options ⇒ Object

:nodoc:



173
174
175
 
# File 'lib/thor/base.rb', line 173

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

#check_unknown_options! ⇒ Object

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



169
170
171
 
# File 'lib/thor/base.rb', line 169

def check_unknown_options!
  @check_unknown_options = true
end

#check_unknown_options?(config) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


177
178
179
 
# File 'lib/thor/base.rb', line 177

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

#class_at_least_one(*args, &block) ⇒ Object

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



393
394
395
396
 
# File 'lib/thor/base.rb', line 393

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

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

Returns

Array[Array]



412
413
414
 
# File 'lib/thor/base.rb', line 412

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) ⇒ Object

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.



358
359
360
361
 
# File 'lib/thor/base.rb', line 358

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

#class_exclusive_option_names ⇒ Object

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

Returns

Array[Array]



403
404
405
 
# File 'lib/thor/base.rb', line 403

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

#class_option(name, options = {}) ⇒ Object

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.



329
330
331
332
333
334
 
# File 'lib/thor/base.rb', line 329

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) ⇒ Object

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]



307
308
309
310
311
 
# File 'lib/thor/base.rb', line 307

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

#commands ⇒ Object Also known as: tasks

Returns the commands for this Thor class.

Returns

Hash

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



472
473
474
 
# File 'lib/thor/base.rb', line 472

def commands
  @commands ||= Hash.new
end

#disable_required_check?(command_name) ⇒ Boolean

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

Returns:

  • (Boolean) 


208
209
210
 
# File 'lib/thor/base.rb', line 208

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

#exit_on_failure? ⇒ Boolean

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

Returns:

  • (Boolean) 


629
630
631
632
 
# File 'lib/thor/base.rb', line 629

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

#group(name = nil) ⇒ Object

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>



458
459
460
461
462
463
464
 
# File 'lib/thor/base.rb', line 458

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) ⇒ Object

:nodoc:

Raises:



619
620
621
622
623
624
625
626
 
# File 'lib/thor/base.rb', line 619

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) ⇒ Object Also known as: handle_no_task_error

:nodoc:

Raises:



614
615
616
 
# File 'lib/thor/base.rb', line 614

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

#namespace(name = nil) ⇒ Object

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



567
568
569
570
571
572
573
 
# File 'lib/thor/base.rb', line 567

def namespace(name = nil)
  if name
    @namespace = name.to_s
  else
    @namespace ||= Thor::Util.namespace_from_thor_class(self)
  end
end

#no_commands(&block) ⇒ Object Also known as: no_tasks

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



531
532
533
 
# File 'lib/thor/base.rb', line 531

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

#no_commands? ⇒ Boolean

Returns:

  • (Boolean) 


541
542
543
 
# File 'lib/thor/base.rb', line 541

def no_commands?
  no_commands_context.entered?
end

#no_commands_context ⇒ Object 



537
538
539
 
# File 'lib/thor/base.rb', line 537

def no_commands_context
  @no_commands_context ||= NestedContext.new
end

#public_command(*names) ⇒ Object 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



607
608
609
610
611
 
# File 'lib/thor/base.rb', line 607

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

#remove_argument(*names) ⇒ Object

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



427
428
429
430
431
432
433
434
 
# File 'lib/thor/base.rb', line 427

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) ⇒ Object

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



446
447
448
449
450
 
# File 'lib/thor/base.rb', line 446

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

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

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.



501
502
503
504
505
506
507
508
509
 
# File 'lib/thor/base.rb', line 501

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

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

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)



583
584
585
586
587
588
589
590
591
592
593
594
595
 
# File 'lib/thor/base.rb', line 583

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

#stop_on_unknown_option?(command_name) ⇒ Boolean

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.

Returns:

  • (Boolean) 


202
203
204
 
# File 'lib/thor/base.rb', line 202

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

#strict_args_position ⇒ Object

:nodoc:



219
220
221
 
# File 'lib/thor/base.rb', line 219

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

#strict_args_position! ⇒ Object

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.



215
216
217
 
# File 'lib/thor/base.rb', line 215

def strict_args_position!
  @strict_args_position = true
end

#strict_args_position?(config) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


223
224
225
 
# File 'lib/thor/base.rb', line 223

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