# optparse.py

# CLI options parser.

#

# Copyright (C) 2014-2016 Red Hat, Inc.

#

# This copyrighted material is made available to anyone wishing to use,

# modify, copy, or redistribute it subject to the terms and conditions of

# the GNU General Public License v.2, or (at your option) any later version.

# This program is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY expressed or implied, including the implied warranties of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General

# Public License for more details.  You should have received a copy of the

# GNU General Public License along with this program; if not, write to the

# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the

# source code or documentation are not subject to the GNU General Public

# License and may only be used or replicated with the express permission of

# Red Hat, Inc.

#

from __future__ import unicode_literals

from dnf.i18n import _

from dnf.util import _parse_specs

import argparse

import dnf.exceptions

import dnf.util

import dnf.rpm

import dnf.yum.misc

import logging

import os.path

import re

import sys

logger = logging.getLogger("dnf")

class MultilineHelpFormatter(argparse.HelpFormatter):

    def _split_lines(self, text, width):

        if '\n' in text:

            return text.splitlines()

        return super(MultilineHelpFormatter, self)._split_lines(text, width)

class OptionParser(argparse.ArgumentParser):

    """ArgumentParser like class to do things the "yum way"."""

    def __init__(self, reset_usage=True):

        super(OptionParser, self).__init__(add_help=False,

                                           formatter_class=MultilineHelpFormatter)

        self.command_positional_parser = None

        self.command_group = None

        self._add_general_options()

        if reset_usage:

            self._cmd_usage = {}      # names, summary for dnf commands, to build usage

            self._cmd_groups = set()  # cmd groups added (main, plugin)

    def error(self, msg):

        """Output an error message, and exit the program.

           This method overrides standard argparser's error

           so that error output goes to the logger.

        :param msg: the error message to output

        """

        self.print_usage()

        logger.critical(_("Command line error: %s"), msg)

        sys.exit(1)

    class _RepoCallback(argparse.Action):

        def __call__(self, parser, namespace, values, opt_str):

            operation = 'disable' if opt_str == '--disablerepo' else 'enable'

            l = getattr(namespace, self.dest)

            l.extend((x, operation) for x in re.split(r'\s*[,\s]\s*', values))

    class _RepoCallbackEnable(argparse.Action):

        def __call__(self, parser, namespace, values, opt_str):

            namespace.repos_ed.append((values[0], 'enable'))

            setattr(namespace, 'reponame', values)

    class _SplitCallback(argparse._AppendAction):

        """ Split all strings in seq, at "," and whitespace.

        Returns a new list. """

        SPLITTER = r'\s*[,\s]\s*'

        def __call__(self, parser, namespace, values, opt_str):

            first = True

            for val in re.split(self.SPLITTER, values):

                if first or val:

                    # Empty values are sometimes used to clear existing content of the option.

                    # Only the first value in the parsed string can be empty. Other empty values

                    # are ignored.

                    super(OptionParser._SplitCallback,

                          self).__call__(parser, namespace, val, opt_str)

                first = False

    class _SplitExtendDictCallback(argparse.Action):

        """ Split string at "," or whitespace to (key, value).

        Extends dict with {key: value}."""

        def __call__(self, parser, namespace, values, opt_str):

            try:

                key, val = values.split(',')

                if not key or not val:

                    raise ValueError

            except ValueError:

                msg = _('bad format: %s') % values

                raise argparse.ArgumentError(self, msg)

            dct = getattr(namespace, self.dest)

            dct[key] = val

    class _SetoptsCallback(argparse.Action):

        """ Parse setopts arguments and put them into main_<setopts>

            and repo_<setopts>."""

        def __call__(self, parser, namespace, values, opt_str):

            vals = values.split('=')

            if len(vals) > 2:

                logger.warning(_("Setopt argument has multiple values: %s"), values)

                return

            if len(vals) < 2:

                logger.warning(_("Setopt argument has no value: %s"), values)

                return

            k, v = vals

            period = k.rfind('.')

            if period != -1:

                repo = k[:period]

                k = k[period+1:]

                if hasattr(namespace, 'repo_setopts'):

                    repoopts = namespace.repo_setopts

                else:

                    repoopts = {}

                repoopts.setdefault(repo, {}).setdefault(k, []).append(v)

                setattr(namespace, 'repo_' + self.dest, repoopts)

            else:

                if hasattr(namespace, 'main_setopts'):

                    mainopts = namespace.main_setopts

                else:

                    mainopts = {}

                mainopts.setdefault(k, []).append(v)

                setattr(namespace, 'main_' + self.dest, mainopts)

    class ParseSpecGroupFileCallback(argparse.Action):

        def __call__(self, parser, namespace, values, opt_str):

            _parse_specs(namespace, values)

    class PkgNarrowCallback(argparse.Action):

        def __init__(self, *args, **kwargs):

            self.pkgnarrow = {}

            try:

                for k in ['choices', 'default']:

                    self.pkgnarrow[k] = kwargs[k]

                    del kwargs[k]

            except KeyError as e:

                raise TypeError("%s() missing mandatory argument %s"

                                % (self.__class__.__name__, e))

            kwargs['default'] = []

            super(OptionParser.PkgNarrowCallback, self).__init__(*args, **kwargs)

        def __call__(self, parser, namespace, values, opt_str):

            dest_action = self.dest + '_action'

            if not values or values[0] not in self.pkgnarrow['choices']:

                narrow = self.pkgnarrow['default']

            else:

                narrow = values.pop(0)

            setattr(namespace, dest_action, narrow)

            setattr(namespace, self.dest, values)

    class ForceArchAction(argparse.Action):

        def __call__(self, parser, namespace, values, opt_str):

            namespace.ignorearch = True

            namespace.arch = values

    def _add_general_options(self):

        """ Standard options known to all dnf subcommands. """

        # All defaults need to be a None, so we can always tell whether the user

        # has set something or whether we are getting a default.

        general_grp = self.add_argument_group(_('General {prog} options'.format(

            prog=dnf.util.MAIN_PROG_UPPER)))

        general_grp.add_argument("-c", "--config", dest="config_file_path",

                                 default=None, metavar='[config file]',

                                 help=_("config file location"))

        general_grp.add_argument("-q", "--quiet", dest="quiet",

                                 action="store_true", default=None,

                                 help=_("quiet operation"))

        general_grp.add_argument("-v", "--verbose", action="store_true",

                                 default=None, help=_("verbose operation"))

        general_grp.add_argument("--version", action="store_true", default=None,

                                 help=_("show {prog} version and exit").format(

                                     prog=dnf.util.MAIN_PROG_UPPER))

        general_grp.add_argument("--installroot", help=_("set install root"),

                                 metavar='[path]')

        general_grp.add_argument("--nodocs", action="store_const", const=['nodocs'], dest='tsflags',

                                 help=_("do not install documentations"))

        general_grp.add_argument("--noplugins", action="store_false",

                                 default=None, dest='plugins',

                                 help=_("disable all plugins"))

        general_grp.add_argument("--enableplugin", dest="enableplugin",

                                 default=[], action=self._SplitCallback,

                                 help=_("enable plugins by name"),

                                 metavar='[plugin]')

        general_grp.add_argument("--disableplugin", dest="disableplugin",

                                 default=[], action=self._SplitCallback,

                                 help=_("disable plugins by name"),

                                 metavar='[plugin]')

        general_grp.add_argument("--releasever", default=None,

                                 help=_("override the value of $releasever"

                                        " in config and repo files"))

        general_grp.add_argument("--setopt", dest="setopts", default=[],

                                 action=self._SetoptsCallback,

                                 help=_("set arbitrary config and repo options"))

        general_grp.add_argument("--skip-broken", dest="skip_broken", action="store_true",

                                 default=None,

                                 help=_("resolve depsolve problems by skipping packages"))

        general_grp.add_argument('-h', '--help', '--help-cmd',

                                 action="store_true", dest='help',

                                 help=_("show command help"))

        general_grp.add_argument('--allowerasing', action='store_true',

                                 default=None,

                                 help=_('allow erasing of installed packages to '

                                        'resolve dependencies'))

        best_group = general_grp.add_mutually_exclusive_group()

        best_group.add_argument("-b", "--best", action="store_true", dest='best', default=None,

                                help=_("try the best available package versions in transactions."))

        best_group.add_argument("--nobest", action="store_false", dest='best',

                                help=_("do not limit the transaction to the best candidate"))

        general_grp.add_argument("-C", "--cacheonly", dest="cacheonly",

                                 action="store_true", default=None,

                                 help=_("run entirely from system cache, "

                                        "don't update cache"))

        general_grp.add_argument("-R", "--randomwait", dest="sleeptime", type=int,

                                 default=None, metavar='[minutes]',

                                 help=_("maximum command wait time"))

        general_grp.add_argument("-d", "--debuglevel", dest="debuglevel",

                                 metavar='[debug level]', default=None,

                                 help=_("debugging output level"), type=int)

        general_grp.add_argument("--debugsolver",

                                 action="store_true", default=None,

                                 help=_("dumps detailed solving results into"

                                        " files"))

        general_grp.add_argument("--showduplicates", dest="showdupesfromrepos",

                                 action="store_true", default=None,

                                 help=_("show duplicates, in repos, "

                                        "in list/search commands"))

        general_grp.add_argument("-e", "--errorlevel", default=None, type=int,

                                 help=_("error output level"))

        general_grp.add_argument("--obsoletes", default=None, dest="obsoletes",

                                 action="store_true",

                                 help=_("enables {prog}'s obsoletes processing logic "

                                        "for upgrade or display capabilities that "

                                        "the package obsoletes for info, list and "

                                        "repoquery").format(prog=dnf.util.MAIN_PROG))

        general_grp.add_argument("--rpmverbosity", default=None,

                                 help=_("debugging output level for rpm"),

                                 metavar='[debug level name]')

        general_grp.add_argument("-y", "--assumeyes", action="store_true",

                                 default=None, help=_("automatically answer yes"

                                                      " for all questions"))

        general_grp.add_argument("--assumeno", action="store_true",

                                 default=None, help=_("automatically answer no"

                                                      " for all questions"))

        general_grp.add_argument("--enablerepo", action=self._RepoCallback,

                                 dest='repos_ed', default=[], metavar='[repo]',

                                 help=_("Enable additional repositories. List option. "

                                        "Supports globs, can be specified multiple times."))

        repo_group = general_grp.add_mutually_exclusive_group()

        repo_group.add_argument("--disablerepo", action=self._RepoCallback,

                                dest='repos_ed', default=[], metavar='[repo]',

                                help=_("Disable repositories. List option. "

                                       "Supports globs, can be specified multiple times."))

        repo_group.add_argument('--repo', '--repoid', metavar='[repo]', dest='repo',

                                action=self._SplitCallback, default=[],

                                help=_('enable just specific repositories by an id or a glob, '

                                       'can be specified multiple times'))

        enable_group = general_grp.add_mutually_exclusive_group()

        enable_group.add_argument("--enable", default=False,

                                  dest="set_enabled", action="store_true",

                                  help=_("enable repos with config-manager "

                                         "command (automatically saves)"))

        enable_group.add_argument("--disable", default=False,

                                  dest="set_disabled", action="store_true",

                                  help=_("disable repos with config-manager "

                                         "command (automatically saves)"))

        general_grp.add_argument("-x", "--exclude", "--excludepkgs", default=[],

                                 dest='excludepkgs', action=self._SplitCallback,

                                 help=_("exclude packages by name or glob"),

                                 metavar='[package]')

        general_grp.add_argument("--disableexcludes", "--disableexcludepkgs",

                                 default=[], dest="disable_excludes",

                                 action=self._SplitCallback,

                                 help=_("disable excludepkgs"),

                                 metavar='[repo]')

        general_grp.add_argument("--repofrompath", default={},

                                 action=self._SplitExtendDictCallback,

                                 metavar='[repo,path]',

                                 help=_("label and path to an additional repository to use (same "

                                        "path as in a baseurl), can be specified multiple times."))

        general_grp.add_argument("--noautoremove", action="store_false",

                                 default=None, dest='clean_requirements_on_remove',

                                 help=_("disable removal of dependencies that are no longer used"))

        general_grp.add_argument("--nogpgcheck", action="store_false",

                                 default=None, dest='gpgcheck',

                                 help=_("disable gpg signature checking (if RPM policy allows)"))

        general_grp.add_argument("--color", dest="color", default=None,

                                 help=_("control whether color is used"))

        general_grp.add_argument("--refresh", dest="freshest_metadata",

                                 action="store_true",

                                 help=_("set metadata as expired before running"

                                        " the command"))

        general_grp.add_argument("-4", dest="ip_resolve", default=None,

                                 help=_("resolve to IPv4 addresses only"),

                                 action="store_const", const='ipv4')

        general_grp.add_argument("-6", dest="ip_resolve", default=None,

                                 help=_("resolve to IPv6 addresses only"),

                                 action="store_const", const='ipv6')

        general_grp.add_argument("--destdir", "--downloaddir", dest="destdir", default=None,

                                 help=_("set directory to copy packages to"))

        general_grp.add_argument("--downloadonly", dest="downloadonly",

                                 action="store_true", default=False,

                                 help=_("only download packages"))

        general_grp.add_argument("--comment", dest="comment", default=None,

                                 help=_("add a comment to transaction"))

        # Updateinfo options...

        general_grp.add_argument("--bugfix", action="store_true",

                                 help=_("Include bugfix relevant packages, "

                                        "in updates"))

        general_grp.add_argument("--enhancement", action="store_true",

                                 help=_("Include enhancement relevant packages,"

                                        " in updates"))

        general_grp.add_argument("--newpackage", action="store_true",

                                 help=_("Include newpackage relevant packages,"

                                        " in updates"))

        general_grp.add_argument("--security", action="store_true",

                                 help=_("Include security relevant packages, "

                                        "in updates"))

        general_grp.add_argument("--advisory", "--advisories", dest="advisory",

                                 default=[], action=self._SplitCallback,

                                 help=_("Include packages needed to fix the "

                                        "given advisory, in updates"))

        general_grp.add_argument("--bz", "--bzs", default=[], dest="bugzilla",

                                 action=self._SplitCallback, help=_(

                "Include packages needed to fix the given BZ, in updates"))

        general_grp.add_argument("--cve", "--cves", default=[], dest="cves",

                                 action=self._SplitCallback,

                                 help=_("Include packages needed to fix the given CVE, in updates"))

        general_grp.add_argument(

            "--sec-severity", "--secseverity",

            choices=['Critical', 'Important', 'Moderate', 'Low'], default=[],

            dest="severity", action=self._SplitCallback, help=_(

                "Include security relevant packages matching the severity, "

                "in updates"))

        general_grp.add_argument("--forcearch", metavar="ARCH",

                                 dest=argparse.SUPPRESS,

                                 action=self.ForceArchAction,

                                 choices=sorted(dnf.rpm._BASEARCH_MAP.keys()),

                                 help=_("Force the use of an architecture"))

        general_grp.add_argument('command', nargs='?', help=argparse.SUPPRESS)

    def _add_cmd_usage(self, cmd, group):

        """ store usage info about a single dnf command."""

        summary = dnf.i18n.ucd(cmd.summary)

        name = dnf.i18n.ucd(cmd.aliases[0])

        if not name in self._cmd_usage:

            self._cmd_usage[name] = (group, summary)

            self._cmd_groups.add(group)

    def add_commands(self, cli_cmds, group):

        """ store name & summary for dnf commands

        The stored information is used build usage information

        grouped by build-in & plugin commands.

        """

        for cmd in set(cli_cmds.values()):

            self._add_cmd_usage(cmd, group)

    def get_usage(self):

        """ get the usage information to show the user. """

        desc = {'main': _('List of Main Commands:'),

                'plugin': _('List of Plugin Commands:')}

        usage = '%s [options] COMMAND\n' % dnf.util.MAIN_PROG

        for grp in ['main', 'plugin']:

            if not grp in self._cmd_groups:

                # dont add plugin usage, if we dont have plugins

                continue

            usage += "\n%s\n\n" % desc[grp]

            for name in sorted(self._cmd_usage.keys()):

                group, summary = self._cmd_usage[name]

                if group == grp:

                    usage += "%-25s %s\n" % (name, summary)

        return usage

    def _add_command_options(self, command):

        self.prog = "%s %s" % (dnf.util.MAIN_PROG, command._basecmd)

        self.description = command.summary

        self.command_positional_parser = argparse.ArgumentParser(self.prog, add_help=False)

        self.command_positional_parser.print_usage = self.print_usage

        self.command_positional_parser._positionals.title = None

        self.command_group = self.add_argument_group(

            '{} command-specific options'.format(command._basecmd.capitalize()))

        self.command_group.add_argument = self.cmd_add_argument

        self.command_group._command = command._basecmd

        command.set_argparser(self.command_group)

    def cmd_add_argument(self, *args, **kwargs):

        if all([(arg[0] in self.prefix_chars) for arg in args]):

            return type(self.command_group).add_argument(self.command_group, *args, **kwargs)

        else:

            return self.command_positional_parser.add_argument(*args, **kwargs)

    def _check_encoding(self, args):

        for arg in args:

            try:

                arg.encode('utf-8')

            except UnicodeEncodeError as e:

                raise dnf.exceptions.ConfigError(

                    _("Cannot encode argument '%s': %s") % (arg, str(e)))

    def parse_main_args(self, args):

        self._check_encoding(args)

        namespace, _unused_args = self.parse_known_args(args)

        return namespace

    def parse_command_args(self, command, args):

        self._add_command_options(command)

        namespace, unused_args = self.parse_known_args(args)

        namespace = self.command_positional_parser.parse_args(unused_args, namespace)

        command.opts = namespace

        return command.opts

    def print_usage(self, file_=None):

        if self.command_positional_parser:

            self._actions += self.command_positional_parser._actions

        super(OptionParser, self).print_usage(file_)

    def print_help(self, command=None):

        # pylint: disable=W0212

        if command:

            if not self.command_group or self.command_group._command != command._basecmd:

                self._add_command_options(command)

            self._actions += self.command_positional_parser._actions

            self._action_groups.append(self.command_positional_parser._positionals)

        else:

            self.usage = self.get_usage()

        super(OptionParser, self).print_help()