module Thor::Base::ClassMethods

def all_tasks
  @all_tasks ||= from_superclass(:all_tasks, Thor::CoreExt::OrderedHash.new)
  @all_tasks.merge(tasks)
end

def argument(name, options={})
  is_thor_reserved_word?(name, :argument)
  no_tasks { attr_accessor name }
  required = if options.key?(:optional)
    !options[:optional]
  elsif options.key?(:required)
    options[:required]
  else
    options[:default].nil?
  end
  remove_argument name
  arguments.each do |argument|
    next if argument.required?
    raise ArgumentError, "You cannot have #{name.to_s.inspect} as required argument after " <<
                         "the non-required argument #{argument.human_name.inspect}."
  end if required
  arguments << Thor::Argument.new(name, options[:desc], required, options[:type],
                                        options[:default], options[:banner])
end

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

def baseclass #:nodoc:
end

def build_option(name, options, scope) #:nodoc:
  scope[name] = Thor::Option.new(name, options[:desc], options[:required],
                                       options[:type], options[:default], options[:banner],
                                       options[:group], options[:aliases])
end

def build_options(options, scope) #:nodoc:
  options.each do |key, value|
    scope[key] = Thor::Option.parse(key, value)
  end
end

def class_option(name, options={})
  build_option(name, options, class_options)
end

def class_options(options=nil)
  @class_options ||= from_superclass(:class_options, {})
  build_options(options, @class_options) if options
  @class_options
end

def class_options_help(shell, ungrouped_name=nil, extra_group=nil) #:nodoc:
  groups = {}
  class_options.each do |_, value|
    groups[value.group] ||= []
    groups[value.group] << value
  end
  printer = proc do |group_name, options|
    list = []
    padding = options.collect{ |o| o.aliases.size  }.max.to_i * 4
    options.each do |option|
      item = [ option.usage(padding) ]
      item.push(option.description ? "# #{option.description}" : "")
      list << item
      list << [ "", "# Default: #{option.default}" ] if option.show_default?
    end
    unless list.empty?
      shell.say(group_name ? "#{group_name} options:" : "Options:")
      shell.print_table(list, :ident => 2)
      shell.say ""
    end
  end
  # Deal with default group
  global_options = groups.delete(nil) || []
  printer.call(ungrouped_name, global_options) if global_options
  # Print all others
  groups = extra_group.merge(groups) if extra_group
  groups.each(&printer)
  printer
end

def create_task(meth) #:nodoc:
end

def exit_on_failure?
  false
end

def find_and_refresh_task(name) #:nodoc:
  task = if task = tasks[name.to_s]
    task
  elsif task = all_tasks[name.to_s]
    tasks[name.to_s] = task.clone
  else
    raise ArgumentError, "You supplied :for => #{name.inspect}, but the task #{name.inspect} could not be found."
  end
end

def from_superclass(method, default=nil)
  if self == baseclass || !superclass.respond_to?(method, true)
    default
  else
    value = superclass.send(method)
    value.dup if value
  end
end

def group(name=nil)
  case name
    when nil
      @group ||= from_superclass(:group, 'standard')
    else
      @group = name.to_s
  end
end

def inherited(klass)
  Thor::Base.register_klass_file(klass)
end

def initialize_added #:nodoc:
end

def is_thor_reserved_word?(word, type) #:nodoc:
  return false unless THOR_RESERVED_WORDS.include?(word.to_s)
  raise "#{word.inspect} is a Thor reserved word and cannot be defined as #{type}"
end

def method_added(meth)
  meth = meth.to_s
  if meth == "initialize"
    initialize_added
    return
  end
  # Return if it's not a public instance method
  return unless public_instance_methods.include?(meth) ||
                public_instance_methods.include?(meth.to_sym)
  return if @no_tasks || !create_task(meth)
  is_thor_reserved_word?(meth, :task)
  Thor::Base.register_klass_file(self)
end

def namespace(name=nil)
  case name
    when nil
      @namespace ||= Thor::Util.namespace_from_thor_class(self, false)
    else
      @namespace = name.to_s
  end
end

def no_tasks
  @no_tasks = true
  yield
  @no_tasks = false
end

def remove_argument(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}
  names.each do |name|
    arguments.delete_if { |a| a.name == name.to_s }
    undef_method name, "#{name}=" if options[:undefine]
  end
end

def remove_class_option(*names)
  names.each do |name|
    class_options.delete(name)
  end
end

def remove_task(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}
  names.each do |name|
    tasks.delete(name.to_s)
    all_tasks.delete(name.to_s)
    undef_method name if options[:undefine]
  end
end

def start(given_args=ARGV, config={})
  config[:shell] ||= Thor::Base.shell.new
  yield
rescue Thor::Error => e
  if given_args.include?("--debug")
    raise e
  else
    config[:shell].error e.message
  end
  exit(1) if exit_on_failure?
end

def tasks
  @tasks ||= Thor::CoreExt::OrderedHash.new
end