class Thor
def banner(task)
the namespace should be displayed as arguments.
the task that is going to be invoked and a boolean which indicates if
thor class by another ways which is not the Thor::Runner. It receives
The banner for this class. You can customize it if you are invoking the
def banner(task) "thor " + task.formatted_usage(self) end
def baseclass #:nodoc:
def baseclass #:nodoc: Thor end
def create_task(meth) #:nodoc:
def create_task(meth) #:nodoc: if @usage && @desc tasks[meth.to_s] = Thor::Task.new(meth, @desc, @usage, method_options) @usage, @desc, @method_options = nil true elsif self.all_tasks[meth.to_s] || meth.to_sym == :method_missing true else puts "[WARNING] Attempted to create task #{meth.inspect} without usage or description. " << "Call desc if you want this method to be available as task or declare it inside a " << "no_tasks{} block. Invoked from #{caller[1].inspect}." false end end
def default_task(meth=nil)
meth
==== Parameters
Sets the default task when thor is executed without an explicit task to be called.
def default_task(meth=nil) case meth when :none @default_task = 'help' when nil @default_task ||= from_superclass(:default_task, 'help') else @default_task = meth.to_s end end
def desc(usage, description, options={})
description
usage
==== Parameters
Defines the usage and the description of the next task.
def desc(usage, description, options={}) if options[:for] task = find_and_refresh_task(options[:for]) task.usage = usage if usage task.description = description if description else @usage, @desc = usage, description end end
def help(shell, options={})
skip_inherited:: When true, does not show tasks from superclass.
namespace:: When true, shows the namespace in the output before the usage.
==== Options
meth
==== Parameters
only about the specific task.
Prints help information. If a task name is given, it shows information
def help(shell, options={}) if options[:task] task = all_tasks[options[:task]] raise UndefinedTaskError, "task '#{options[:task]}' could not be found in namespace '#{self.namespace}'" unless task shell.say "Usage:" shell.say " #{banner(task)}" shell.say class_options_help(shell, nil => task.options.map { |_, o| o }) shell.say task.description else list = printable_tasks(!options[:short]) Thor::Util.thor_classes_in(self).each do |klass| list += klass.printable_tasks(false) end list.sort!{ |a,b| a[0] <=> b[0] } if options[:short] shell.print_table(list, :truncate => true) else shell.say "Tasks:" shell.print_table(list, :ident => 2, :truncate => true) shell.say class_options_help(shell) end end end
def help(task=nil)
def help(task=nil) self.class.help(shell, :task => task) end
def initialize_added #:nodoc:
def initialize_added #:nodoc: class_options.merge!(method_options) @method_options = nil end
def map(mappings=nil)
Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given task.
==== Parameters
Will invoke the list task.
thor -T
Running:
map "-T" => "list"
Maps an input to a task. If you define:
def map(mappings=nil) @map ||= from_superclass(:map, {}) if mappings mappings.each do |key, value| if key.respond_to?(:each) key.each {|subkey| @map[subkey] = value} else @map[key] = value end end end @map end
def method_option(name, options={})
:banner - String to show on usage notes.
:type - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
:aliases - Aliases for this option.
:default - Default value for this argument. It cannot be required and have default values.
:required - If the argument is required or not.
:desc - Description for the argument.
==== Options
options
name
==== Parameters
end
# magic
def next_task
method_option :foo => :bar, :for => :previous_task
end
# magic
def previous_task
it allows you to change the options from a previous defined task.
Adds an option to the set of method options. If :for is given as option,
def method_option(name, options={}) scope = if options[:for] find_and_refresh_task(options[:for]).options else method_options end build_option(name, options, scope) end
def method_options(options=nil)
or :required (string). If you give a value, the type of the value is used.
is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
Hash[Symbol => Object]:: The hash key is the name of the option and the value
==== Parameters
Declares the options for the next task to be declared.
def method_options(options=nil) @method_options ||= {} build_options(options, @method_options) if options @method_options end
def normalize_task_name(meth) #:nodoc:
If a map can't be found use the sent name or the default task.
Receives a task name (can be nil), and try to get a map from it.
def normalize_task_name(meth) #:nodoc: mapping = map[meth.to_s] meth = mapping || meth || default_task meth.to_s.gsub('-','_') # treat foo-bar > foo_bar end
def printable_tasks(all=true)
def printable_tasks(all=true) (all ? all_tasks : tasks).map do |_, task| item = [] item << banner(task) item << "# #{task.description}" if task.description item end end
def start(given_args=ARGV, config={})
script.invoke(:task, first_arg, second_arg, third_arg)
script = MyScript.new(args, options, config)
can simply initialize it:
from an array. If you are inside Ruby and want to use a Thor class, you
and invoke the task. This method is used when the arguments must be parsed
Parses the task and options from the given args, instantiate the class
def start(given_args=ARGV, config={}) super do meth = normalize_task_name(given_args.shift) task = all_tasks[meth] if task args, opts = Thor::Options.split(given_args) config.merge!(:task_options => task.options) else args, opts = given_args, {} end task ||= Thor::Task::Dynamic.new(meth) trailing = args[Range.new(arguments.size, -1)] new(args, opts, config).invoke(task, trailing || []) end end