Module: Foreman::Thor::Base::ClassMethods

Defined in:
lib/foreman/vendor/thor/lib/thor/base.rb

Instance Method Summary collapse

Instance Method Details

#all_commands ⇒ Object Also known as: all_tasks

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

Returns

OrderedHash

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



348
349
350
351
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 348

def all_commands
  @all_commands ||= from_superclass(:all_commands, Foreman::Thor::CoreExt::OrderedHash.new)
  @all_commands.merge!(commands)
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.



210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 210

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

#arguments ⇒ Object

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

Returns

Array



242
243
244
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 242

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

#attr_accessor ⇒ Object

:nodoc:



135
136
137
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 135

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

#attr_reader ⇒ Object

:nodoc:



127
128
129
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 127

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

#attr_writer ⇒ Object

:nodoc:



131
132
133
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 131

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

#check_unknown_options ⇒ Object

:nodoc:



145
146
147
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 145

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.



141
142
143
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 141

def check_unknown_options!
  @check_unknown_options = true
end

#check_unknown_options?(config) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


149
150
151
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 149

def check_unknown_options?(config) #:nodoc:
  !!check_unknown_options
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: Foreman::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.



277
278
279
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 277

def class_option(name, options = {})
  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]



255
256
257
258
259
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 255

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 Foreman::Thor class.

Returns

OrderedHash

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



337
338
339
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 337

def commands
  @commands ||= Foreman::Thor::CoreExt::OrderedHash.new
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>



323
324
325
326
327
328
329
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 323

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:



479
480
481
482
483
484
485
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 479

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

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

:nodoc:

Raises:



473
474
475
476
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 473

def handle_no_command_error(command, has_namespace = $thor_runner) #:nodoc:
  raise UndefinedCommandError, "Could not find command #{command.inspect} in #{namespace.inspect} namespace." if has_namespace
  raise UndefinedCommandError, "Could not find command #{command.inspect}."
end

#namespace(name = nil) ⇒ Object

Sets the namespace for the Foreman::Thor or Foreman::Thor::Group class. By default the namespace is retrieved from the class name. If your Foreman::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



426
427
428
429
430
431
432
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 426

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

#no_commands ⇒ Object Also known as: no_tasks

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

So you can do:

class MyScript < Foreman::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 < Foreman::Thor
  def this_is_not_a_command
  end
  remove_command :this_is_not_a_command
end



396
397
398
399
400
401
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 396

def no_commands
  @no_commands = true
  yield
ensure
  @no_commands = false
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



466
467
468
469
470
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 466

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



292
293
294
295
296
297
298
299
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 292

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



311
312
313
314
315
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 311

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



366
367
368
369
370
371
372
373
374
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 366

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

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



442
443
444
445
446
447
448
449
450
451
452
453
454
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 442

def start(given_args = ARGV, config = {})
  config[:shell] ||= Foreman::Thor::Base.shell.new
  dispatch(nil, given_args.dup, nil, config)
rescue Foreman::Thor::Error => e
  config[:debug] || ENV["THOR_DEBUG"] == "1" ? (raise e) : config[:shell].error(e.message)
  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

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


156
157
158
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 156

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

#strict_args_position ⇒ Object

:nodoc:



167
168
169
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 167

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.



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

def strict_args_position!
  @strict_args_position = true
end

#strict_args_position?(config) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


171
172
173
 
# File 'lib/foreman/vendor/thor/lib/thor/base.rb', line 171

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