class Thor

def banner(task, namespace = nil, subcommand = false)


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, namespace = nil, subcommand = false)
  "#{basename} #{task.formatted_usage(self, $thor_runner, subcommand)}"
end

def baseclass #:nodoc:

:nodoc:
def baseclass #:nodoc:
  Thor
end

def check_unknown_options!(options={})

options: A hash containing :only and/or :except keys
=== Parameters

Extend check unknown options to accept a hash of conditions.
def check_unknown_options!(options={})
  @check_unknown_options ||= Hash.new
  options.each do |key, value|
    if value
      @check_unknown_options[key] = Array(value)
    else
      @check_unknown_options.delete(key)
    end
  end
  @check_unknown_options
end

def check_unknown_options?(config) #:nodoc:

:nodoc:
Overwrite check_unknown_options? to take subcommands and options into account.
def check_unknown_options?(config) #:nodoc:
  options = check_unknown_options
  return false unless options
  task = config[:current_task]
  return true unless task
  name = task.name
  if subcommands.include?(name)
    false
  elsif options[:except]
    !options[:except].include?(name.to_sym)
  elsif options[:only]
    options[:only].include?(name.to_sym)
  else
    true
  end
end

def create_task(meth) #:nodoc:

:nodoc:
def create_task(meth) #:nodoc:
  if @usage && @desc
    base_class = @hide ? Thor::HiddenTask : Thor::Task
    tasks[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
    @usage, @desc, @long_desc, @method_options, @hide = nil
    true
  elsif self.all_tasks[meth] || meth == "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:: name of the default task
==== 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={})


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, @hide = usage, description, options[:hide] || false
  end
end

def dispatch(meth, given_args, given_opts, config) #:nodoc:

:nodoc:
The method responsible for dispatching given the args.
def dispatch(meth, given_args, given_opts, config) #:nodoc:
  meth ||= retrieve_task_name(given_args)
  task = all_tasks[normalize_task_name(meth)]
  if task
    args, opts = Thor::Options.split(given_args)
  else
    args, opts = given_args, nil
    task = Thor::DynamicTask.new(meth)
  end
  opts = given_opts || opts || []
  config.merge!(:current_task => task, :task_options => task.options)
  instance = new(args, opts, config)
  yield instance if block_given?
  args = instance.args
  trailing = args[Range.new(arguments.size, -1)]
  instance.invoke_task(task, trailing || [])
end

def find_task_possibilities(meth)

alias name.
and determines whether it is an unambiguous prefix of a task or
this is the logic that takes the task name passed in by the user
def find_task_possibilities(meth)
  len = meth.to_s.length
  possibilities = all_tasks.merge(map).keys.select { |n| meth == n[0, len] }.sort
  unique_possibilities = possibilities.map { |k| map[k] || k }.uniq
  if possibilities.include?(meth)
    [meth]
  elsif unique_possibilities.size == 1
    unique_possibilities
  else
    possibilities
  end
end

def help(shell, subcommand = false)


shell
==== Parameters

Prints help information for this class.
def help(shell, subcommand = false)
  list = printable_tasks(true, subcommand)
  Thor::Util.thor_classes_in(self).each do |klass|
    list += klass.printable_tasks(false)
  end
  list.sort!{ |a,b| a[0] <=> b[0] }
  shell.say "Tasks:"
  shell.print_table(list, :indent => 2, :truncate => true)
  shell.say
  class_options_help(shell)
end

def help(task = nil, subcommand = false)

def help(task = nil, subcommand = false)
  task ? self.class.task_help(shell, task) : self.class.help(shell, subcommand)
end

def initialize_added #:nodoc:

:nodoc:
def initialize_added #:nodoc:
  class_options.merge!(method_options)
  @method_options = nil
end

def long_desc(long_description, options={})


long description
==== Parameters

Defines the long description of the next task.
def long_desc(long_description, options={})
  if options[:for]
    task = find_and_refresh_task(options[:for])
    task.long_description = long_description if long_description
  else
    @long_desc = long_description
  end
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={})


:hide - If you want to hide this option from the help.
: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:: Described below.
name:: The name of the argument.
==== 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:

:nodoc:
into +animal_prison+.
+normalize_task_name+ also converts names like +animal-prison+

a task or alias.
will determine if a shortened command is an unambiguous prefix of
the tasks hash. In addition to normalizing aliases, this logic
receives a (possibly nil) task name and returns a name that is in
def normalize_task_name(meth) #:nodoc:
  return default_task.to_s.gsub('-', '_') unless meth
  possibilities = find_task_possibilities(meth)
  if possibilities.size > 1
    raise ArgumentError, "Ambiguous task #{meth} matches [#{possibilities.join(', ')}]"
  elsif possibilities.size < 1
    meth = meth || default_task
  elsif map[meth]
    meth = map[meth]
  else
    meth = possibilities.first
  end
  meth.to_s.gsub('-','_') # treat foo-bar as foo_bar
end

def printable_tasks(all = true, subcommand = false)

Returns tasks ready to be printed.
def printable_tasks(all = true, subcommand = false)
  (all ? all_tasks : tasks).map do |_, task|
    next if task.hidden?
    item = []
    item << banner(task, false, subcommand)
    item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
    item
  end.compact
end

def register(klass, subcommand_name, usage, description, options={})

description:: Description for the subcommand
usage:: Short usage for the subcommand
command:: Subcommand name to use
klass:: Thor subclass to register
==== Parameters

Registers another Thor subclass as a command.
def register(klass, subcommand_name, usage, description, options={})
  if klass <= Thor::Group
    desc usage, description, options
    define_method(subcommand_name) { |*args| invoke(klass, args) }
  else
    desc usage, description, options
    subcommand subcommand_name, klass
  end
end

def retrieve_task_name(args) #:nodoc:

:nodoc:
Retrieve the task name from given args.
def retrieve_task_name(args) #:nodoc:
  meth = args.first.to_s unless args.empty?
  if meth && (map[meth] || meth !~ /^\-/)
    args.shift
  else
    nil
  end
end

def subcommand(subcommand, subcommand_class)

def subcommand(subcommand, subcommand_class)
  self.subcommands << subcommand.to_s
  subcommand_class.subcommand_help subcommand
  define_method(subcommand) do |*args|
    args, opts = Thor::Arguments.split(args)
    invoke subcommand_class, args, opts
  end
end

def subcommand_help(cmd)

def subcommand_help(cmd)
  desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
  class_eval <<-RUBY
    def help(task = nil, subcommand = true); super; end
  RUBY
end

def subcommands

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

def task_help(shell, task_name)


task_name
shell
==== Parameters

Prints help information for the given task.
def task_help(shell, task_name)
  meth = normalize_task_name(task_name)
  task = all_tasks[meth]
  handle_no_task_error(meth) unless task
  shell.say "Usage:"
  shell.say "  #{banner(task)}"
  shell.say
  class_options_help(shell, nil => task.options.map { |_, o| o })
  if task.long_description
    shell.say "Description:"
    shell.print_wrapped(task.long_description, :indent => 2)
  else
    shell.say task.description
  end
end