After downloading (above) use try-fedora-review:

      $ cd FedoraReview

  To run from any directory, install try-fedora-review according to

  instructions in that script. update-version only needs to run once.

  BuildArch:  noarch

  Requires:       fedora-packager

  # licensecheck used to be in rpmdevtools, moved to devscripts later

  # this is compatible with both situations without ifdefs

  Requires:       %{_bindir}/licensecheck

  Requires:       dnf-plugins-core

  # Let's be consistent with the name used on fedorahosted

  Provides:       %{name}-php-phpci = %{version}-%{release}

  Obsoletes:      %{name}-php-phpci < %{version}-%{release}

  %package tests

  Summary: Test and test data files for fedora-review

  Requires: %{name} = %{version}-%{release}

  %description tests

  Tests are packaged separately due to space concerns.

  %build

  %install

  ln -s %{_datadir}/%{name}/scripts $pkg_dir/scripts

  ln -s %{_datadir}/%{name}/plugins $pkg_dir/plugins

  cd test

  bash < restore-links.sh

  rm restore-links.sh remember-links

  cd ..

  %check

  mock --quiet -r fedora-25-i386 --init

  mock --quiet -r fedora-26-i386 --init

  mock --quiet -r fedora-26-i386 --uniqueext=hugo --init

  %endif

  %files

  %doc README

  %license COPYING AUTHORS

  %{_bindir}/fedora-review

  %{_bindir}/fedora-create-review

  %{_bindir}/koji-download-scratch

  import re

  import os

  import rpm

          version = None

          for url in self.URLS:

              try:

                  content = stream.read()

                  stream.close()

                  self.log.warning('Could not retrieve info from %s', url)

                  self.log.debug('Error: %s', err, exc_info=True)

                  continue

              if res is not None:

                  self.log.debug("Found in: %s", url)

                  versionok.append(url)

                  if version is None:

                  else:

                      self.log.warning(

                          " * Found two version of the package in %s",

      def run_on_applicable(self):

          """ Run the check """

          if up_version is None:

              self.set_passed(

                  self.PENDING,

          if self.is_user_enabled():

              return self.user_enabled_value()

          archs = self.checks.spec.expand_tag('BuildArchs')

              return False

          if self.checks.buildsrc.is_available:

              src = self.checks.buildsrc

                  # All other .h files should be in a -devel package.

                  if '-devel' not in pkg:

                      passed = False

          self.set_passed(passed, extra)

              if pkg.endswith('-devel'):

                  continue

              for path in self.rpms.find_all('*.so', pkg):

                  if self.bad_re.search(path):

                      in_libdir = True

                  else:

              extra = ""

              for pkg in self.spec.packages:

                  for path in self.rpms.find_all('*.la', pkg):

              self.set_passed(self.FAIL, extra)

  import os.path

  import re

  from glob import glob

  from subprocess import Popen, PIPE, CalledProcessError

  import rpm

      def run(self):

          archs = self.checks.spec.expand_tag('BuildArchs')

              self.set_passed(self.NA)

              return

          self.set_passed(self.PENDING)

          try:

              cmd = 'find %s -perm -4000' % rpms_dir

              with open('/dev/null', 'w') as f:

          except CalledProcessError:

              self.log.info('Cannot run find command: %s', cmd)

              suids = []

      def run(self):

          bad_tags = []

          for pkg_name in self.spec.packages:

                  bad_tags.append(pkg_name + ' (summary)')

                  bad_tags.append(pkg_name + ' (description)')

          if bad_tags:

              self.set_passed(self.PENDING,

      def _write_license(files_by_license, filename):

          ''' Dump files_by_license to filename. '''

          with open(filename, 'w') as f:

                  f.write('\n' + license_ + '\n')

                  f.write('-' * len(license_) + '\n')

                  for path in sorted(files_by_license[license_]):

              license_ = license_.strip()

              if not license_is_valid(license_):

                  license_ = self.unknown_license

                  files_by_license[license_] = []

              files_by_license[license_].append(file_)

          return files_by_license

              if os.path.exists(source_dir):

                  cmd = 'licensecheck -r ' + source_dir

                  try:

                  except (OSError, CalledProcessError) as err:

                      self.set_passed(self.PENDING,

                                      "Cannot run licensecheck: " + str(err))

                  msg += ' Please check the source files for licenses manually.'

              else:

                  msg += ' Licenses found: "' \

                  if self.unknown_license in files_by_license:

                      msg += ' %d files have unknown license.' % \

                                  len(files_by_license[self.unknown_license])

                                'COPYRIGHT', 'copyright']:

              pattern = '*' + potentialfile + '*'

              licenses.extend(self.rpms.find_all(pattern))

          if licenses == []:

              self.set_passed(self.PENDING)

              return

          for pkg in self.spec.packages:

              nvr = self.spec.get_package_nvr(pkg)

              rpm_path = Mock.get_package_rpm_path(nvr)

              flagged_files.extend(doclist.split('\n'))

          if self._license_flag == 'L':

              for pkg in self.spec.packages:

                  nvr = self.spec.get_package_nvr(pkg)

                  rpm_path = Mock.get_package_rpm_path(nvr)

                  cmd = 'rpm -qpL %s' % rpm_path

                  qpL_files.extend(qpL_list.split('\n'))

          for _license in licenses:

              if self._license_flag == 'L' and _license not in qpL_files:

          self.type = 'MUST'

      def is_applicable(self):

          return 'and' in license_ or 'or' in license_

          if passed:

              self.set_passed(passed)

          else:

  class CheckNaming(GenericCheckBase):

              items = []

              for d in owners_by_dir:

                  owners = ', '.join(owners_by_dir[d])

              return "Dirs in package are owned also by: " + \

                  ', '.join(items)

                  self.log.warn(

                      "Cannot extract local source: %s", s.filename)

                  return(False, None)

              self.log.debug(' Diff cmd: %s', cmd)

              try:

                  output = p.communicate()[0]

              except OSError:

                  self.log.error("Cannot run diff", exc_info=True)

              local = self.srpm.check_source_checksum(source.filename)

              upstream = source.check_source_checksum()

              text += source.url + ' :\n'

                      format(Settings.checksum.upper(), local)

                      format(Settings.checksum.upper(), upstream)

              if local != upstream:

                  all_sources_passed = False

      def run(self):

          using = []

          failed = False

          for pkg in self.spec.packages:

              if self.rpms.find('/usr/lib/systemd/system/*', pkg):

                  using.append(pkg)

      def run(self):

          using = []

          failed = False

          for pkg in self.spec.packages:

              if self.rpms.find('/usr/lib/systemd/user/*', pkg):

                  using.append(pkg)

  def _prepend_indent(text):

      ''' add the paragraph indentation '''

      lines = text.splitlines()

  class Registry(RegistryBase):

              try:

                  self.log.debug("running: %s", ' '.join(cmd))

                  stdout, stderr = p.communicate()

              except IOError:

                  self.set_passed(self.PENDING,

                  return

              m4_lines = stdout.splitlines(False)

              for m4_line in m4_lines:

                  line, m4 = m4_line.split(':')

  import sys

  import tempfile

  import FedoraReview.deps as deps

  from FedoraReview import CheckBase, Mock, ReviewDirs, Settings

          arg: filenames, list of filenames to run rpmlint on

          """

          rpmlint_cfg = tempfile.NamedTemporaryFile(delete=False)

          rpmlint_cfg.close()

          cmd = 'rpmlint -f ' + rpmlint_cfg.name + ' ' + ' '.join(filenames)

          text += 'Active plugins: ' + ', '.join(plugins) + '\n'

          plugins = self.checks.get_plugins(False)

          text += 'Disabled plugins: ' + ', '.join(plugins) + '\n'

                   if not self.checks.flags[f]]

          flags = ', '.join(flags) if flags else 'None'

          text += 'Disabled flags: ' + flags + '\n'

  from FedoraReview import ReviewError             # pylint: disable=W0611

  from FedoraReview import RegistryBase, Settings

  class Registry(RegistryBase):

          def get_requires(rpm_name, requires):

              ''' Return printable requirements for a rpm. '''

              requires = sorted(list(set(requires)))

              hdr = rpm_name + ' (rpmlib, GLIBC filtered):'

              requires.insert(0, hdr)

          if len(self.spec.packages) == 1:

              self.set_passed(self.NA)

              return

              isa = ''

          else:

              isa = Mock.get_macro('%_isa', self.spec, self.flags)

          for tag in ('Packager', 'Vendor', 'PreReq', 'Copyright'):

              if not self.spec.find_re(r'^\s*' + tag + r'\s*:'):

                  continue

              if value:

                  passed = False

          if not passed:

              self.set_passed(passed, output)

          else:

              return

          passed = 'pass'

          extra = ''

              for fn in files_by_pkg[pkg]:

                  if '-devel' not in pkg:

                      passed = 'pending'

          self.set_passed(passed, extra)

          url_spec_file = self.spec.filename

          cmd = ["diff", '-U2', url_spec_file, srpm_spec_file]

          try:

              output = p.communicate()[0]

          except OSError:

              self.log.error("Cannot run diff", exc_info=True)

          build_ok = self.checks.checkdict['CheckBuild'].is_passed

          arch = self.spec.expand_tag('BuildArch')

          one_arch = self.spec.expand_tag('ExclusiveArch')

          if build_ok and (one_arch or noarch):

              self.set_passed(self.PASS)

          self.automatic = True

      def run_on_applicable(self):

          if _has_extension(self):

              self.set_passed('noarch' not in arch,

                              "Package with binary extension can't be built"

          err_message = []

          # construct the error message for all non-present macros

              if value is False:

                  err_message.append(key.pattern.replace('\\s+', ' '))

      fi

      sort_hint=$1

      shift

      file="$sort_hint;${title/;/:};$i"

      cat > .attachments/"$file"

      cd $startdir

  def _settings_generator():

      ''' Bash code defining FR_SETTINGS, reflecting Settings. '''

      body = 'declare -A FR_SETTINGS \n'

          if key.startswith('_'):

              continue

          value = Settings.__dict__[key]

              value = ''

          if isinstance(value, str):

              value = value.replace('"', r'\"')

      return body

  def _source_generator(spec):

      ''' Bash code defining the %sourceX items. '''

      body = ''

          body += 'export ' + tag + '="' + path + '"\n'

      return body

  def _patch_generator(spec):

      ''' Bash code defining the %patchX items. '''

      body = ''

          body += 'export ' + tag + '="' + path + '"\n'

      return body

      body = 'declare -A FR_FILES\n'

      for pkg in spec.packages:

          item = _quote('\n'.join(spec.get_files(pkg)))

      return body

          section = spec.get_section('%description', pkg)

          if section:

              item = _quote('\n'.join(section))

      return body

  def _flags_generator(flags):

      ''' Bash code defining FR_FLAGS,reflecting checks.flags. '''

      body = 'declare -A FR_FLAGS\n'

      return body

  def _write_tag(spec, env, tag):

      ''' Substitute a spec tag into env. '''

      if value:

          env = env.replace('@' + tag + '@', value)

      else:

          Actually invoke the external script, returning

          (retcode, stdout, stderr)

          '''

          try:

              stdout, stderr = p.communicate()

          except OSError:

  Tools for helping Fedora package reviewers

  '''

  # vim: set expandtab ts=4 sw=4:

  from abc import ABCMeta, abstractmethod

  from glob import glob

  class AbstractBug(HelpersMixin):

  '''

  import os.path

  class BugzillaBug(UrlBug):

  ''' Basic definitions: AbstractCheck + descendants, TestResult.  '''

  import re

  from abc import ABCMeta, abstractmethod

  from textwrap import TextWrapper

  class _Attachment(object):

          s += self.text

          return s