class Thor::Group

def _invoke_for_class_method(klass, task=nil, *args, &block) #:nodoc:
  shell.padding += 1
  result = if block_given?
    if block.arity == 2
      block.call(self, klass)
    else
      block.call(self, klass, task)
    end
  else
    invoke klass, task, *args
  end
  shell.padding -= 1
  result
end

def banner
  "#{self.namespace} #{self.arguments.map {|a| a.usage }.join(' ')}"
end

def baseclass #:nodoc:
  Thor::Group
end

def class_options_help(shell, ungrouped_name=nil, extra_group=nil) #:nodoc:
  group_options = {}
  get_options_from_invocations(group_options, class_options) do |klass|
    klass.send(:get_options_from_invocations, group_options, class_options)
  end
  group_options.merge!(extra_group) if extra_group
  super(shell, ungrouped_name, group_options)
end

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

def desc(description=nil)
  case description
    when nil
      @desc ||= from_superclass(:desc, nil)
    else
      @desc = description
  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 |option|
      base_options[option.name.to_sym].nil? && option.group.nil? &&
      !group_options.values.flatten.any? { |i| i.name == option.name }
    end
    yield klass if block_given?
  end
end

def help(shell, options={})
  if options[:short]
    shell.say banner
  else
    shell.say "Usage:"
    shell.say "  #{banner}"
    shell.say
    class_options_help(shell)
    shell.say self.desc if self.desc
  end
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 remove_invocation(*names)
  names.each do |name|
    remove_task(name)
    remove_class_option(name)
    invocations.delete(name)
    invocation_blocks.delete(name)
  end
end

def start(given_args=ARGV, config={})
  super do
    if Thor::HELP_MAPPINGS.include?(given_args.first)
      help(config[:shell])
      return
    end
    args, opts = Thor::Options.split(given_args)
    new(args, opts, config).invoke
  end
end