[gentoo-commits] proj/portage:repoman commit in: repoman/pym/repoman/modules/scan/ebuild/

[Zac Medico]

commit:     ac86784b164c8705c45f79d3418d783e59d99a9a
Author:     Brian Dolbec <dolsen <AT> gentoo <DOT> org>
AuthorDate: Sat Jul 15 01:10:13 2017 +0000
Commit:     Zac Medico <zmedico <AT> gentoo <DOT> org>
CommitDate: Fri Mar 30 03:51:20 2018 +0000
URL:        https://gitweb.gentoo.org/proj/portage.git/commit/?id=ac86784b

repoman: Remove the no longer used modules/scan/ebuild/checks.py

 repoman/pym/repoman/modules/scan/ebuild/checks.py | 1044 ---------------------
 1 file changed, 1044 deletions(-)

diff --git a/repoman/pym/repoman/modules/scan/ebuild/checks.py b/repoman/pym/repoman/modules/scan/ebuild/checks.py
deleted file mode 100644
index de03bedd2..000000000
--- a/repoman/pym/repoman/modules/scan/ebuild/checks.py
+++ /dev/null
@@ -1,1044 +0,0 @@
-# -*- coding:utf-8 -*-
-# repoman: Checks
-# Copyright 2007-2017 Gentoo Foundation
-# Distributed under the terms of the GNU General Public License v2
-
-"""This module contains functions used in Repoman to ascertain the quality
-and correctness of an ebuild."""
-
-from __future__ import unicode_literals
-
-from itertools import chain
-import operator
-import re
-import time
-
-# import our initialized portage instance
-from repoman._portage import portage
-
-from portage.eapi import (
-	eapi_supports_prefix, eapi_has_implicit_rdepend,
-	eapi_has_src_prepare_and_src_configure, eapi_has_dosed_dohard,
-	eapi_exports_AA, eapi_has_pkg_pretend)
-
-from . import errors
-
-
-class LineCheck(object):
-	"""Run a check on a line of an ebuild."""
-	"""A regular expression to determine whether to ignore the line"""
-	ignore_line = False
-	"""True if lines containing nothing more than comments with optional
-	leading whitespace should be ignored"""
-	ignore_comment = True
-
-	def new(self, pkg):
-		pass
-
-	def check_eapi(self, eapi):
-		"""Returns if check should be run in the given EAPI (default: True)"""
-		return True
-
-	def check(self, num, line):
-		"""Run the check on line and return error if there is one"""
-		if self.re.match(line):
-			return self.error
-
-	def end(self):
-		pass
-
-
-class PhaseCheck(LineCheck):
-	""" basic class for function detection """
-
-	func_end_re = re.compile(r'^\}$')
-	phases_re = re.compile('(%s)' % '|'.join((
-		'pkg_pretend', 'pkg_setup', 'src_unpack', 'src_prepare',
-		'src_configure', 'src_compile', 'src_test', 'src_install',
-		'pkg_preinst', 'pkg_postinst', 'pkg_prerm', 'pkg_postrm',
-		'pkg_config')))
-	in_phase = ''
-
-	def check(self, num, line):
-		m = self.phases_re.match(line)
-		if m is not None:
-			self.in_phase = m.group(1)
-		if self.in_phase != '' and self.func_end_re.match(line) is not None:
-			self.in_phase = ''
-
-		return self.phase_check(num, line)
-
-	def phase_check(self, num, line):
-		""" override this function for your checks """
-		pass
-
-
-class EbuildHeader(LineCheck):
-	"""Ensure ebuilds have proper headers
-		Copyright header errors
-		CVS header errors
-		License header errors
-
-	Args:
-		modification_year - Year the ebuild was last modified
-	"""
-
-	repoman_check_name = 'ebuild.badheader'
-
-	gentoo_copyright = r'^# Copyright ((1999|2\d\d\d)-)?%s Gentoo Foundation$'
-	gentoo_license = (
-		'# Distributed under the terms'
-		' of the GNU General Public License v2')
-	id_header_re = re.compile(r'.*\$(Id|Header)(:.*)?\$.*')
-	blank_line_re = re.compile(r'^$')
-	ignore_comment = False
-
-	def new(self, pkg):
-		if pkg.mtime is None:
-			self.modification_year = r'2\d\d\d'
-		else:
-			self.modification_year = str(time.gmtime(pkg.mtime)[0])
-		self.gentoo_copyright_re = re.compile(
-			self.gentoo_copyright % self.modification_year)
-
-	def check(self, num, line):
-		if num > 2:
-			return
-		elif num == 0:
-			if not self.gentoo_copyright_re.match(line):
-				return errors.COPYRIGHT_ERROR
-		elif num == 1 and line.rstrip('\n') != self.gentoo_license:
-			return errors.LICENSE_ERROR
-		elif num == 2 and self.id_header_re.match(line):
-			return errors.ID_HEADER_ERROR
-		elif num == 2 and not self.blank_line_re.match(line):
-			return errors.NO_BLANK_LINE_ERROR
-
-
-class EbuildWhitespace(LineCheck):
-	"""Ensure ebuilds have proper whitespacing"""
-
-	repoman_check_name = 'ebuild.minorsyn'
-
-	ignore_line = re.compile(r'(^$)|(^(\t)*#)')
-	ignore_comment = False
-	leading_spaces = re.compile(r'^[\S\t]')
-	trailing_whitespace = re.compile(r'.*([\S]$)')
-
-	def check(self, num, line):
-		if self.leading_spaces.match(line) is None:
-			return errors.LEADING_SPACES_ERROR
-		if self.trailing_whitespace.match(line) is None:
-			return errors.TRAILING_WHITESPACE_ERROR
-
-
-class EbuildBlankLine(LineCheck):
-	repoman_check_name = 'ebuild.minorsyn'
-	ignore_comment = False
-	blank_line = re.compile(r'^$')
-
-	def new(self, pkg):
-		self.line_is_blank = False
-
-	def check(self, num, line):
-		if self.line_is_blank and self.blank_line.match(line):
-			return 'Useless blank line on line: %d'
-		if self.blank_line.match(line):
-			self.line_is_blank = True
-		else:
-			self.line_is_blank = False
-
-	def end(self):
-		if self.line_is_blank:
-			yield 'Useless blank line on last line'
-
-
-class EbuildQuote(LineCheck):
-	"""Ensure ebuilds have valid quoting around things like D,FILESDIR, etc..."""
-
-	repoman_check_name = 'ebuild.minorsyn'
-	_message_commands = [
-		"die", "echo", "eerror", "einfo", "elog", "eqawarn", "ewarn"]
-	_message_re = re.compile(
-		r'\s(' + "|".join(_message_commands) + r')\s+"[^"]*"\s*$')
-	_ignored_commands = ["local", "export"] + _message_commands
-	ignore_line = re.compile(
-		r'(^$)|(^\s*#.*)|(^\s*\w+=.*)' +
-		r'|(^\s*(' + "|".join(_ignored_commands) + r')\s+)')
-	ignore_comment = False
-	var_names = ["D", "DISTDIR", "FILESDIR", "S", "T", "ROOT", "WORKDIR"]
-
-	# EAPI=3/Prefix vars
-	var_names += ["ED", "EPREFIX", "EROOT"]
-
-	# variables for games.eclass
-	var_names += [
-		"Ddir", "GAMES_PREFIX_OPT", "GAMES_DATADIR",
-		"GAMES_DATADIR_BASE", "GAMES_SYSCONFDIR", "GAMES_STATEDIR",
-		"GAMES_LOGDIR", "GAMES_BINDIR"]
-
-	# variables for multibuild.eclass
-	var_names += ["BUILD_DIR"]
-
-	var_names = "(%s)" % "|".join(var_names)
-	var_reference = re.compile(
-		r'\$(\{%s\}|%s\W)' % (var_names, var_names))
-	missing_quotes = re.compile(
-		r'(\s|^)[^"\'\s]*\$\{?%s\}?[^"\'\s]*(\s|$)' % var_names)
-	cond_begin = re.compile(r'(^|\s+)\[\[($|\\$|\s+)')
-	cond_end = re.compile(r'(^|\s+)\]\]($|\\$|\s+)')
-
-	def check(self, num, line):
-		if self.var_reference.search(line) is None:
-			return
-		# There can be multiple matches / violations on a single line. We
-		# have to make sure none of the matches are violators. Once we've
-		# found one violator, any remaining matches on the same line can
-		# be ignored.
-		pos = 0
-		while pos <= len(line) - 1:
-			missing_quotes = self.missing_quotes.search(line, pos)
-			if not missing_quotes:
-				break
-			# If the last character of the previous match is a whitespace
-			# character, that character may be needed for the next
-			# missing_quotes match, so search overlaps by 1 character.
-			group = missing_quotes.group()
-			pos = missing_quotes.end() - 1
-
-			# Filter out some false positives that can
-			# get through the missing_quotes regex.
-			if self.var_reference.search(group) is None:
-				continue
-
-			# Filter matches that appear to be an
-			# argument to a message command.
-			# For example: false || ewarn "foo $WORKDIR/bar baz"
-			message_match = self._message_re.search(line)
-			if message_match is not None and \
-				message_match.start() < pos and \
-				message_match.end() > pos:
-				break
-
-			# This is an attempt to avoid false positives without getting
-			# too complex, while possibly allowing some (hopefully
-			# unlikely) violations to slip through. We just assume
-			# everything is correct if the there is a ' [[ ' or a ' ]] '
-			# anywhere in the whole line (possibly continued over one
-			# line).
-			if self.cond_begin.search(line) is not None:
-				continue
-			if self.cond_end.search(line) is not None:
-				continue
-
-			# Any remaining matches on the same line can be ignored.
-			return errors.MISSING_QUOTES_ERROR
-
-
-class EbuildAssignment(LineCheck):
-	"""Ensure ebuilds don't assign to readonly variables."""
-
-	repoman_check_name = 'variable.readonly'
-	read_only_vars = 'A|CATEGORY|P|P[VNRF]|PVR|D|WORKDIR|FILESDIR|FEATURES|USE'
-	readonly_assignment = re.compile(r'^\s*(export\s+)?(%s)=' % read_only_vars)
-
-	def check(self, num, line):
-		match = self.readonly_assignment.match(line)
-		e = None
-		if match is not None:
-			e = errors.READONLY_ASSIGNMENT_ERROR
-		return e
-
-
-class Eapi3EbuildAssignment(EbuildAssignment):
-	"""Ensure ebuilds don't assign to readonly EAPI 3-introduced variables."""
-
-	readonly_assignment = re.compile(r'\s*(export\s+)?(ED|EPREFIX|EROOT)=')
-
-	def check_eapi(self, eapi):
-		return eapi_supports_prefix(eapi)
-
-
-class EbuildNestedDie(LineCheck):
-	"""Check ebuild for nested die statements (die statements in subshells)"""
-
-	repoman_check_name = 'ebuild.nesteddie'
-	nesteddie_re = re.compile(r'^[^#]*\s\(\s[^)]*\bdie\b')
-
-	def check(self, num, line):
-		if self.nesteddie_re.match(line):
-			return errors.NESTED_DIE_ERROR
-
-
-class EbuildUselessDodoc(LineCheck):
-	"""Check ebuild for useless files in dodoc arguments."""
-	repoman_check_name = 'ebuild.minorsyn'
-	uselessdodoc_re = re.compile(
-		r'^\s*dodoc(\s+|\s+.*\s+)(ABOUT-NLS|COPYING|LICENCE|LICENSE)($|\s)')
-
-	def check(self, num, line):
-		match = self.uselessdodoc_re.match(line)
-		if match:
-			return "Useless dodoc '%s'" % (match.group(2), ) + " on line: %d"
-
-
-class EbuildUselessCdS(LineCheck):
-	"""Check for redundant cd ${S} statements"""
-	repoman_check_name = 'ebuild.minorsyn'
-	_src_phases = r'^\s*src_(prepare|configure|compile|install|test)\s*\(\)'
-	method_re = re.compile(_src_phases)
-	cds_re = re.compile(r'^\s*cd\s+("\$(\{S\}|S)"|\$(\{S\}|S))\s')
-
-	def __init__(self):
-		self.check_next_line = False
-
-	def check(self, num, line):
-		if self.check_next_line:
-			self.check_next_line = False
-			if self.cds_re.match(line):
-				return errors.REDUNDANT_CD_S_ERROR
-		elif self.method_re.match(line):
-			self.check_next_line = True
-
-
-class EapiDefinition(LineCheck):
-	"""
-	Check that EAPI assignment conforms to PMS section 7.3.1
-	(first non-comment, non-blank line).
-	"""
-	repoman_check_name = 'EAPI.definition'
-	ignore_comment = True
-	_eapi_re = portage._pms_eapi_re
-
-	def new(self, pkg):
-		self._cached_eapi = pkg.eapi
-		self._parsed_eapi = None
-		self._eapi_line_num = None
-
-	def check(self, num, line):
-		if self._eapi_line_num is None and line.strip():
-			self._eapi_line_num = num + 1
-			m = self._eapi_re.match(line)
-			if m is not None:
-				self._parsed_eapi = m.group(2)
-
-	def end(self):
-		if self._parsed_eapi is None:
-			if self._cached_eapi != "0":
-				yield "valid EAPI assignment must occur on or before line: %s" % \
-					self._eapi_line_num
-		elif self._parsed_eapi != self._cached_eapi:
-			yield (
-				"bash returned EAPI '%s' which does not match "
-				"assignment on line: %s" %
-				(self._cached_eapi, self._eapi_line_num))
-
-
-class EbuildPatches(LineCheck):
-	"""Ensure ebuilds use bash arrays for PATCHES to ensure white space safety"""
-	repoman_check_name = 'ebuild.patches'
-	re = re.compile(r'^\s*PATCHES=[^\(]')
-	error = errors.PATCHES_ERROR
-
-	def check_eapi(self, eapi):
-		return eapi in ("0", "1", "2", "3", "4", "4-python",
-			"4-slot-abi", "5", "5-hdepend", "5-progress")
-
-
-class EbuildQuotedA(LineCheck):
-	"""Ensure ebuilds have no quoting around ${A}"""
-
-	repoman_check_name = 'ebuild.minorsyn'
-	a_quoted = re.compile(r'.*\"\$(\{A\}|A)\"')
-
-	def check(self, num, line):
-		match = self.a_quoted.match(line)
-		if match:
-			return "Quoted \"${A}\" on line: %d"
-
-
-class NoOffsetWithHelpers(LineCheck):
-	""" Check that the image location, the alternate root offset, and the
-	offset prefix (D, ROOT, ED, EROOT and EPREFIX) are not used with
-	helpers """
-
-	repoman_check_name = 'variable.usedwithhelpers'
-	# Ignore matches in quoted strings like this:
-	# elog "installed into ${ROOT}usr/share/php5/apc/."
-	_install_funcs = (
-		'docinto|do(compress|dir|hard)'
-		'|exeinto|fowners|fperms|insinto|into')
-	_quoted_vars = 'D|ROOT|ED|EROOT|EPREFIX'
-	re = re.compile(
-		r'^[^#"\']*\b(%s)\s+"?\$\{?(%s)\b.*' %
-		(_install_funcs, _quoted_vars))
-	error = errors.NO_OFFSET_WITH_HELPERS
-
-
-class ImplicitRuntimeDeps(LineCheck):
-	"""
-	Detect the case where DEPEND is set and RDEPEND is unset in the ebuild,
-	since this triggers implicit RDEPEND=$DEPEND assignment (prior to EAPI 4).
-	"""
-
-	repoman_check_name = 'RDEPEND.implicit'
-	_assignment_re = re.compile(r'^\s*(R?DEPEND)\+?=')
-
-	def new(self, pkg):
-		self._rdepend = False
-		self._depend = False
-
-	def check_eapi(self, eapi):
-		# Beginning with EAPI 4, there is no
-		# implicit RDEPEND=$DEPEND assignment
-		# to be concerned with.
-		return eapi_has_implicit_rdepend(eapi)
-
-	def check(self, num, line):
-		if not self._rdepend:
-			m = self._assignment_re.match(line)
-			if m is None:
-				pass
-			elif m.group(1) == "RDEPEND":
-				self._rdepend = True
-			elif m.group(1) == "DEPEND":
-				self._depend = True
-
-	def end(self):
-		if self._depend and not self._rdepend:
-			yield 'RDEPEND is not explicitly assigned'
-
-
-class InheritDeprecated(LineCheck):
-	"""Check if ebuild directly or indirectly inherits a deprecated eclass."""
-
-	repoman_check_name = 'inherit.deprecated'
-
-	# deprecated eclass : new eclass (False if no new eclass)
-	deprecated_eclasses = {
-		"autotools-multilib": "multilib-minimal",
-		"autotools-utils": False,
-		"base": False,
-		"bash-completion": "bash-completion-r1",
-		"boost-utils": False,
-		"clutter": "gnome2",
-		"confutils": False,
-		"distutils": "distutils-r1",
-		"fdo-mime": "xdg-utils",
-		"games": False,
-		"gems": "ruby-fakegem",
-		"git-2": "git-r3",
-		"gpe": False,
-		"gst-plugins-bad": "gstreamer",
-		"gst-plugins-base": "gstreamer",
-		"gst-plugins-good": "gstreamer",
-		"gst-plugins-ugly": "gstreamer",
-		"gst-plugins10": "gstreamer",
-		"mono": "mono-env",
-		"python": "python-r1 / python-single-r1 / python-any-r1",
-		"ruby": "ruby-ng",
-		"x-modular": "xorg-2",
-		"xfconf": False,
-	}
-
-	_inherit_re = re.compile(r'^\s*inherit\s(.*)$')
-
-	def new(self, pkg):
-		self._errors = []
-
-	def check(self, num, line):
-		direct_inherits = None
-		m = self._inherit_re.match(line)
-		if m is not None:
-			direct_inherits = m.group(1)
-			if direct_inherits:
-				direct_inherits = direct_inherits.split()
-
-		if not direct_inherits:
-			return
-
-		for eclass in direct_inherits:
-			replacement = self.deprecated_eclasses.get(eclass)
-			if replacement is None:
-				pass
-			elif replacement is False:
-				self._errors.append(
-					"please migrate from "
-					"'%s' (no replacement) on line: %d" % (eclass, num + 1))
-			else:
-				self._errors.append(
-					"please migrate from "
-					"'%s' to '%s' on line: %d" % (eclass, replacement, num + 1))
-
-	def end(self):
-		for error in self._errors:
-			yield error
-		del self._errors
-
-
-
-class InheritEclass(LineCheck):
-	"""
-	Base class for checking for missing inherits, as well as excess inherits.
-
-	Args:
-		eclass: Set to the name of your eclass.
-		funcs: A tuple of functions that this eclass provides.
-		comprehensive: Is the list of functions complete?
-		exempt_eclasses: If these eclasses are inherited, disable the missing
-			inherit check.
-	"""
-
-	def __init__(
-		self, eclass, funcs=None, comprehensive=False,
-		exempt_eclasses=None, ignore_missing=False, **kwargs):
-		self._eclass = eclass
-		self._comprehensive = comprehensive
-		self._exempt_eclasses = exempt_eclasses
-		self._ignore_missing = ignore_missing
-		inherit_re = eclass
-		self._inherit_re = re.compile(
-			r'^(\s*|.*[|&]\s*)\binherit\s(.*\s)?%s(\s|$)' % inherit_re)
-		# Match when the function is preceded only by leading whitespace, a
-		# shell operator such as (, {, |, ||, or &&, or optional variable
-		# setting(s). This prevents false positives in things like elog
-		# messages, as reported in bug #413285.
-		self._func_re = re.compile(
-			r'(^|[|&{(])\s*(\w+=.*)?\b(' + '|'.join(funcs) + r')\b')
-
-	def new(self, pkg):
-		self.repoman_check_name = 'inherit.missing'
-		# We can't use pkg.inherited because that tells us all the eclasses that
-		# have been inherited and not just the ones we inherit directly.
-		self._inherit = False
-		self._func_call = False
-		if self._exempt_eclasses is not None:
-			inherited = pkg.inherited
-			self._disabled = any(x in inherited for x in self._exempt_eclasses)
-		else:
-			self._disabled = False
-		self._eapi = pkg.eapi
-
-	def check(self, num, line):
-		if not self._inherit:
-			self._inherit = self._inherit_re.match(line)
-		if not self._inherit:
-			if self._disabled or self._ignore_missing:
-				return
-			s = self._func_re.search(line)
-			if s is not None:
-				func_name = s.group(3)
-				eapi_func = _eclass_eapi_functions.get(func_name)
-				if eapi_func is None or not eapi_func(self._eapi):
-					self._func_call = True
-					return (
-						'%s.eclass is not inherited, '
-						'but "%s" found at line: %s' %
-						(self._eclass, func_name, '%d'))
-		elif not self._func_call:
-			self._func_call = self._func_re.search(line)
-
-	def end(self):
-		if not self._disabled and self._comprehensive and self._inherit \
-			and not self._func_call:
-			self.repoman_check_name = 'inherit.unused'
-			yield 'no function called from %s.eclass; please drop' % self._eclass
-
-_usex_supported_eapis = ("0", "1", "2", "3", "4", "4-python", "4-slot-abi")
-_in_iuse_supported_eapis = ("0", "1", "2", "3", "4", "4-python", "4-slot-abi",
-		"5", "5-hdepend", "5-progress")
-_get_libdir_supported_eapis = _in_iuse_supported_eapis
-_eclass_eapi_functions = {
-	"usex": lambda eapi: eapi not in _usex_supported_eapis,
-	"in_iuse": lambda eapi: eapi not in _in_iuse_supported_eapis,
-	"get_libdir": lambda eapi: eapi not in _get_libdir_supported_eapis,
-}
-
-# eclasses that export ${ECLASS}_src_(compile|configure|install)
-_eclass_export_functions = (
-	'ant-tasks', 'apache-2', 'apache-module', 'aspell-dict',
-	'autotools-utils', 'base', 'bsdmk', 'cannadic',
-	'clutter', 'cmake-utils', 'db', 'distutils', 'elisp',
-	'embassy', 'emboss', 'emul-linux-x86', 'enlightenment',
-	'font-ebdftopcf', 'font', 'fox', 'freebsd', 'freedict',
-	'games', 'games-ggz', 'games-mods', 'gdesklets',
-	'gems', 'gkrellm-plugin', 'gnatbuild', 'gnat', 'gnome2',
-	'gnome-python-common', 'gnustep-base', 'go-mono', 'gpe',
-	'gst-plugins-bad', 'gst-plugins-base', 'gst-plugins-good',
-	'gst-plugins-ugly', 'gtk-sharp-module', 'haskell-cabal',
-	'horde', 'java-ant-2', 'java-pkg-2', 'java-pkg-simple',
-	'java-virtuals-2', 'kde4-base', 'kde4-meta', 'kernel-2',
-	'latex-package', 'linux-mod', 'mozlinguas', 'myspell',
-	'myspell-r2', 'mysql', 'mysql-v2', 'mythtv-plugins',
-	'oasis', 'obs-service', 'office-ext', 'perl-app',
-	'perl-module', 'php-ext-base-r1', 'php-ext-pecl-r2',
-	'php-ext-source-r2', 'php-lib-r1', 'php-pear-lib-r1',
-	'php-pear-r1', 'python-distutils-ng', 'python',
-	'qt4-build', 'qt4-r2', 'rox-0install', 'rox', 'ruby',
-	'ruby-ng', 'scsh', 'selinux-policy-2', 'sgml-catalog',
-	'stardict', 'sword-module', 'tetex-3', 'tetex',
-	'texlive-module', 'toolchain-binutils', 'toolchain',
-	'twisted', 'vdr-plugin-2', 'vdr-plugin', 'vim',
-	'vim-plugin', 'vim-spell', 'virtuoso', 'vmware',
-	'vmware-mod', 'waf-utils', 'webapp', 'xemacs-elisp',
-	'xemacs-packages', 'xfconf', 'x-modular', 'xorg-2',
-	'zproduct'
-)
-
-_eclass_info = {
-	'autotools': {
-		'funcs': (
-			'eaclocal', 'eautoconf', 'eautoheader',
-			'eautomake', 'eautoreconf', '_elibtoolize',
-			'eautopoint'
-		),
-		'comprehensive': True,
-
-		# Exempt eclasses:
-		# git - An EGIT_BOOTSTRAP variable may be used to call one of
-		#       the autotools functions.
-		# subversion - An ESVN_BOOTSTRAP variable may be used to call one of
-		#       the autotools functions.
-		'exempt_eclasses': ('git', 'git-2', 'subversion', 'autotools-utils')
-	},
-
-	'eutils': {
-		'funcs': (
-			'estack_push', 'estack_pop', 'eshopts_push', 'eshopts_pop',
-			'eumask_push', 'eumask_pop', 'epatch', 'epatch_user',
-			'emktemp', 'edos2unix', 'in_iuse', 'use_if_iuse', 'usex'
-		),
-		'comprehensive': False,
-
-		# These are "eclasses are the whole ebuild" type thing.
-		'exempt_eclasses': _eclass_export_functions,
-	},
-
-	'flag-o-matic': {
-		'funcs': (
-			'filter-(ld)?flags', 'strip-flags', 'strip-unsupported-flags',
-			'append-((ld|c(pp|xx)?))?flags', 'append-libs',
-		),
-		'comprehensive': False
-	},
-
-	'libtool': {
-		'funcs': (
-			'elibtoolize',
-		),
-		'comprehensive': True,
-		'exempt_eclasses': ('autotools',)
-	},
-
-	'multilib': {
-		'funcs': (
-			'get_libdir',
-		),
-
-		# These are "eclasses are the whole ebuild" type thing.
-		'exempt_eclasses': _eclass_export_functions + (
-			'autotools', 'libtool', 'multilib-minimal'),
-
-		'comprehensive': False
-	},
-
-	'multiprocessing': {
-		'funcs': (
-			'makeopts_jobs',
-		),
-		'comprehensive': False
-	},
-
-	'prefix': {
-		'funcs': (
-			'eprefixify',
-		),
-		'comprehensive': True
-	},
-
-	'toolchain-funcs': {
-		'funcs': (
-			'gen_usr_ldscript',
-		),
-		'comprehensive': False
-	},
-
-	'user': {
-		'funcs': (
-			'enewuser', 'enewgroup',
-			'egetent', 'egethome', 'egetshell', 'esethome'
-		),
-		'comprehensive': True
-	}
-}
-
-
-class EMakeParallelDisabled(PhaseCheck):
-	"""Check for emake -j1 calls which disable parallelization."""
-	repoman_check_name = 'upstream.workaround'
-	re = re.compile(r'^\s*emake\s+.*-j\s*1\b')
-	error = errors.EMAKE_PARALLEL_DISABLED
-
-	def phase_check(self, num, line):
-		if self.in_phase == 'src_compile' or self.in_phase == 'src_install':
-			if self.re.match(line):
-				return self.error
-
-
-class EMakeParallelDisabledViaMAKEOPTS(LineCheck):
-	"""Check for MAKEOPTS=-j1 that disables parallelization."""
-	repoman_check_name = 'upstream.workaround'
-	re = re.compile(r'^\s*MAKEOPTS=(\'|")?.*-j\s*1\b')
-	error = errors.EMAKE_PARALLEL_DISABLED_VIA_MAKEOPTS
-
-
-class UriUseHttps(LineCheck):
-	"""Check that we use https:// for known good sites."""
-	repoman_check_name = 'uri.https'
-	_SITES = (
-		'([-._a-zA-Z0-9]*\.)?apache\.org',
-		'((alioth|packages(\.qa)?|people|www)\.)?debian\.org',
-		# Most FDO sites support https, but not all (like tango).
-		# List the most common ones here for now.
-		'((anongit|bugs|cgit|dri|patchwork|people|specifications|www|xcb|xorg)\.)?freedesktop\.org',
-		'((bugs|dev|wiki|www)\.)?gentoo\.org',
-		'((wiki)\.)?github\.(io|com)',
-		'savannah\.(non)?gnu\.org',
-		'((gcc|www)\.)?gnu\.org',
-		'curl\.haxx\.se',
-		'((bugzilla|git|mirrors|patchwork|planet|www(\.wiki)?)\.)?kernel\.org',
-		'((bugs|wiki|www)\.)?linuxfoundation\.org',
-		'((docs|pypi|www)\.)?python\.org',
-		'(sf|sourceforge)\.net',
-		'(www\.)?(enlightenment|sourceware|x)\.org',
-	)
-	# Try to anchor the end of the URL so we don't get false positives
-	# with http://github.com.foo.bar.com/.  Unlikely, but possible.
-	re = re.compile(r'.*\bhttp://(%s)(\s|["\'/]|$)' % r'|'.join(_SITES))
-	error = errors.URI_HTTPS
-
-
-class NoAsNeeded(LineCheck):
-	"""Check for calls to the no-as-needed function."""
-	repoman_check_name = 'upstream.workaround'
-	re = re.compile(r'.*\$\(no-as-needed\)')
-	error = errors.NO_AS_NEEDED
-
-
-class PreserveOldLib(LineCheck):
-	"""Check for calls to the deprecated preserve_old_lib function."""
-	repoman_check_name = 'ebuild.minorsyn'
-	re = re.compile(r'.*preserve_old_lib')
-	error = errors.PRESERVE_OLD_LIB
-
-
-class SandboxAddpredict(LineCheck):
-	"""Check for calls to the addpredict function."""
-	repoman_check_name = 'upstream.workaround'
-	re = re.compile(r'(^|\s)addpredict\b')
-	error = errors.SANDBOX_ADDPREDICT
-
-
-class DeprecatedBindnowFlags(LineCheck):
-	"""Check for calls to the deprecated bindnow-flags function."""
-	repoman_check_name = 'ebuild.minorsyn'
-	re = re.compile(r'.*\$\(bindnow-flags\)')
-	error = errors.DEPRECATED_BINDNOW_FLAGS
-
-
-class WantAutoDefaultValue(LineCheck):
-	"""Check setting WANT_AUTO* to latest (default value)."""
-	repoman_check_name = 'ebuild.minorsyn'
-	_re = re.compile(r'^WANT_AUTO(CONF|MAKE)=(\'|")?latest')
-
-	def check(self, num, line):
-		m = self._re.match(line)
-		if m is not None:
-			return 'WANT_AUTO' + m.group(1) + \
-				' redundantly set to default value "latest" on line: %d'
-
-
-class SrcCompileEconf(PhaseCheck):
-	repoman_check_name = 'ebuild.minorsyn'
-	configure_re = re.compile(r'\s(econf|./configure)')
-
-	def check_eapi(self, eapi):
-		return eapi_has_src_prepare_and_src_configure(eapi)
-
-	def phase_check(self, num, line):
-		if self.in_phase == 'src_compile':
-			m = self.configure_re.match(line)
-			if m is not None:
-				return ("'%s'" % m.group(1)) + \
-					" call should be moved to src_configure from line: %d"
-
-
-class SrcUnpackPatches(PhaseCheck):
-	repoman_check_name = 'ebuild.minorsyn'
-	src_prepare_tools_re = re.compile(r'\s(e?patch|sed)\s')
-
-	def check_eapi(self, eapi):
-		return eapi_has_src_prepare_and_src_configure(eapi)
-
-	def phase_check(self, num, line):
-		if self.in_phase == 'src_unpack':
-			m = self.src_prepare_tools_re.search(line)
-			if m is not None:
-				return ("'%s'" % m.group(1)) + \
-					" call should be moved to src_prepare from line: %d"
-
-
-class BuiltWithUse(LineCheck):
-	repoman_check_name = 'ebuild.minorsyn'
-	re = re.compile(r'(^|.*\b)built_with_use\b')
-	error = errors.BUILT_WITH_USE
-
-
-class DeprecatedUseq(LineCheck):
-	"""Checks for use of the deprecated useq function"""
-	repoman_check_name = 'ebuild.minorsyn'
-	re = re.compile(r'(^|.*\b)useq\b')
-	error = errors.USEQ_ERROR
-
-
-class DeprecatedHasq(LineCheck):
-	"""Checks for use of the deprecated hasq function"""
-	repoman_check_name = 'ebuild.minorsyn'
-	re = re.compile(r'(^|.*\b)hasq\b')
-	error = errors.HASQ_ERROR
-
-
-# EAPI <2 checks
-class UndefinedSrcPrepareSrcConfigurePhases(LineCheck):
-	repoman_check_name = 'EAPI.incompatible'
-	src_configprepare_re = re.compile(r'\s*(src_configure|src_prepare)\s*\(\)')
-
-	def check_eapi(self, eapi):
-		return not eapi_has_src_prepare_and_src_configure(eapi)
-
-	def check(self, num, line):
-		m = self.src_configprepare_re.match(line)
-		if m is not None:
-			return ("'%s'" % m.group(1)) + \
-				" phase is not defined in EAPI < 2 on line: %d"
-
-
-# EAPI-3 checks
-class Eapi3DeprecatedFuncs(LineCheck):
-	repoman_check_name = 'EAPI.deprecated'
-	deprecated_commands_re = re.compile(r'^\s*(check_license)\b')
-
-	def check_eapi(self, eapi):
-		return eapi not in ('0', '1', '2')
-
-	def check(self, num, line):
-		m = self.deprecated_commands_re.match(line)
-		if m is not None:
-			return ("'%s'" % m.group(1)) + \
-				" has been deprecated in EAPI=3 on line: %d"
-
-
-# EAPI <4 checks
-class UndefinedPkgPretendPhase(LineCheck):
-	repoman_check_name = 'EAPI.incompatible'
-	pkg_pretend_re = re.compile(r'\s*(pkg_pretend)\s*\(\)')
-
-	def check_eapi(self, eapi):
-		return not eapi_has_pkg_pretend(eapi)
-
-	def check(self, num, line):
-		m = self.pkg_pretend_re.match(line)
-		if m is not None:
-			return ("'%s'" % m.group(1)) + \
-				" phase is not defined in EAPI < 4 on line: %d"
-
-
-# EAPI-4 checks
-class Eapi4IncompatibleFuncs(LineCheck):
-	repoman_check_name = 'EAPI.incompatible'
-	banned_commands_re = re.compile(r'^\s*(dosed|dohard)')
-
-	def check_eapi(self, eapi):
-		return not eapi_has_dosed_dohard(eapi)
-
-	def check(self, num, line):
-		m = self.banned_commands_re.match(line)
-		if m is not None:
-			return ("'%s'" % m.group(1)) + \
-				" has been banned in EAPI=4 on line: %d"
-
-
-class Eapi4GoneVars(LineCheck):
-	repoman_check_name = 'EAPI.incompatible'
-	undefined_vars_re = re.compile(
-		r'.*\$(\{(AA|KV|EMERGE_FROM)\}|(AA|KV|EMERGE_FROM))')
-
-	def check_eapi(self, eapi):
-		# AA, KV, and EMERGE_FROM should not be referenced in EAPI 4 or later.
-		return not eapi_exports_AA(eapi)
-
-	def check(self, num, line):
-		m = self.undefined_vars_re.match(line)
-		if m is not None:
-			return ("variable '$%s'" % m.group(1)) + \
-				" is gone in EAPI=4 on line: %d"
-
-
-class PortageInternal(LineCheck):
-	repoman_check_name = 'portage.internal'
-	ignore_comment = True
-	# Match when the command is preceded only by leading whitespace or a shell
-	# operator such as (, {, |, ||, or &&. This prevents false positives in
-	# things like elog messages, as reported in bug #413285.
-
-	internal_portage_func_or_var = (
-		'ecompress|ecompressdir|env-update|prepall|prepalldocs|preplib')
-	re = re.compile(
-		r'^(\s*|.*[|&{(]+\s*)\b(%s)\b' % internal_portage_func_or_var)
-
-	def check(self, num, line):
-		"""Run the check on line and return error if there is one"""
-		m = self.re.match(line)
-		if m is not None:
-			return ("'%s'" % m.group(2)) + " called on line: %d"
-
-
-class PortageInternalVariableAssignment(LineCheck):
-	repoman_check_name = 'portage.internal'
-	internal_assignment = re.compile(
-		r'\s*(export\s+)?(EXTRA_ECONF|EXTRA_EMAKE)\+?=')
-
-	def check(self, num, line):
-		match = self.internal_assignment.match(line)
-		e = None
-		if match is not None:
-			e = 'Assignment to variable %s' % match.group(2)
-			e += ' on line: %d'
-		return e
-
-
-class EbuildNonRelativeDosym(LineCheck):
-	"""Check ebuild for dosym using absolute paths instead of relative."""
-	repoman_check_name = 'ebuild.absdosym'
-	regex = re.compile(
-		r'^\s*dosym\s+["\']?(/(bin|etc|lib|opt|sbin|srv|usr|var)\S*)')
-
-	def check(self, num, line):
-		match = self.regex.match(line)
-		if match:
-			return "dosym '%s'... could use relative path" % (match.group(1), ) + " on line: %d"
-
-
-_base_check_classes = (InheritEclass, LineCheck, PhaseCheck)
-_constant_checks = None
-
-
-def checks_init(experimental_inherit=False):
-
-	global _constant_checks, _eclass_info
-
-	if not experimental_inherit:
-		# Emulate the old eprefixify.defined and inherit.autotools checks.
-		_eclass_info = {
-			'autotools': {
-				'funcs': (
-					'eaclocal', 'eautoconf', 'eautoheader',
-					'eautomake', 'eautoreconf', '_elibtoolize',
-					'eautopoint'
-				),
-				'comprehensive': True,
-				'ignore_missing': True,
-				'exempt_eclasses': ('git', 'git-2', 'subversion', 'autotools-utils')
-			},
-
-			'prefix': {
-				'funcs': (
-					'eprefixify',
-				),
-				'comprehensive': False
-			}
-		}
-
-	_constant_checks = tuple(
-		chain((
-			v() for k, v in globals().items()
-			if (
-				isinstance(v, type)
-				and issubclass(v, LineCheck)
-				and v not in _base_check_classes)), (
-			InheritEclass(k, **kwargs)
-			for k, kwargs in _eclass_info.items())))
-
-
-_here_doc_re = re.compile(r'.*<<[-]?(\w+)\s*(>\s*\S+\s*)?$')
-_ignore_comment_re = re.compile(r'^\s*#')
-_continuation_re = re.compile(r'(\\)*$')
-
-
-def run_checks(contents, pkg):
-	if _constant_checks is None:
-		checks_init()
-	checks = _constant_checks
-	here_doc_delim = None
-	multiline = None
-
-	for lc in checks:
-		lc.new(pkg)
-
-	multinum = 0
-	for num, line in enumerate(contents):
-
-		# Check if we're inside a here-document.
-		if here_doc_delim is not None:
-			if here_doc_delim.match(line):
-				here_doc_delim = None
-		if here_doc_delim is None:
-			here_doc = _here_doc_re.match(line)
-			if here_doc is not None:
-				here_doc_delim = re.compile(r'^\s*%s$' % here_doc.group(1))
-		if here_doc_delim is not None:
-			continue
-
-		# Unroll multiline escaped strings so that we can check things:
-		# 	inherit foo bar \
-		# 		moo \
-		# 		cow
-		# This will merge these lines like so:
-		# 	inherit foo bar moo cow
-		# A line ending with an even number of backslashes does not count,
-		# because the last backslash is escaped. Therefore, search for an
-		# odd number of backslashes.
-		line_escaped = operator.sub(*_continuation_re.search(line).span()) % 2 == 1
-		if multiline:
-			# Chop off the \ and \n bytes from the previous line.
-			multiline = multiline[:-2] + line
-			if not line_escaped:
-				line = multiline
-				num = multinum
-				multiline = None
-			else:
-				continue
-		else:
-			if line_escaped:
-				multinum = num
-				multiline = line
-				continue
-
-		if not line.endswith("#nowarn\n"):
-			# Finally we have a full line to parse.
-			is_comment = _ignore_comment_re.match(line) is not None
-			for lc in checks:
-				if is_comment and lc.ignore_comment:
-					continue
-				if lc.check_eapi(pkg.eapi):
-					ignore = lc.ignore_line
-					if not ignore or not ignore.match(line):
-						e = lc.check(num, line)
-						if e:
-							yield lc.repoman_check_name, e % (num + 1)
-
-	for lc in checks:
-		i = lc.end()
-		if i is not None:
-			for e in i:
-				yield lc.repoman_check_name, e