def is_path_excluded(self, path):
# type: (str) -> bool
"""Check if a path is excluded.
:param str path:
Path to check against the exclude patterns.
:returns:
True if there are exclude patterns and the path matches,
otherwise False.
:rtype:
bool
"""
exclude = self.options.exclude
if not exclude:
return False
basename = os.path.basename(path)
if utils.fnmatch(basename, exclude):
LOG.info('"%s" has been excluded', basename)
return True
absolute_path = os.path.abspath(path)
match = utils.fnmatch(absolute_path, exclude)
LOG.info('"%s" has %sbeen excluded', absolute_path,
'' if match else 'not ')
return match
def is_path_excluded(self, path):
# type: (str) -> bool
"""Check if a path is excluded.
:param str path:
Path to check against the exclude patterns.
:returns:
True if there are exclude patterns and the path matches,
otherwise False.
:rtype:
bool
"""
if path == '-':
if self.options.stdin_display_name == 'stdin':
return False
path = self.options.stdin_display_name
exclude = self.options.exclude
if not exclude:
return False
basename = os.path.basename(path)
if utils.fnmatch(basename, exclude):
LOG.debug('"%s" has been excluded', basename)
return True
absolute_path = os.path.abspath(path)
match = utils.fnmatch(absolute_path, exclude)
LOG.debug('"%s" has %sbeen excluded', absolute_path,
'' if match else 'not ')
return match
def is_path_excluded(self, path):
# type: (str) -> bool
"""Check if a path is excluded.
:param str path:
Path to check against the exclude patterns.
:returns:
True if there are exclude patterns and the path matches,
otherwise False.
:rtype:
bool
"""
if path == "-":
if self.options.stdin_display_name == "stdin":
return False
path = self.options.stdin_display_name
exclude = self.options.exclude
if not exclude:
return False
basename = os.path.basename(path)
if utils.fnmatch(basename, exclude):
LOG.debug('"%s" has been excluded', basename)
return True
absolute_path = os.path.abspath(path)
match = utils.fnmatch(absolute_path, exclude)
LOG.debug(
'"%s" has %sbeen excluded', absolute_path, "" if match else "not "
)
return match
def get_plugin_rules(plugin_name: str, plugins: PluginsType) -> List[str]:
"""Get rules for plugin from `plugins` in the config
Plugin name can be specified as a glob expression.
So, it's not trivial to match the right one
1. Try to find exact match (normalizing ass all packages names normalized)
2. Try to find globs that match and select the longest one (nginx-style)
3. Return empty list if nothing is found.
"""
if not plugins:
return []
plugin_name = REX_NAME.sub('-', plugin_name).lower()
# try to find exact match
for pattern, rules in plugins.items():
if '*' not in pattern and REX_NAME.sub('-',
pattern).lower() == plugin_name:
return rules
# try to find match by pattern and select the longest
best_match = (0, []) # type: Tuple[int, List[str]]
for pattern, rules in plugins.items():
if not fnmatch(filename=plugin_name, patterns=[pattern]):
continue
match = len(pattern)
if match > best_match[0]:
best_match = match, rules
if best_match[0]:
return best_match[1]
return []
def should_create_file_checker(filename):
"""Determine if we should create a file checker."""
matches_filename_patterns = utils.fnmatch(filename,
filename_patterns)
is_stdin = filename == '-'
file_exists = os.path.exists(filename)
return (file_exists and matches_filename_patterns) or is_stdin
def check_include(code: str, rules: List[str]) -> bool:
"""
0. Validate rules
1. Return True if rule explicitly included
2. Return False if rule explicitly excluded
3. Return True if the latest glob-matching rule is include
4. Return False if the latest glob-matching rule is exclude
"""
# always report exceptions in file processing
if code in ('E902', 'E999'):
return True
for rule in rules:
if len(rule) < 2 or rule[0] not in {'-', '+'}:
raise ValueError('invalid rule: `{}`'.format(rule))
for rule in reversed(rules):
if code.lower() == rule[1:].lower():
return rule[0] == '+'
include = False
for rule in rules:
if fnmatch(code, patterns=[rule[1:]]):
include = rule[0] == '+'
return include
def get_exceptions(
path: Union[str, Path],
exceptions: Dict[str, PluginsType],
root: Path = None,
) -> PluginsType:
if not exceptions:
return dict()
if isinstance(path, str):
path = Path(path)
if root is None:
root = Path().resolve()
path = path.resolve().relative_to(root).as_posix()
exceptions = sorted(
exceptions.items(),
key=lambda item: len(item[0]),
reverse=True,
)
# prefix
for path_rule, rules in exceptions:
if '*' in path_rule:
continue
if path.startswith(path_rule):
return rules
# glob
for path_rule, rules in exceptions:
if '*' not in path_rule:
continue
if fnmatch(filename=path, patterns=[path_rule]):
return rules
return dict()
def should_create_file_checker(filename):
"""Determine if we should create a file checker."""
matches_filename_patterns = utils.fnmatch(
filename, filename_patterns
)
is_stdin = filename == '-'
file_exists = os.path.exists(filename)
return (file_exists and matches_filename_patterns) or is_stdin
def _should_create_file_checker(self, filename: str, argument) -> bool:
"""Filter out excluded files
"""
if filename == '-':
return True
if fnmatch(filename=filename, patterns=self.options.filename):
return True
if self.options._running_from_vcs:
return False
if self.options.diff:
return False
return argument == filename
def should_create_file_checker(filename, argument):
"""Determine if we should create a file checker."""
matches_filename_patterns = utils.fnmatch(filename,
filename_patterns)
is_stdin = filename == "-"
# NOTE(sigmavirus24): If a user explicitly specifies something,
# e.g, ``flake8 bin/script`` then we should run Flake8 against
# that. Since should_create_file_checker looks to see if the
# filename patterns match the filename, we want to skip that in
# the event that the argument and the filename are identical.
# If it was specified explicitly, the user intended for it to be
# checked.
explicitly_provided = not running_from_diff and (argument
== filename)
return (explicitly_provided
or matches_filename_patterns) or is_stdin
def should_create_file_checker(filename, argument):
"""Determine if we should create a file checker."""
matches_filename_patterns = utils.fnmatch(
filename, filename_patterns
)
is_stdin = filename == '-'
file_exists = os.path.exists(filename)
# NOTE(sigmavirus24): If a user explicitly specifies something,
# e.g, ``flake8 bin/script`` then we should run Flake8 against
# that. Since should_create_file_checker looks to see if the
# filename patterns match the filename, we want to skip that in
# the event that the argument and the filename are identical.
# If it was specified explicitly, the user intended for it to be
# checked.
explicitly_provided = (not running_from_vcs and
not running_from_diff and
(argument == filename))
return ((file_exists and
(explicitly_provided or matches_filename_patterns)) or
is_stdin)
def get_exceptions(
path: Union[str, Path],
exceptions: Dict[str, PluginsType],
root: Path = None,
) -> PluginsType:
if not exceptions:
return dict()
if isinstance(path, str):
path = Path(path)
if root is None:
root = Path().resolve()
try:
path = path.resolve().relative_to(root).as_posix()
except ValueError:
# path is not in the project root
return dict()
exceptions = sorted(
exceptions.items(),
key=lambda item: len(item[0]),
reverse=True,
)
aggregated_rules = defaultdict(list)
# prefix
for path_rule, rules in exceptions:
if '*' in path_rule:
continue
if path.startswith(path_rule):
for plugin_name, exception_list in rules.items():
aggregated_rules[plugin_name].extend(exception_list)
# glob
for path_rule, rules in exceptions:
if '*' not in path_rule:
continue
if fnmatch(filename=path, patterns=[path_rule]):
for plugin_name, exception_list in rules.items():
aggregated_rules[plugin_name].extend(exception_list)
return aggregated_rules
def _should_process(
self,
argument: str,
filename: str,
check_type: str,
check: Dict[str, Any],
) -> bool:
# do not run plugins without rules specified
plugin_name = get_plugin_name(check)
rules = self._get_rules(plugin_name=plugin_name, filename=filename)
if not rules or set(rules) == {'-*'}:
return False
if filename == '-':
return True
if fnmatch(filename=filename, patterns=self.options.filename):
return True
if self.options._running_from_vcs:
return False
if self.options.diff:
return False
return argument == filename
def check_include(code, rules):
# type: (str, List[str]) -> bool
"""
0. Validate rules
1. Return True if rule explicitly included
2. Return False if rule explicitly excluded
3. Return True if the latest glob-matching rule is include
4. Return False if the latest glob-matching rule is exclude
"""
for rule in rules:
if len(rule) < 2 or rule[0] not in {'-', '+'}:
raise ValueError('invalid rule: `{}`'.format(rule))
for rule in reversed(rules):
if code.lower() == rule[1:].lower():
return rule[0] == '+'
include = False
for rule in rules:
if fnmatch(code, patterns=[rule[1:]]):
include = rule[0] == '+'
return include
def test_fnmatch(filename, patterns, expected):
"""Verify that our fnmatch wrapper works as expected."""
assert utils.fnmatch(filename, patterns) is expected
def test_fnmatch_returns_the_default_with_empty_default():
"""The default parameter should be returned when no patterns are given."""
sentinel = object()
assert utils.fnmatch('file.py', [], default=sentinel) is sentinel
def predicate(pth):
return utils.fnmatch(os.path.abspath(pth), exclude)
def test_fnmatch(filename, patterns, expected):
"""Verify that our fnmatch wrapper works as expected."""
assert utils.fnmatch(filename, patterns) is expected
def predicate(pth):
return utils.fnmatch(os.path.abspath(pth), exclude)
def test_fnmatch_returns_the_default_with_empty_default():
"""The default parameter should be returned when no patterns are given."""
sentinel = object()
assert utils.fnmatch('file.py', [], default=sentinel) is sentinel
