class Thor::Group

def _invoke_for_class_method(klass, task=nil, *args, &block) #:nodoc:
  with_padding do
    if block
      case block.arity
      when 3
        block.call(self, klass, task)
      when 2
        block.call(self, klass)
      when 1
        instance_exec(klass, &block)
      end
    else
      invoke klass, task, *args
    end
  end
end

def banner
  "#{basename} #{self_task.formatted_usage(self, false)}"
end

def baseclass #:nodoc:
  Thor::Group
end

def class_options_help(shell, groups={}) #:nodoc:
  get_options_from_invocations(groups, class_options) do |klass|
    klass.send(:get_options_from_invocations, groups, class_options)
  end
  super(shell, groups)
end

def create_task(meth) #:nodoc:
  tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil, nil)
  true
end

def desc(description=nil)
  case description
    when nil
      @desc ||= from_superclass(:desc, nil)
    else
      @desc = description
  end
end

def dispatch(task, given_args, given_opts, config) #:nodoc:
  if Thor::HELP_MAPPINGS.include?(given_args.first)
    help(config[:shell])
    return
  end
  args, opts = Thor::Options.split(given_args)
  opts = given_opts || opts
  instance = new(args, opts, config)
  yield instance if block_given?
  args = instance.args
  if task
    instance.invoke_task(all_tasks[task])
  else
    instance.invoke_all
  end
end

def get_options_from_invocations(group_options, base_options) #:nodoc:
  invocations.each do |name, from_option|
    value = if from_option
      option = class_options[name]
      option.type == :boolean ? name : option.default
    else
      name
    end
    next unless value
    klass, task = prepare_for_invocation(name, value)
    next unless klass && klass.respond_to?(:class_options)
    value = value.to_s
    human_name = value.respond_to?(:classify) ? value.classify : value
    group_options[human_name] ||= []
    group_options[human_name] += klass.class_options.values.select do |class_option|
      base_options[class_option.name.to_sym].nil? && class_option.group.nil? &&
      !group_options.values.flatten.any? { |i| i.name == class_option.name }
    end
    yield klass if block_given?
  end
end

def handle_argument_error(task, error, arity=nil) #:nodoc:
  if arity > 0
    msg = "#{basename} #{task.name} takes #{arity} argument"
    msg << "s" if arity > 1
    msg << ", but it should not."
  else
    msg = "You should not pass arguments to #{basename} #{task.name}."
  end
  raise error, msg
end

def help(shell)
  shell.say "Usage:"
  shell.say "  #{banner}\n"
  shell.say
  class_options_help(shell)
  shell.say self.desc if self.desc
end

def invocation_blocks #:nodoc:
  @invocation_blocks ||= from_superclass(:invocation_blocks, {})
end

def invocations #:nodoc:
  @invocations ||= from_superclass(:invocations, {})
end

def invoke(*names, &block)
  options = names.last.is_a?(Hash) ? names.pop : {}
  verbose = options.fetch(:verbose, true)
  names.each do |name|
    invocations[name] = false
    invocation_blocks[name] = block if block_given?
    class_eval <<-METHOD, __FILE__, __LINE__
      def _invoke_#{name.to_s.gsub(/\W/, '_')}
        klass, task = self.class.prepare_for_invocation(nil, #{name.inspect})
        if klass
          say_status :invoke, #{name.inspect}, #{verbose.inspect}
          block = self.class.invocation_blocks[#{name.inspect}]
          _invoke_for_class_method klass, task, &block
        else
          say_status :error, %(#{name.inspect} [not found]), :red
        end
      end
    METHOD
  end
end

def invoke_from_option(*names, &block)
  options = names.last.is_a?(Hash) ? names.pop : {}
  verbose = options.fetch(:verbose, :white)
  names.each do |name|
    unless class_options.key?(name)
      raise ArgumentError, "You have to define the option #{name.inspect} " <<
                           "before setting invoke_from_option."
    end
    invocations[name] = true
    invocation_blocks[name] = block if block_given?
    class_eval <<-METHOD, __FILE__, __LINE__
      def _invoke_from_option_#{name.to_s.gsub(/\W/, '_')}
        return unless options[#{name.inspect}]
        value = options[#{name.inspect}]
        value = #{name.inspect} if TrueClass === value
        klass, task = self.class.prepare_for_invocation(#{name.inspect}, value)
        if klass
          say_status :invoke, value, #{verbose.inspect}
          block = self.class.invocation_blocks[#{name.inspect}]
          _invoke_for_class_method klass, task, &block
        else
          say_status :error, %(\#{value} [not found]), :red
        end
      end
    METHOD
  end
end

def printable_tasks(*)
  item = []
  item << banner
  item << (desc ? "# #{desc.gsub(/\s+/m,' ')}" : "")
  [item]
end

def remove_invocation(*names)
  names.each do |name|
    remove_task(name)
    remove_class_option(name)
    invocations.delete(name)
    invocation_blocks.delete(name)
  end
end

def self_task #:nodoc:
  Thor::DynamicTask.new(self.namespace, class_options)
end