Module: Thor::Base::ClassMethods

Includes:
CommonClassOptions
Defined in:
lib/thor/base/class_methods.rb

Overview

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

Instance Method Summary collapse

Methods included from CommonClassOptions

#common_class_options, define

Instance Method Details

#all_commands ⇒ Object Also known as: all_tasks

Returns the commands for this Thor class and all subclasses.

Returns

OrderedHash

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



323
324
325
326
327
 
# File 'lib/thor/base/class_methods.rb', line 323

def all_commands
  @all_commands ||= from_superclass(  :all_commands,
                                      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.



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
 
# File 'lib/thor/base/class_methods.rb', line 170

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



204
205
206
 
# File 'lib/thor/base/class_methods.rb', line 204

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

#attr_accessor ⇒ Object

:nodoc:



58
59
60
 
# File 'lib/thor/base/class_methods.rb', line 58

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

#attr_reader ⇒ Object

Mixin Methods

(Which become class methods on includers of Thor::Base)



48
49
50
 
# File 'lib/thor/base/class_methods.rb', line 48

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

#attr_writer ⇒ Object

:nodoc:



53
54
55
 
# File 'lib/thor/base/class_methods.rb', line 53

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

#baseclass ⇒ Object (protected)

SIGNATURE: Sets the baseclass. This is where the superclass lookup finishes.



714
715
 
# File 'lib/thor/base/class_methods.rb', line 714

def baseclass #:nodoc:
end

#basename ⇒ Object (protected)

The basename of the program invoking the thor class.



700
701
702
 
# File 'lib/thor/base/class_methods.rb', line 700

def basename
  File.basename($PROGRAM_NAME).split(" ").first
end

#build_option(name, options, scope) ⇒ Object (protected)

Build an option and adds it to the given scope.

Parameters

name<Symbol>

The name of the argument.

options<Hash>

Described in both class_option and method_option.

scope<Hash>

Options hash that is being built up



602
603
604
605
606
607
 
# File 'lib/thor/base/class_methods.rb', line 602

def build_option(name, options, scope) #:nodoc:
  scope[name] = Thor::Option.new(
    name,
    options.merge(:check_default_type => check_default_type?)
  )
end

#build_options(options, scope) ⇒ Object (protected)

Receives a hash of options, parse them and add to the scope. This is a fast way to set a bunch of options:

build_options :foo => true, :bar => :required, :baz => :string

Parameters

Hash[Symbol => Object]



617
618
619
620
621
 
# File 'lib/thor/base/class_methods.rb', line 617

def build_options(options, scope) #:nodoc:
  options.each do |key, value|
    scope[key] = Thor::Option.parse(key, value)
  end
end

#check_default_type ⇒ Object

:nodoc:



89
90
91
 
# File 'lib/thor/base/class_methods.rb', line 89

def check_default_type #:nodoc:
  @check_default_type ||= from_superclass(:check_default_type, false)
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 is disabled by default for compatibility.



84
85
86
 
# File 'lib/thor/base/class_methods.rb', line 84

def check_default_type!
  @check_default_type = true
end

#check_default_type? ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


94
95
96
 
# File 'lib/thor/base/class_methods.rb', line 94

def check_default_type? #:nodoc:
  !!check_default_type
end

#check_unknown_options ⇒ Object

:nodoc:



71
72
73
 
# File 'lib/thor/base/class_methods.rb', line 71

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.



66
67
68
 
# File 'lib/thor/base/class_methods.rb', line 66

def check_unknown_options!
  @check_unknown_options = true
end

#check_unknown_options?(config) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


76
77
78
 
# File 'lib/thor/base/class_methods.rb', line 76

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.



246
247
248
 
# File 'lib/thor/base/class_methods.rb', line 246

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]



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

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

#class_options_help(shell, groups = {}) ⇒ nil (protected)

Prints the class options per group. If an option does not belong to any group, it’s printed as Class option.

Returns:

  • (nil) 


540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
 
# File 'lib/thor/base/class_methods.rb', line 540

def class_options_help shell, groups = {}
  # Group options by group
  class_options.each do |_, value|
    groups[value.group] ||= []
    groups[value.group] << value
  end

  # Deal with default group
  global_options = groups.delete(nil) || []
  print_options \
    shell,
    global_options,
    (groups.empty? ? nil : 'General')

  # Print all others
  groups.each do |group_name, options|
    print_options(shell, options, group_name)
  end
  
  nil
end

#commands ⇒ Object Also known as: tasks

Returns the commands for this Thor class.

Returns

OrderedHash

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



311
312
313
 
# File 'lib/thor/base/class_methods.rb', line 311

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

#create_command(meth) ⇒ Object (protected) Also known as: create_task

SIGNATURE: Creates a new command if valid_command? is true. This method is called when a new method is added to the class.



720
721
 
# File 'lib/thor/base/class_methods.rb', line 720

def create_command(meth) #:nodoc:
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) 


109
110
111
 
# File 'lib/thor/base/class_methods.rb', line 109

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

#dispatch(command, given_args, given_opts, config) ⇒ Object (protected)

SIGNATURE: The hook invoked by start.

Raises:

  • (NotImplementedError) 


732
733
734
 
# File 'lib/thor/base/class_methods.rb', line 732

def dispatch(command, given_args, given_opts, config) #:nodoc:
  raise NotImplementedError
end

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

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

For details on why this is here see Too Broken to Fail.



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

