Returns the tasks for this Thor class and all subclasses.
OrderedHash | An ordered hash with tasks names as keys and Thor::Task objects as values. |
# File lib/bundler/vendor/thor/base.rb, line 294 294: def all_tasks 295: @all_tasks ||= from_superclass(:all_tasks, Thor::CoreExt::OrderedHash.new) 296: @all_tasks.merge(tasks) 297: 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 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.
name | The name of the argument. |
options | Described below. |
: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.
ArgumentError | Raised if you supply a required argument after a non required one. |
# File lib/bundler/vendor/thor/base.rb, line 160 160: def argument(name, options={}) 161: is_thor_reserved_word?(name, :argument) 162: no_tasks { attr_accessor name } 163: 164: required = if options.key?(:optional) 165: !options[:optional] 166: elsif options.key?(:required) 167: options[:required] 168: else 169: options[:default].nil? 170: end 171: 172: remove_argument name 173: 174: arguments.each do |argument| 175: next if argument.required? 176: raise ArgumentError, "You cannot have #{name.to_s.inspect} as required argument after " << 177: "the non-required argument #{argument.human_name.inspect}." 178: end if required 179: 180: arguments << Thor::Argument.new(name, options[:desc], required, options[:type], 181: options[:default], options[:banner]) 182: end
Returns this class arguments, looking up in the ancestors chain.
Array[Thor::Argument]
# File lib/bundler/vendor/thor/base.rb, line 189 189: def arguments 190: @arguments ||= from_superclass(:arguments, []) 191: 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/bundler/vendor/thor/base.rb, line 113 113: def check_unknown_options! 114: @check_unknown_options = true 115: end
Adds an option to the set of class options
name | The name of the argument. |
options | Described below. |
: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. :type - The type of the argument, can be :string, :hash, :array, :numeric or :boolean. :banner - String to show on usage notes.
# File lib/bundler/vendor/thor/base.rb, line 223 223: def class_option(name, options={}) 224: build_option(name, options, class_options) 225: 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.
Hash[Symbol => Object]
# File lib/bundler/vendor/thor/base.rb, line 202 202: def class_options(options=nil) 203: @class_options ||= from_superclass(:class_options, {}) 204: build_options(options, @class_options) if options 205: @class_options 206: end
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.
name
# File lib/bundler/vendor/thor/base.rb, line 269 269: def group(name=nil) 270: case name 271: when nil 272: @group ||= from_superclass(:group, 'standard') 273: else 274: @group = name.to_s 275: end 276: 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 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
# File lib/bundler/vendor/thor/base.rb, line 369 369: def namespace(name=nil) 370: case name 371: when nil 372: @namespace ||= Thor::Util.namespace_from_thor_class(self) 373: else 374: @namespace = name.to_s 375: end 376: end
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
# File lib/bundler/vendor/thor/base.rb, line 340 340: def no_tasks 341: @no_tasks = true 342: yield 343: ensure 344: @no_tasks = false 345: end
Removes a previous defined argument. If :undefine is given, undefine accessors as well.
names | Arguments to be removed |
remove_argument :foo remove_argument :foo, :bar, :baz, :undefine => true
# File lib/bundler/vendor/thor/base.rb, line 238 238: def remove_argument(*names) 239: options = names.last.is_a?(Hash) ? names.pop : {} 240: 241: names.each do |name| 242: arguments.delete_if { |a| a.name == name.to_s } 243: undef_method name, "#{name}=" if options[:undefine] 244: end 245: end
Removes a previous defined class option.
names | Class options to be removed |
remove_class_option :foo remove_class_option :foo, :bar, :baz
# File lib/bundler/vendor/thor/base.rb, line 257 257: def remove_class_option(*names) 258: names.each do |name| 259: class_options.delete(name) 260: end 261: end
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.
name | The name of the task to be removed |
options | You can give :undefine => true if you want tasks the method to be undefined from the class as well. |
# File lib/bundler/vendor/thor/base.rb, line 311 311: def remove_task(*names) 312: options = names.last.is_a?(Hash) ? names.pop : {} 313: 314: names.each do |name| 315: tasks.delete(name.to_s) 316: all_tasks.delete(name.to_s) 317: undef_method name if options[:undefine] 318: end 319: end
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)
# File lib/bundler/vendor/thor/base.rb, line 386 386: def start(given_args=ARGV, config={}) 387: self.debugging = given_args.delete("--debug") 388: config[:shell] ||= Thor::Base.shell.new 389: dispatch(nil, given_args.dup, nil, config) 390: rescue Thor::Error => e 391: debugging ? (raise e) : config[:shell].error(e.message) 392: exit(1) if exit_on_failure? 393: end
Returns the tasks for this Thor class.
OrderedHash | An ordered hash with tasks names as keys and Thor::Task objects as values. |
# File lib/bundler/vendor/thor/base.rb, line 284 284: def tasks 285: @tasks ||= Thor::CoreExt::OrderedHash.new 286: end
A flag that makes the process exit with status 1 if any error happens.
# File lib/bundler/vendor/thor/base.rb, line 530 530: def exit_on_failure? 531: false 532: end
Retrieves a value from superclass. If it reaches the baseclass, returns default.
# File lib/bundler/vendor/thor/base.rb, line 520 520: def from_superclass(method, default=nil) 521: if self == baseclass || !superclass.respond_to?(method, true) 522: default 523: else 524: value = superclass.send(method) 525: value.dup if value 526: end 527: end
Everytime someone inherits from a Thor class, register the klass and file into baseclass.
# File lib/bundler/vendor/thor/base.rb, line 494 494: def inherited(klass) 495: Thor::Base.register_klass_file(klass) 496: end
Fire this callback whenever a method is added. Added methods are tracked as tasks by invoking the create_task method.
# File lib/bundler/vendor/thor/base.rb, line 500 500: def method_added(meth) 501: meth = meth.to_s 502: 503: if meth == "initialize" 504: initialize_added 505: return 506: end 507: 508: # Return if it's not a public instance method 509: return unless public_instance_methods.include?(meth) || 510: public_instance_methods.include?(meth.to_sym) 511: 512: return if @no_tasks || !create_task(meth) 513: 514: is_thor_reserved_word?(meth, :task) 515: Thor::Base.register_klass_file(self) 516: end
Receives a set of options and print them.
# File lib/bundler/vendor/thor/base.rb, line 430 430: def print_options(shell, options, group_name=nil) 431: return if options.empty? 432: 433: list = [] 434: padding = options.collect{ |o| o.aliases.size }.max.to_i * 4 435: 436: options.each do |option| 437: item = [ option.usage(padding) ] 438: item.push(option.description ? "# #{option.description}" : "") 439: 440: list << item 441: list << [ "", "# Default: #{option.default}" ] if option.show_default? 442: end 443: 444: shell.say(group_name ? "#{group_name} options:" : "Options:") 445: shell.print_table(list, :ident => 2) 446: shell.say "" 447: end
Disabled; run with --debug to generate this.
Generated with the Darkfish Rdoc Generator 1.1.6.