+ init-hook=

+     import os

+     import sys

+     from pylint.config import find_pylintrc

+     pylintrc = find_pylintrc()

+     backend_dir = os.path.dirname(pylintrc)

+     sys.path.insert(0, os.path.join(backend_dir, '..', 'common'))

+     sys.path.insert(0, os.path.join(backend_dir, '..', 'python'))

+ 

+ test -f ../build_aux/linter && {

+     echo >&2 "running linter"

+     ../build_aux/linter

+ }

+ 

+ #! /bin/bash

+ 

+ # csdiff mis-parses the line if we don't produce absoulute filenames, hence

+ # the leading /.

+ 

+ pylint -rn \

+        --score=no \

+        --msg-template='/{path}:{line}:{column}: {msg_id}[pylint]: {msg}' \

+        "$@" \

+     | grep -F -v '*******'

+ 

+ exit "${PIPESTATUS[0]}"

+ #! /bin/bash

+ 

+ set -x

+ set -e

+ 

+ # only PRs now

+ case $REPO in

+     *forks*) ;;

+     *) exit 0 ;;

+ esac

+ 

+ cleanup_actions=()

+ cleanup()

+ {

+     for action in "${cleanup_actions[@]}"; do

+         $action

+     done

+ }

+ trap cleanup EXIT

+ 

+ filter="

+ import sys, json

+ d = json.loads(sys.stdin.read())

+ for member in d['members']:

+     sys.stdout.write(' ' + member + ' ')

+ print()

+ "

+ 

+ echo "Checking whether we want to run against $REPO/$BRANCH"

+ 

+ # only copr-team for now

+ members=$(curl https://pagure.io/api/0/group/copr \

+     | python3 -c "$filter")

+ 

+ # https://pagure.io/pagure/issue/4807

+ copr_sig_member=false

+ for member in $members; do

+     case $REPO in

