module Bundler::Thor::Base

def included(base) #:nodoc:
  base.extend ClassMethods
  base.send :include, Invocation
  base.send :include, Shell
end

def initialize(args = [], local_options = {}, config = {}) # rubocop:disable MethodLength
  parse_options = self.class.class_options
  # The start method splits inbound arguments at the first argument
  # that looks like an option (starts with - or --). It then calls
  # new, passing in the two halves of the arguments Array as the
  # first two parameters.
  command_options = config.delete(:command_options) # hook for start
  parse_options = parse_options.merge(command_options) if command_options
  if local_options.is_a?(Array)
    array_options, hash_options = local_options, {}
  else
    # Handle the case where the class was explicitly instantiated
    # with pre-parsed options.
    array_options, hash_options = [], local_options
  end
  # Let Bundler::Thor::Options parse the options first, so it can remove
  # declared options from the array. This will leave us with
  # a list of arguments that weren't declared.
  stop_on_unknown = self.class.stop_on_unknown_option? config[:current_command]
  opts = Bundler::Thor::Options.new(parse_options, hash_options, stop_on_unknown)
  self.options = opts.parse(array_options)
  self.options = config[:class_options].merge(options) if config[:class_options]
  # If unknown options are disallowed, make sure that none of the
  # remaining arguments looks like an option.
  opts.check_unknown! if self.class.check_unknown_options?(config)
  # Add the remaining arguments from the options parser to the
  # arguments passed in to initialize. Then remove any positional
  # arguments declared using #argument (this is primarily used
  # by Bundler::Thor::Group). Tis will leave us with the remaining
  # positional arguments.
  to_parse  = args
  to_parse += opts.remaining unless self.class.strict_args_position?(config)
  thor_args = Bundler::Thor::Arguments.new(self.class.arguments)
  thor_args.parse(to_parse).each { |k, v| __send__("#{k}=", v) }
  @args = thor_args.remaining
end

def register_klass_file(klass) #:nodoc:
  file = caller[1].match(/(.*):\d+/)[1]
  Bundler::Thor::Base.subclasses << klass unless Bundler::Thor::Base.subclasses.include?(klass)
  file_subclasses = Bundler::Thor::Base.subclass_files[File.expand_path(file)]
  file_subclasses << klass unless file_subclasses.include?(klass)
end

def shell
  @shell ||= if ENV["THOR_SHELL"] && ENV["THOR_SHELL"].size > 0
    Bundler::Thor::Shell.const_get(ENV["THOR_SHELL"])
  elsif RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ && !ENV["ANSICON"]
    Bundler::Thor::Shell::Basic
  else
    Bundler::Thor::Shell::Color
  end
end

def subclass_files
  @subclass_files ||= Hash.new { |h, k| h[k] = [] }
end

def subclasses
  @subclasses ||= []
end