def exec!(given_args = ARGV, config = {})
  execution = Thor::Execution.new thor_class:   self,
                                  given_args:   given_args,
                                  thor_config:  config
  
  execution.exec!
end

#exit_on_failure? ⇒ Boolean (protected)

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

Returns:

  • (Boolean) 


693
694
695
 
# File 'lib/thor/base/class_methods.rb', line 693

def exit_on_failure?
  false
end

#find_and_refresh_command(name) ⇒ Object (protected) Also known as: find_and_refresh_task

Finds a command with the given name. If the command belongs to the current class, just return it, otherwise dup it and add the fresh copy to the current command hash.



627
628
629
630
631
632
633
634
635
636
637
 
# File 'lib/thor/base/class_methods.rb', line 627

def find_and_refresh_command(name) #:nodoc:
  if commands[name.to_s]
    commands[name.to_s]
  elsif command = all_commands[name.to_s] # rubocop:disable AssignmentInCondition
    commands[name.to_s] = command.clone
  else
    raise ArgumentError,
      "You supplied :for => #{name.inspect}, but the command " \
      "#{name.inspect} could not be found."
  end
end

#from_superclass(method, default = nil) ⇒ Object (protected)

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



672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
 
# File 'lib/thor/base/class_methods.rb', line 672

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

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



296
297
298
299
300
301
302
 
# File 'lib/thor/base/class_methods.rb', line 296

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

Called in Command#run when an ArgumentError is raised and Command#handle_argument_error? returned ‘true`.

Assembles a message and raises InvocationError.

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

Parameters:

  • command (Thor::Command) —

    The command that encountered the ArgumentError.

  • error (ArgumentError) —

    The argument error itself.

  • args (Array) —

    The arguments the command was run with.

  • arity (Fixnum?) —

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

    Not used in this implementation.

Raises:



519
520
521
522
523
524
525
526
 
# File 'lib/thor/base/class_methods.rb', line 519

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

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

:nodoc:

Raises:



481
482
483
484
485
486
487
488
489
 
# File 'lib/thor/base/class_methods.rb', line 481

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

#inherited(klass) ⇒ Object (protected)

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



643
644
645
646
 
# File 'lib/thor/base/class_methods.rb', line 643

def inherited(klass)
  Thor::Base.register_klass_file(klass)
  klass.instance_variable_set(:@no_commands, false)
end

#initialize_added ⇒ Object (protected)

SIGNATURE: Defines behavior when the initialize method is added to the class.



727
728
 
# File 'lib/thor/base/class_methods.rb', line 727

def initialize_added #:nodoc:
end

#is_thor_reserved_word?(word, type) ⇒ Boolean (protected)

Raises an error if the word given is a Thor reserved word.

Returns:

  • (Boolean) 


589
590
591
592
593
 
# File 'lib/thor/base/class_methods.rb', line 589

def is_thor_reserved_word?(word, type) #:nodoc:
  return false unless Thor::THOR_RESERVED_WORDS.include?(word.to_s)
  raise "#{word.inspect} is a Thor reserved word and cannot be " \
        "defined as #{type}"
end

#method_added(meth) ⇒ Object (protected)

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



651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
 
# File 'lib/thor/base/class_methods.rb', line 651

def method_added(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)

  @no_commands ||= false
  return if @no_commands || !create_command(meth)

  is_thor_reserved_word?(meth, :command)
  Thor::Base.register_klass_file(self)
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



405
406
407
408
409
410
411
 
# File 'lib/thor/base/class_methods.rb', line 405

def namespace(name = nil)
  if name
    @namespace = name.to_s
  else
    @namespace ||= 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 < 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



374
375
376
377
378
379
 
# File 'lib/thor/base/class_methods.rb', line 374

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

#print_options(shell, options, group_name = nil) ⇒ Object (protected)

Receives a set of options and print them.



564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
 
# File 'lib/thor/base/class_methods.rb', line 564

def print_options(shell, options, group_name = nil)
  return if options.empty?

  list = []
  padding = options.map { |o| o.aliases.size }.max.to_i * 4

  options.each do |option|
    next if option.hide
    item = [option.usage(padding)]
    item.push(option.description ? "# #{option.description}" : "")

    list << item
    list << ["", "# Default: #{option.default}"] if option.show_default?
    if option.enum
      list << ["", "# Possible values: #{option.enum.join(', ')}"]
    end
  end

  shell.say(group_name ? "#{group_name} options:" : "Options:")
  shell.print_table(list, :indent => 2)
  shell.say ""
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



473
474
475
476
477
 
# File 'lib/thor/base/class_methods.rb', line 473

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



262
263
264
265
266
267
268
269
 
# File 'lib/thor/base/class_methods.rb', line 262

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



282
283
284
285
286
 
# File 'lib/thor/base/class_methods.rb', line 282

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.



343
344
345
346
347
348
349
350
351
 
# File 'lib/thor/base/class_methods.rb', line 343

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)



429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
 
# File 'lib/thor/base/class_methods.rb', line 429

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

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


102
103
104
 
# File 'lib/thor/base/class_methods.rb', line 102

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

#strict_args_position ⇒ Object

:nodoc:



122
123
124
 
# File 'lib/thor/base/class_methods.rb', line 122

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.



117
118
119
 
# File 'lib/thor/base/class_methods.rb', line 117

def strict_args_position!
  @strict_args_position = true
end

#strict_args_position?(config) ⇒ Boolean

:nodoc:

Returns:

  • (Boolean) 


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

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