+         *forks/$member/*)

+             copr_sig_member=true

+             break

+             ;;

+     esac

+ done

+ $copr_sig_member || exit 0  # silently skip non-copr people

+ 

+ git remote rm proposed || true

+ git remote add proposed "$REPO"

+ git fetch proposed

+ git checkout "proposed/$BRANCH"

+ 

+ : "${DIFF_AGAINST=origin/master}"

+ 

+ subdirs=(

+     -e ^backend$

+     -e ^frontend$

+     -e ^distgit$

+     -e ^cli$

+     -e ^common$

+     -e ^messaging$

+     -e ^rpmbuild$

+     -e ^keygen$

+     -e ^python$

+ )

+ 

+ changed_packages=$(

+     git diff --name-only "$DIFF_AGAINST" \

+         | cut -d'/' -f1 | sort | uniq \

+         | grep "${subdirs[@]}"

+ ) || :

+ 

+ test -n "$changed_packages" || exit 0

+ 

+ 

+ run_linter()

+ {

+     test -f build_aux/linter || return 0

+     mkdir -p image

+     image=copr-lint-container:latest

+     cat > image/Dockerfile <<EOF

+ From fedora:32

+ RUN dnf install -y csdiff git pylint

+ EOF

+     ( cd image

+       docker build -t "$image" .

+     )

+     container=$(docker run --rm -v "$PWD":/workdir:Z -d "$image" sleep 1800)

+     cleanup_actions+=( "docker kill $container" )

+     for package; do

+       docker exec "$container" bash -c "cd /workdir/$package && ../build_aux/linter --compare-against $DIFF_AGAINST"

+     done

+ }

+ 

+ run_linter $changed_packages

+ #! /usr/bin/python3

+ 

+ """

+ Using 'csdiff', print newly added coding errors.

+ """

+ 

+ import os

+ import sys

+ from subprocess import Popen, PIPE, check_output, check_call

+ import glob

+ import logging

+ import tempfile

+ import shutil

+ import argparse

+ 

+ 

+ logging.basicConfig(level=logging.INFO)

+ log = logging.getLogger()  # pylint: disable=invalid-name

+ 

+ CSDIFF_PYLINT = os.path.realpath(os.path.join(os.path.dirname(__file__),

+                                               'csdiff-pylint'))

+ 

+ 

+ def file_type(filename):

+     """

+     Taking FILENAME (must exist), return it's type in string format.  Current

+     supported formats are ('python',).

+     """

+     if filename.endswith(".py"):

+         return 'python'

+     with open(filename) as f_d:

+         first_line = f_d.readline()

+         if first_line.startswith('#!') and first_line.find('python') != -1:

+             return 'python'

+     return 'unknown'

+ 

+ 

+ class _Linter:

+     filetype = None

+     path_filters = None

+ 

+     def __init__(self, projectdir, renames=None):

+         self.projectdir = projectdir

+         self.renames = renames

+ 

+     @classmethod

+     def modify_rename(cls, old, new):

+         """ if the paths in linter output need adjustments """

+         return old, new

+ 

+     def _sed_filter(self):

+         if not self.renames:

+             return None

+ 

+         rules = []

+         for pair in self.renames:

+             old, new = self.modify_rename(pair[0], pair[1])

+             rule = "s|^{}|{}|".format(old, new)

+             rules += ['-e', rule]

+ 

+         return ['sed'] + rules

+ 

+     def command(self, filenames):

+         """

+         Given the list of FILENAMES, generate command that will be executed

+         by lint() method, and environment vars set.  Return (CMD, ENV) pair.

+         """

+         raise NotImplementedError

+ 

+     # pylint: disable=no-self-use,unused-argument

+     def is_compatible(self, file):

+         """ file contains 'filename' and 'type' attributes """

+         return True

+ 

+     def lint(self, cwd, files, logfd):

+         """ run the linter """

+         if not files:

+             return

+ 

+         oldcwd = os.getcwd()

+ 

+         try:

+             log.debug("linting in %s", cwd)

+             os.chdir(cwd)

+             files = [f.filename for f in files if self.is_compatible(f)]

+             if not files:

+                 return

+             linter_cmd, linter_env = self.command(files)

+             env = os.environ.copy()

+             env.update(linter_env)

+             sed_cmd = self._sed_filter()

+             if sed_cmd:

+                 linter = Popen(linter_cmd, env=env, stdout=PIPE)

+                 sed = Popen(sed_cmd, stdout=logfd, stdin=linter.stdout)

+                 sed.communicate()

+             else:

+                 linter = Popen(linter_cmd, env=env, stdout=logfd)

+                 linter.communicate()

+ 

+         finally:

+             os.chdir(oldcwd)

+ 

+ 

+ class PylintLinter(_Linter):

+     """

+     Generate pyilnt error output that is compatible with 'csdiff'.

+     """

+     def is_compatible(self, file):

+         return file.type == 'python'

+ 

+     @classmethod

+     def modify_rename(cls, old, new):

+         """

+         Git reports 'a -> b' rename, but we use '/a -> /b' here because

+         otherwise csdiff wouldn't parse the reports.  That's why we have to

+         modify it here, too.

+         """

+         return '/' + old, '/' + new

+ 

+     def command(self, filenames):

+         options = []

+         pylintrc = os.path.realpath(os.path.join(self.projectdir, 'pylintrc'))

+         cmd = [CSDIFF_PYLINT] + options + filenames

+         env = {'PYLINTRC': pylintrc}

+         return cmd, env

+ 

+ 

+ def get_rename_map(options):

+     """

+     Using the os.getcwd() and 'git diff --namestatus', generate list of

+     files to analyze with possible overrides.  The returned format is

+     dict of format 'new_file' -> 'old_file'.

+     """

+     cmd = ['git', 'diff', '--name-status', '-C', options.compare_against,

+            '--numstat', '.']

+     # current file -> old_name

+     return_map = {}

+     output = check_output(cmd).decode('utf-8')

+     for line in output.split('\n'):

+         if not line:

+             continue

+ 

+         parts = line.split('\t')

+         mode = parts[0]

+         if mode == '':

+             continue

+         if mode.startswith('R'):

+             return_map[parts[2]] = parts[1]

+         elif mode.startswith('A'):

+             return_map[parts[1]] = None

+         elif mode == 'M':

+             return_map[parts[1]] = parts[1]

+         else:

+             assert False

+ 

+     return return_map

+ 

+ 

+ class _Worker:  # pylint: disable=too-few-public-methods

+     gitroot = None

+     projectdir = None

+     workdir = None

+     checkout = None

+     linters = [PylintLinter]

+ 

+     def __init__(self, options):

+         self.options = options

+ 

+     def _analyze_projectdir(self):

+         """ find sub-directory in git repo which contains spec file """

+         gitroot = check_output(['git', 'rev-parse', '--show-toplevel'])

+         self.gitroot = gitroot.decode('utf-8').strip()

+ 

+         checkout = check_output(['git', 'rev-parse',

+                                  self.options.compare_against])

+         self.checkout = checkout.decode('utf-8').strip()

+ 

+         path = os.getcwd()

+         while True:

+             log.debug("checking for projectdir: %s", path)

+             if os.path.realpath(path) == '/':

+                 raise Exception("project dir not found")

+             if os.path.isdir(os.path.join(path, '.git')):

+                 self.projectdir = path

+                 return

+             if glob.glob(os.path.join(path, '*.spec')):

+                 self.projectdir = path

+                 return

+             path = os.path.normpath(os.path.join(path, '..'))

+ 

+     def _run_linters(self, old_report_fd, new_report_fd):

+         # pylint: disable=too-many-locals

+         lookup = get_rename_map(self.options)

+         if not lookup:

+             return

+ 

+         old_files = []

+         new_files = []

+         old_dir = os.path.join(self.workdir, 'old_dir')

+         origin_from = self.gitroot

+         check_call(['git', 'clone', '--quiet', origin_from, old_dir])

+         ret_cwd = os.getcwd()

+         try:

+             os.chdir(old_dir)

+             check_call(['git', 'checkout', '-q', self.checkout])

+         finally:

+             os.chdir(ret_cwd)

+ 

+         new_dir = self.gitroot

+ 

+         def add_file(dirname, files, filename):

+             if not filename:

+                 return

+             git_file = os.path.join(dirname, filename)

+             if not os.path.isfile(git_file):

+                 log.debug("skipping non-file %s", git_file)

+                 return

+             file = lambda: None  # noqa: E731

+             file.filename = filename

+             file.type = file_type(git_file)

+             files.append(file)

+ 

+         for filename in lookup:

+             add_file(new_dir, new_files, filename)

+             add_file(old_dir, old_files, lookup[filename])

+ 

+         renames = []

+         for new in lookup:

+             old = lookup[new]

+             if old and old != new:

+                 renames.append((old, new))

+ 

+         for LinterClass in self.linters:

+             linter_new = LinterClass(self.projectdir)

+             linter_old = LinterClass(self.projectdir, renames)

+             linter_new.lint(new_dir, new_files, logfd=new_report_fd)

+             linter_old.lint(old_dir, old_files, logfd=old_report_fd)

+ 

+     def run(self):

+         """

+         Run all the 'self.linters' against old sources and new sources,

+         and provide the diff.

+         """

+         self._analyze_projectdir()

+         self.workdir = tempfile.mkdtemp(prefix='copr-linter-')

+         try:

+             old_report = os.path.join(self.workdir, 'old')

+             new_report = os.path.join(self.workdir, 'new')

+ 

+             with open(old_report, 'w') as old, open(new_report, 'w') as new:

+                 oldcwd = os.getcwd()

+                 try:

+                     log.debug("going to projectdir %s", self.projectdir)

+                     os.chdir(self.projectdir)

+                     self._run_linters(old, new)

+                 finally:

+                     os.chdir(oldcwd)

+ 

+             popen_diff = Popen(['csdiff', old_report, new_report],

+                                stdout=PIPE)

+             diff = popen_diff.communicate()[0].decode('utf-8')

+             sys.stdout.write(diff)

+             sys.exit(bool(diff))

+         finally:

+             log.debug("removing workdir %s", self.workdir)

+             shutil.rmtree(self.workdir)

+ 

+ 

+ def _get_arg_parser():

+     parser = argparse.ArgumentParser()

+     parser.add_argument(

+         "--compare-against",

+         default="origin/master",

+         help=("What git ref to diff the linters' results against.  Note "

+               "that the reference needs to be available in the current "

+               "git directory"))

+     return parser

+ 

+ 

+ def _main():

+     options = _get_arg_parser().parse_args()

+     worker = _Worker(options)

+     worker.run()

+ 

+ 

+ if __name__ == "__main__":

+     _main()

+ init-hook=

+     import os

+     import sys

+     from pylint.config import find_pylintrc

+     pylintrc = find_pylintrc()

+     backend_dir = os.path.dirname(pylintrc)

+     sys.path.insert(0, os.path.join(backend_dir, '..', 'common'))

+     sys.path.insert(0, os.path.join(backend_dir, '..', 'python'))

+ 

+ 

+ set -e

+ 

+ test -f ../build_aux/linter && {

+     echo >&2 "running linter"

+     ../build_aux/linter

+ }

+ 

+ ../pylintrc 

+ ../pylintrc 

+ test -f ../build_aux/linter && {

+     echo >&2 "running linter"

+     ../build_aux/linter

+ }

+ 

+ init-hook=

+     import os

+     import sys

+     from pylint.config import find_pylintrc

+     pylintrc = find_pylintrc()

+     backend_dir = os.path.dirname(pylintrc)

+     sys.path.insert(0, os.path.join(backend_dir, '..', 'common'))

+     sys.path.insert(0, os.path.join(backend_dir, '..', 'python'))

+ 

+ test -f ../build_aux/linter && {

+     echo >&2 "running linter"

+     ../build_aux/linter

+ }

+ 

+ ../pylintrc 

+ set -e

+ 

+ test -f ../build_aux/linter && {

+     echo >&2 "running linter"

+     ../build_aux/linter

+ }

+ 

+ # pylint: skip-file

+ 

+ init-hook=

+     import os

+     import sys

+     from pylint.config import find_pylintrc

+     pylintrc = find_pylintrc()

+     backend_dir = os.path.dirname(pylintrc)

+     sys.path.insert(0, os.path.join(backend_dir, '..', 'common'))

+     sys.path.insert(0, os.path.join(backend_dir, '..', 'python'))

+ 

+ 

+ set -e

+ 

+ test -f ../build_aux/linter && {

+     echo >&2 "running linter"

+     ../build_aux/linter

+ }

+ 

+ 

+ python3 -m pytest -s copr_messaging/tests

+ # copr global (fallback) pylint configuration

+ 

+ [MASTER]

+ # Pickle collected data for later comparisons.

+ persistent=no

+ 

+ init-hook=

+     import os

+     import sys

+     import subprocess

+     gitrootdir = subprocess.check_output(["git", "rev-parse", "--show-toplevel"]).decode("utf-8").strip()

+     sys.path.insert(0, os.path.join(gitrootdir, 'common'))

+     sys.path.insert(0, os.path.join(gitrootdir, 'python'))

+ 

+ 

+ [VARIABLES]

+ # A regular expression matching names used for dummy variables (i.e. not used).

+ dummy-variables-rgx=_|dummy

+ 

+ 

+ [BASIC]

+ # Regular expression which should only match correct module names

+ module-rgx=([a-zA-Z_][a-zA-Z0-9_]+)$

+ 

+ # Regular expression which should only match correct module level names

+ const-rgx=(([a-zA-Z_][a-zA-Z0-9_]*)|(__.*__))$

+ 

+ # Regular expression which should only match correct class names

+ class-rgx=[a-zA-Z_][a-zA-Z0-9_]+$

+ 

+ # Regular expression which should only match correct function names

+ function-rgx=[a-z_][a-zA-Z0-9_]{,42}$

+ 

+ # Regular expression which should only match correct method names

+ method-rgx=[a-z_][a-zA-Z0-9_]{,42}$

+ 

+ # Regular expression which should only match correct instance attribute names

+ attr-rgx=[a-z_][a-zA-Z0-9_]{,30}$

+ 

+ # Regular expression which should only match correct argument names

+ argument-rgx=[a-z_][a-zA-Z0-9_]{,30}$

+ 

+ # Regular expression which should only match correct variable names

+ variable-rgx=[a-z_][a-zA-Z0-9_]{,30}$

+ 

+ # Regular expression which should only match correct list comprehension /

+ # generator expression variable names

+ inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$

+ 

+ # Regular expression which should only match correct class sttribute names

+ class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,42}|(__.*__))$

+ 

+ # Good variable names which should always be accepted, separated by a comma

+ good-names=i,j,k,ex,Run,_

+ 

+ # Bad variable names which should always be refused, separated by a comma

+ bad-names=foo,bar,baz,toto,tutu,tata

+ 

+ # List of builtins function names that should not be used, separated by a comma

+ bad-functions=apply,input

+ 

+ 

+ [DESIGN]

+ 

+ # Maximum number of arguments for function / method

+ max-args=10

+ 

+ # Maximum number of locals for function / method body

+ max-locals=20

+ 

+ # Maximum number of return / yield for function / method body

+ max-returns=6

+ 

+ # Maximum number of branch for function / method body

+ max-branchs=20

+ 

+ # Maximum number of statements in function / method body

+ max-statements=50

+ 

+ # Maximum number of parents for a class (see R0901).

+ max-parents=7

+ 

+ # Maximum number of attributes for a class (see R0902).

+ max-attributes=7

+ 

+ # Minimum number of public methods for a class (see R0903).

+ min-public-methods=1

+ 

+ # Maximum number of public methods for a class (see R0904).

+ max-public-methods=20

+ 

+ 

+ [FORMAT]

+ # Maximum number of characters on a single line.

+ max-line-length=120

+ 

+ # Maximum number of lines in a module

+ max-module-lines=1000

+ 

+ # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1

+ # tab).

+ indent-string='    '

+ 

+ 

+ [MISCELLANEOUS]

+ # List of note tags to take in consideration, separated by a comma.

+ notes=

+ init-hook=

+     import os

+     import sys

+     from pylint.config import find_pylintrc

+     pylintrc = find_pylintrc()

+     backend_dir = os.path.dirname(pylintrc)

+     sys.path.insert(0, os.path.join(backend_dir, '..', 'common'))

+     sys.path.insert(0, os.path.join(backend_dir, '..', 'python'))

+ 

+ 

+ set -e

+ 

+ test -f ../build_aux/linter && {

+     echo >&2 "running linter"

+     ../build_aux/linter

+ }

+ 

+ ../pylintrc 

+ set -e

+ 

+ test -f ../build_aux/linter && {

+     echo >&2 "running linter"

+     ../build_aux/linter

+ }

+