module Bundler::Thor::Base::ClassMethods

def all_commands
  @all_commands ||= from_superclass(:all_commands, Bundler::Thor::CoreExt::OrderedHash.new)
  @all_commands.merge(commands)
end

def argument(name, options = {}) # rubocop:disable MethodLength
  is_thor_reserved_word?(name, :argument)
  no_commands { 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?
    fail ArgumentError, "You cannot have #{name.to_s.inspect} as required argument after " <<
                         "the non-required argument #{argument.human_name.inspect}."
  end if required
  options[:required] = required
  arguments << Bundler::Thor::Argument.new(name, options)
end

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

def attr_accessor(*) #:nodoc:
  no_commands { super }
end

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

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

def baseclass #:nodoc:
end

def basename
  File.basename($PROGRAM_NAME).split(" ").first
end

def build_option(name, options, scope) #:nodoc:
  scope[name] = Bundler::Thor::Option.new(name, options)
end

def build_options(options, scope) #:nodoc:
  options.each do |key, value|
    scope[key] = Bundler::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 commands
  @commands ||= Bundler::Thor::CoreExt::OrderedHash.new
end

def create_command(meth) #:nodoc:
end

def dispatch(command, given_args, given_opts, config) #:nodoc:
  fail NotImplementedError
end

def exit_on_failure?
  false
end

def find_and_refresh_command(name) #:nodoc:
  if commands[name.to_s]
    commands[name.to_s]
  elsif command = all_commands[name.to_s] # rubocop:disable AssignmentInCondition
    commands[name.to_s] = command.clone
  else
    fail ArgumentError, "You supplied :for => #{name.inspect}, but the command #{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)
    # Ruby implements `dup` on Object, but raises a `TypeError`
    # if the method is called on immediates. As a result, we
    # don't have a good way to check whether dup will succeed
    # without calling it and rescuing the TypeError.
    begin
      value.dup
    rescue TypeError
      value
    end
  end
end

def group(name = nil)
  if name
    @group = name.to_s
  else
    @group ||= from_superclass(:group, "standard")
  end
end

def handle_argument_error(command, error, args, arity) #:nodoc:
  msg = "ERROR: \"#{basename} #{command.name}\" was called with "
  msg << "no arguments"               if     args.empty?
  msg << "arguments " << args.inspect unless args.empty?
  msg << "\nUsage: #{banner(command).inspect}"
  fail InvocationError, msg
end

def handle_no_command_error(command, has_namespace = $thor_runner) #:nodoc:
  if has_namespace
    fail UndefinedCommandError, "Could not find command #{command.inspect} in #{namespace.inspect} namespace."
  else
    fail UndefinedCommandError, "Could not find command #{command.inspect}."
  end
end

def inherited(klass)
  Bundler::Thor::Base.register_klass_file(klass)
  klass.instance_variable_set(:@no_commands, false)
end

def initialize_added #:nodoc:
end

def is_thor_reserved_word?(word, type) #:nodoc:
  return false unless THOR_RESERVED_WORDS.include?(word.to_s)
  fail "#{word.inspect} is a Bundler::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_method_defined?(meth.to_sym)
  @no_commands ||= false
  return if @no_commands || !create_command(meth)
  is_thor_reserved_word?(meth, :command)
  Bundler::Thor::Base.register_klass_file(self)
end

def namespace(name = nil)
  if name
    @namespace = name.to_s
  else
    @namespace ||= Bundler::Thor::Util.namespace_from_thor_class(self)
  end
end

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

def print_options(shell, options, group_name = nil)
  return if options.empty?
  list = []
  padding = options.map { |o| o.aliases.size }.max.to_i * 4
  options.each do |option|
    unless option.hide
      item = [option.usage(padding)]
      item.push(option.description ? "# #{option.description}" : "")
      list << item
      list << ["", "# Default: #{option.default}"] if option.show_default?
      list << ["", "# Possible values: #{option.enum.join(', ')}"] if option.enum
    end
  end
  shell.say(group_name ? "#{group_name} options:" : "Options:")
  shell.print_table(list, :indent => 2)
  shell.say ""
end

def public_command(*names)
  names.each do |name|
    class_eval "def #{name}(*); super end"
  end
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_command(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}
  names.each do |name|
    commands.delete(name.to_s)
    all_commands.delete(name.to_s)
    undef_method name if options[:undefine]
  end
end

def start(given_args = ARGV, config = {})
  config[:shell] ||= Bundler::Thor::Base.shell.new
  dispatch(nil, given_args.dup, nil, config)
rescue Bundler::Thor::Error => e
  config[:debug] || ENV["THOR_DEBUG"] == "1" ? (raise e) : config[:shell].error(e.message)
  exit(1) if exit_on_failure?
rescue Errno::EPIPE
  # This happens if a thor command is piped to something like `head`,
  # which closes the pipe when it's done reading. This will also
  # mean that if the pipe is closed, further unnecessary
  # computation will not occur.
  exit(0)
end

def stop_on_unknown_option?(command_name) #:nodoc:
  false
end

def strict_args_position #:nodoc:
  @strict_args_position ||= from_superclass(:strict_args_position, false)
end

def strict_args_position!
  @strict_args_position = true
end

def strict_args_position?(config) #:nodoc:
  !!strict_args_position
end