Mini Shell

# changelog.py
# DNF plugin adding a command changelog.
#
# Copyright (C) 2014 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 absolute_import
from __future__ import unicode_literals

import argparse
import collections
import dateutil.parser

from dnfpluginscore import _, P_, logger
import dnf
import dnf.cli


def validate_date(val):
    try:
        return dateutil.parser.parse(val, fuzzy=True)
    except (ValueError, TypeError, OverflowError):
        raise argparse.ArgumentTypeError(_('Not a valid date: "{0}".').format(val))


@dnf.plugin.register_command
class ChangelogCommand(dnf.cli.Command):
    aliases = ('changelog',)
    summary = _('Show changelog data of packages')

    @staticmethod
    def set_argparser(parser):
        filter_group = parser.add_mutually_exclusive_group()
        filter_group.add_argument(
            '--since', metavar="DATE", default=None,
            type=validate_date,
            help=_('show changelog entries since DATE. To avoid ambiguosity, '
                   'YYYY-MM-DD format is recommended.'))
        filter_group.add_argument(
            '--count', default=None, type=int,
            help=_('show given number of changelog entries per package'))
        filter_group.add_argument(
            '--upgrades', default=False, action='store_true',
            help=_('show only new changelog entries for packages, that provide an '
                   'upgrade for some of already installed packages.'))
        parser.add_argument("package", nargs='*', metavar=_('PACKAGE'))

    def configure(self):
        demands = self.cli.demands
        demands.available_repos = True
        demands.sack_activation = True
        demands.changelogs = True

    def query(self):
        q = self.base.sack.query()
        if self.opts.package:
            q.filterm(empty=True)
            for pkg in self.opts.package:
                pkg_q = dnf.subject.Subject(pkg, ignore_case=True).get_best_query(
                    self.base.sack, with_nevra=True,
                    with_provides=False, with_filenames=False)
                if self.opts.repo:
                    pkg_q.filterm(reponame=self.opts.repo)
                if pkg_q:
                    q = q.union(pkg_q.latest())
                else:
                    logger.info(_('No match for argument: %s') % pkg)
        elif self.opts.repo:
            q.filterm(reponame=self.opts.repo)
        if self.opts.upgrades:
            q = q.upgrades()
        else:
            q = q.available()
        return q

    def by_srpm(self, packages):
        by_srpm = collections.OrderedDict()
        for pkg in sorted(packages):
            by_srpm.setdefault((pkg.source_name or pkg.name, pkg.evr), []).append(pkg)
        return by_srpm

    def filter_changelogs(self, package):
        if self.opts.upgrades:
            return self.base.latest_changelogs(package)
        elif self.opts.count:
            return package.changelogs[:self.opts.count]
        elif self.opts.since:
            return [chlog for chlog in package.changelogs
                    if chlog['timestamp'] >= self.opts.since.date()]
        else:
            return package.changelogs

    def run(self):
        if self.opts.since:
            logger.info(_('Listing changelogs since {}').format(self.opts.since))
        elif self.opts.count:
            logger.info(P_('Listing only latest changelog',
                           'Listing {} latest changelogs',
                           self.opts.count).format(self.opts.count))
        elif self.opts.upgrades:
            logger.info(
                _('Listing only new changelogs since installed version of the package'))
        else:
            logger.info(_('Listing all changelogs'))

        by_srpm = self.by_srpm(self.query())
        for name in by_srpm:
            print(_('Changelogs for {}').format(
                ', '.join(sorted({str(pkg) for pkg in by_srpm[name]}))))
            for chlog in self.filter_changelogs(by_srpm[name][0]):
                print(self.base.format_changelog(chlog))