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 attr_accessor(*) #:nodoc:
  no_tasks { super }
end

def attr_reader(*) #:nodoc:
  no_tasks { super }
end

def attr_writer(*) #:nodoc:
  no_tasks { super }
end

def baseclass #:nodoc:
end

def basename
  File.basename($0).split(' ').first
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[:lazy_default], 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 check_unknown_options #:nodoc:
  @check_unknown_options ||= from_superclass(:check_unknown_options, false)
end

def check_unknown_options!
  @check_unknown_options = true
end

def check_unknown_options?(config) #:nodoc:
  !!check_unknown_options
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, groups={}) #:nodoc:
  # Group options by group
  class_options.each do |_, value|
    groups[value.group] ||= []
    groups[value.group] << value
  end
  # Deal with default group
  global_options = groups.delete(nil) || []
  print_options(shell, global_options)
  # Print all others
  groups.each do |group_name, options|
    print_options(shell, options, group_name)
  end
end

def create_task(meth) #:nodoc:
end

def dispatch(task, given_args, given_opts, config) #:nodoc:
  raise NotImplementedError
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 handle_argument_error(task, error) #:nodoc:
  raise InvocationError, "#{task.name.inspect} was called incorrectly. Call as #{self.banner(task).inspect}."
end

def handle_no_task_error(task) #:nodoc:
  if $thor_runner
    raise UndefinedTaskError, "Could not find task #{task.inspect} in #{namespace.inspect} namespace."
  else
    raise UndefinedTaskError, "Could not find task #{task.inspect}."
  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)
  else
    @namespace = name.to_s
  end
end

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

def print_options(shell, options, group_name=nil)
  return if options.empty?
  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
  shell.say(group_name ? "#{group_name} options:" : "Options:")
  shell.print_table(list, :ident => 2)
  shell.say ""
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={})
  self.debugging = given_args.delete("--debug")
  config[:shell] ||= Thor::Base.shell.new
  dispatch(nil, given_args.dup, nil, config)
rescue Thor::Error => e
  debugging ? (raise e) : config[:shell].error(e.message)
  exit(1) if exit_on_failure?
end

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