Module: Thor::Base::ClassMethods

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

Instance Method Summary collapse

Instance Method Details

#all_tasksObject

Returns the tasks for this Thor class and all subclasses.

Returns

OrderedHash

An ordered hash with tasks names as keys and Thor::Task objects as values.


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

def all_tasks
  @all_tasks ||= from_superclass(:all_tasks, Thor::CoreExt::OrderedHash.new)
  @all_tasks.merge(tasks)
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 task NAME

Instead of:

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


195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
# File 'lib/vendor/thor/lib/thor/base.rb', line 195

def argument(name, options={})
  is_thor_reserved_word?(name, :argument)
  no_tasks { attr_accessor name }

  required = if options.key?(:optional)
    !options[:optional]
  elsif options.key?(:required)
    options[:required]
  else
    options[:default].nil?
  end

  remove_argument name

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

  options[:required] = required

  arguments << Thor::Argument.new(name, options)
end

#argumentsObject

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

Returns

Array


225
226
227
# File 'lib/vendor/thor/lib/thor/base.rb', line 225

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

#attr_accessorObject

:nodoc:


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

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

#attr_readerObject

:nodoc:


119
120
121
# File 'lib/vendor/thor/lib/thor/base.rb', line 119

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

#attr_writerObject

:nodoc:


123
124
125
# File 'lib/vendor/thor/lib/thor/base.rb', line 123

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

#check_unknown_optionsObject

:nodoc:


137
138
139
# File 'lib/vendor/thor/lib/thor/base.rb', line 137

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.


133
134
135
# File 'lib/vendor/thor/lib/thor/base.rb', line 133

def check_unknown_options!
  @check_unknown_options = true
end

#check_unknown_options?(config) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean)

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

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


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

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]


238
239
240
241
242
# File 'lib/vendor/thor/lib/thor/base.rb', line 238

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

#group(name = nil) ⇒ Object

Defines the group. This is used when thor list is invoked so you can specify that only tasks from a pre-defined group will be shown. Defaults to standard.

Parameters

name<String|Symbol>


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

def group(name=nil)
  case name
    when nil
      @group ||= from_superclass(:group, 'standard')
    else
      @group = name.to_s
  end
end

#handle_argument_error(task, error, arity = nil) ⇒ Object

:nodoc:

Raises:


461
462
463
464
465
466
467
468
469
470
471
472
473
# File 'lib/vendor/thor/lib/thor/base.rb', line 461

def handle_argument_error(task, error, arity=nil) #:nodoc:
  msg = "#{basename} #{task.name}"
  if arity
    required = arity < 0 ? (-1 - arity) : arity
    msg << " requires at least #{required} argument"
    msg << "s" if required > 1
  else
    msg = "call #{msg} as"
  end

  msg << ": #{self.banner(task).inspect}."
  raise InvocationError, msg
end

#handle_no_task_error(task, has_namespace = $thor_runner) ⇒ Object

:nodoc:


453
454
455
456
457
458
459
# File 'lib/vendor/thor/lib/thor/base.rb', line 453

def handle_no_task_error(task, has_namespace = $thor_runner) #:nodoc:
  if has_namespace
    raise UndefinedTaskError, "Could not find task #{task.inspect} in #{namespace.inspect} namespace."
  else
    raise UndefinedTaskError, "Could not find task #{task.inspect}."
  end
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 tasks are invoked:

thor my_scripts -h

Finally, if you change your namespace to default:

namespace :default

Your tasks can be invoked with a shortcut. Instead of:

thor :my_task

406
407
408
409
410
411
412
413
# File 'lib/vendor/thor/lib/thor/base.rb', line 406

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

#no_tasksObject

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

So you can do:

class MyScript < Thor
  no_tasks do
    def this_is_not_a_task
    end
  end
end

You can also add the method and remove it from the task list:

class MyScript < Thor
  def this_is_not_a_task
  end
  remove_task :this_is_not_a_task
end

377
378
379
380
381
382
# File 'lib/vendor/thor/lib/thor/base.rb', line 377

def no_tasks
  @no_tasks = true
  yield
ensure
  @no_tasks = false
end

#public_task(*names) ⇒ Object

Allows to use private methods from parent in child classes as tasks.

Parameters

names<Array>:: Method names to be used as tasks

Examples

public_task :foo
public_task :foo, :bar, :baz

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

def public_task(*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

275
276
277
278
279
280
281
282
# File 'lib/vendor/thor/lib/thor/base.rb', line 275

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

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

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

#remove_task(*names) ⇒ Object

Removes a given task 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 task. But you can supply :undefine => true to undefine the method from the class as well.

Parameters

name<Symbol|String>

The name of the task to be removed

options<Hash>

You can give :undefine => true if you want tasks the method to be undefined from the class as well.


348
349
350
351
352
353
354
355
356
# File 'lib/vendor/thor/lib/thor/base.rb', line 348

def remove_task(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}

  names.each do |name|
    tasks.delete(name.to_s)
    all_tasks.delete(name.to_s)
    undef_method name if options[:undefine]
  end
end

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

Parses the task and options from the given args, instantiate the class and invoke the task. 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(:task, first_arg, second_arg, third_arg)

423
424
425
426
427
428
429
430
431
432
433
434
435
# File 'lib/vendor/thor/lib/thor/base.rb', line 423

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

:nodoc:


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

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.


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

def strict_args_position!
  @strict_args_position = true
end

#strict_args_position?(config) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean)

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

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

#tasksObject

Returns the tasks for this Thor class.

Returns

OrderedHash

An ordered hash with tasks names as keys and Thor::Task objects as values.


321
322
323
# File 'lib/vendor/thor/lib/thor/base.rb', line 321

def tasks
  @tasks ||= Thor::CoreExt::OrderedHash.new
end