lintian.py

# -*- coding: utf-8 -*-
#
#   lintian.py — lintian plugin
#
#   This file is part of debexpo - https://alioth.debian.org/projects/debexpo/
#
#   Copyright © 2008 Jonny Lamb <jonny@debian.org>
#   Copyright © 2012 Nicolas Dandrimont <Nicolas.Dandrimont@crans.org>
#   Copyright © 2012 Clément Schreiner <clement@mux.me>
#
#   Permission is hereby granted, free of charge, to any person
#   obtaining a copy of this software and associated documentation
#   files (the "Software"), to deal in the Software without
#   restriction, including without limitation the rights to use,
#   copy, modify, merge, publish, distribute, sublicense, and/or sell
#   copies of the Software, and to permit persons to whom the
#   Software is furnished to do so, subject to the following
#   conditions:
#
#   The above copyright notice and this permission notice shall be
#   included in all copies or substantial portions of the Software.
#
#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
#   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
#   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
#   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
#   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
#   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
#   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
#   OTHER DEALINGS IN THE SOFTWARE.

"""
Holds the lintian plugin.
"""

__author__ = 'Jonny Lamb'
__copyright__ = ', '.join([
        'Copyright © 2008 Jonny Lamb',
        'Copyright © 2012 Nicolas Dandrimont',
        'Copyright © 2012 Clément Schreiner',
        ])
__license__ = 'MIT'


import subprocess
import logging
from collections import defaultdict, namedtuple

from debexpo.lib import constants
from debexpo.plugins.api import *
from debexpo.model import meta

log = logging.getLogger(__name__)

LintianSeverity = namedtuple('LintianSeverity',
                             ['str', 'int', 'plugin_severity'])
severities = {
    'E': LintianSeverity('Package has lintian errors', 5,
                         constants.PLUGIN_SEVERITY_ERROR),
    'W': LintianSeverity('Package has lintian warnings', 4,
                         constants.PLUGIN_SEVERITY_WARNING),
    'I': LintianSeverity('Package has lintian informational warnings', 3,
                         constants.PLUGIN_SEVERITY_INFO),
    'O': LintianSeverity('Package has overridden lintian tags', 2,
                         constants.PLUGIN_SEVERITY_INFO),
    'P': LintianSeverity('Package has lintian pedantic tags', 1,
                         constants.PLUGIN_SEVERITY_INFO),
    'X': LintianSeverity('Package has lintian experimental tags', 0,
                         constants.PLUGIN_SEVERITY_INFO),
    '': LintianSeverity('Package is lintian clean', -1,
                        constants.PLUGIN_SEVERITY_INFO),
    }


@test_result
class LintianTest(PluginResult):
    """ Summary of the lintian results """

    # -1 -> package is clean
    max_lintian_severity = string_field('max_lintian_severity')
    severity = int_field('severity')

    def get_tags(self):
        """
        Returns the LintianTag objects for this package, as a
        dictionary.
        """

        # Yes, three levels of defaultdict and one of list...
        # FIXME: how exactly is this new API better? :/
        def defaultdict_defaultdict_list():
            def defaultdict_list():
                return defaultdict(list)
            return defaultdict(defaultdict_list)
        lintian_warnings = defaultdict(defaultdict_defaultdict_list)

        q = meta.session.query(LintianWarning)
        q = q.filter_by(package_version_id=self.package_version.id)
        for w in q.all():
            lintian_warnings[w.package][w.severity][w.tag].append(w.data)
        return lintian_warnings

    def __str__(self):
        return severities[self.max_lintian_severity].str


class LintianWarning(PluginResult):
    """ A lintian warning found for the package """

    package = string_field('package')
    severity = string_field('severity')
    tag = string_field('tag')
    data = string_field('data')

    def __str__(self):
        return 'Lintian warning ({severity}): [{tag}] {data}'.format(
            severity=self.severity,
            tag=self.tag,
            data=self.data)


class LintianPlugin(QAPlugin):
    """ Runs lintian tests on the package's binaries """

    @importercmd
    def test_lintian(self):
        """
        Method to run lintian on the package.
        """
        log.debug('Running lintian on the package')

        output = subprocess.Popen(["lintian",
                                   "-E",
                                   "-I",
                                   "--pedantic",
                                   "--show-overrides",
                                   self.changes_file],
                                   stdout=subprocess.PIPE).communicate()[0]

        items = output.split('\n')

        lintian_severities = set()

        override_comments = []

        for item in items:
            if not item:
                continue

            # lintian output is of the form:
            # " SEVERITY: package: lintian_tag [lintian tag arguments] "
            # or " N: Override comment "
            if item.startswith("N: "):
                override_comments.append(item[3:].strip())
                continue
            severity, package, rest = item.split(': ', 2)
            lintian_severities.add(severity)
            lintian_tag_data = rest.split()
            lintian_tag = lintian_tag_data[0]
            lintian_data = lintian_tag_data[1:]
            if override_comments:
                lintian_data.append("(override comment: "
                                    + " ".join(override_comments) + ")")
                override_comments = []
            for line in lintian_data:
                self.new_result(LintianWarning, package=package,
                                severity=severity, tag=lintian_tag,
                                data=line)

        if not lintian_severities:
            max_lintian_severity = ''

        else:
            max_lintian_severity = max(lintian_severities,
                                       key=lambda s: severities[s].int)
        severity = severities[max_lintian_severity].plugin_severity

        self.new_test_result(severity=severity,
                             max_lintian_severity=max_lintian_severity)

plugin = LintianPlugin
models = [
    LintianTest,
    LintianWarning,
    ]