module Bundler::Thor::Base

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