class Thor

def banner(task, namespace = nil, subcommand = false)
  "#{$0} #{task.formatted_usage(self, $thor_runner, subcommand)}"
end

def baseclass #:nodoc:
  Thor
end

def create_task(meth) #:nodoc:
  if @usage && @desc
    base_class = @hide ? Thor::HiddenTask : Thor::Task
    tasks[meth.to_s] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
    @usage, @desc, @long_desc, @method_options, @hide = 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)
  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={})
  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 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, :ident => 2, :truncate => true)
  shell.say
  class_options_help(shell)
end

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

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

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)
  @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={})
  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)
  @method_options ||= {}
  build_options(options, @method_options) if options
  @method_options
end

def normalize_task_name(meth) #:nodoc:
  meth = map[meth.to_s] || meth || default_task
  meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
end

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 start(original_args=ARGV, config={})
  @@original_args = original_args
  super do |given_args|
    meth = given_args.first.to_s
    if !meth.empty? && (map[meth] || meth !~ /^\-/)
      given_args.shift
    else
      meth = nil
    end
    meth = normalize_task_name(meth)
    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::DynamicTask.new(meth)
    trailing = args[Range.new(arguments.size, -1)]
    new(args, opts, config).invoke(task, trailing || [])
  end
end

def subcommand(subcommand, subcommand_class)
  subcommand = subcommand.to_s
  subcommands[subcommand] = subcommand_class
  subcommand_class.subcommand_help subcommand
  define_method(subcommand) { |*_| subcommand_class.start(subcommand_args) }
end

def subcommand_args
  @@original_args[1..-1]
end

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
  @@subcommands ||= {}
end

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, :ident => 2)
  else
    shell.say task.description
  end
end