def test_aggregate_options_when_isolated(optmanager):
"""Verify we aggregate options and config values appropriately."""
arguments = [
"flake8",
"--select",
"E11,E34,E402,W,F",
"--exclude",
"tests/*",
]
config_finder = config.ConfigFileFinder("flake8", ignore_config_files=True)
optmanager.extend_default_ignore(["E8"])
options, args = aggregator.aggregate_options(optmanager, config_finder,
arguments)
assert options.select == ["E11", "E34", "E402", "W", "F"]
assert sorted(options.ignore) == [
"E121",
"E123",
"E126",
"E226",
"E24",
"E704",
"E8",
"W503",
"W504",
]
assert options.exclude == [os.path.abspath("tests/*")]
def test_aggregate_options_when_isolated(optmanager):
"""Verify we aggregate options and config values appropriately."""
arguments = [
'flake8', '--isolated', '--select', 'E11,E34,E402,W,F', '--exclude',
'tests/*'
]
config_finder = config.ConfigFileFinder('flake8', arguments, [])
optmanager.extend_default_ignore(['E8'])
options, args = aggregator.aggregate_options(optmanager, config_finder,
arguments)
assert options.isolated is True
assert options.select == ['E11', 'E34', 'E402', 'W', 'F']
assert sorted(options.ignore) == [
'E121',
'E123',
'E126',
'E226',
'E24',
'E704',
'E8',
'W503',
'W504',
]
assert options.exclude == [os.path.abspath('tests/*')]
def test_is_configured_by(filename, is_configured_by, optmanager,
config_finder):
"""Verify the behaviour of the is_configured_by method."""
parsed_config, _ = config.ConfigFileFinder('flake8')._read_config(filename)
parser = config.MergedConfigParser(optmanager, config_finder)
assert parser.is_configured_by(parsed_config) is is_configured_by
def test_cli_config():
"""Verify opening and reading the file specified via the cli."""
cli_filepath = CLI_SPECIFIED_FILEPATH
finder = config.ConfigFileFinder('flake8', None, [])
parsed_config = finder.cli_config(cli_filepath)
assert parsed_config.has_section('flake8')
def get_style_guide(argv=None):
# this is a fork of flake8.api.legacy.get_style_guide
# to allow passing command line argument
application = Application()
if hasattr(application, 'parse_preliminary_options'):
prelim_opts, remaining_args = application.parse_preliminary_options(
argv)
from flake8 import configure_logging
configure_logging(prelim_opts.verbose, prelim_opts.output_file)
from flake8.options import config
config_finder = config.ConfigFileFinder(
application.program,
prelim_opts.append_config,
config_file=prelim_opts.config,
ignore_config_files=prelim_opts.isolated)
application.find_plugins(config_finder)
application.register_plugin_options()
application.parse_configuration_and_cli(config_finder, remaining_args)
else:
application.parse_preliminary_options_and_args([])
application.make_config_finder()
application.find_plugins()
application.register_plugin_options()
application.parse_configuration_and_cli(argv)
application.make_formatter()
application.make_guide()
application.make_file_checker_manager()
return StyleGuide(application)
def initialize(self, argv: List[str]) -> None:
"""Initialize the application to be run.
This finds the plugins, registers their options, and parses the
command-line arguments.
"""
# NOTE(sigmavirus24): When updating this, make sure you also update
# our legacy API calls to these same methods.
prelim_opts, remaining_args = self.parse_preliminary_options(argv)
flake8.configure_logging(prelim_opts.verbose, prelim_opts.output_file)
config_finder = config.ConfigFileFinder(
self.program,
prelim_opts.append_config,
config_file=prelim_opts.config,
ignore_config_files=prelim_opts.isolated,
)
self.find_plugins(config_finder)
self.register_plugin_options()
self.parse_configuration_and_cli(
config_finder,
remaining_args,
)
self.make_formatter()
self.make_guide()
self.make_file_checker_manager()
def make_config_finder(self):
"""Make our ConfigFileFinder based on preliminary opts and args."""
if self.config_finder is None:
self.config_finder = config.ConfigFileFinder(
self.option_manager.program_name,
self.prelim_args,
self.prelim_opts.append_config,
)
def test_generate_possible_local_files(cwd, expected):
"""Verify generation of all possible config paths."""
finder = config.ConfigFileFinder("flake8")
with mock.patch.object(os, "getcwd", return_value=cwd):
config_files = list(finder.generate_possible_local_files())
assert config_files == expected
def make_config_finder(self):
"""Make our ConfigFileFinder based on preliminary opts and args."""
if self.config_finder is None:
extra_config_files = utils.normalize_paths(
self.prelim_opts.append_config)
self.config_finder = config.ConfigFileFinder(
self.option_manager.program_name, self.prelim_args,
extra_config_files)
def test_cli_config_double_read():
"""Second request for CLI config is cached."""
finder = config.ConfigFileFinder('flake8', None, [])
parsed_config = finder.cli_config(CLI_SPECIFIED_FILEPATH)
boom = Exception("second request for CLI config not cached")
with mock.patch.object(finder, '_read_config', side_effect=boom):
parsed_config_2 = finder.cli_config(CLI_SPECIFIED_FILEPATH)
assert parsed_config is parsed_config_2
def test_local_configs_double_read():
"""Second request for local configs is cached."""
finder = config.ConfigFileFinder('flake8', None, [])
first_read = finder.local_configs()
boom = Exception("second request for local configs not cached")
with mock.patch.object(finder, '_read_config', side_effect=boom):
second_read = finder.local_configs()
assert first_read is second_read
def test_get_local_plugins():
"""Verify get_local_plugins returns expected plugins."""
config_fixture_path = 'tests/fixtures/config_files/local-plugin.ini'
config_finder = config.ConfigFileFinder('flake8')
with mock.patch.object(config_finder, 'local_config_files') as localcfs:
localcfs.return_value = [config_fixture_path]
local_plugins = config.get_local_plugins(config_finder)
assert local_plugins.extension == ['XE = test_plugins:ExtensionTestPlugin']
assert local_plugins.report == ['XR = test_plugins:ReportTestPlugin']
def make_config_finder(self, append_config, args):
# type: (List[str], List[str]) -> None
"""Make our ConfigFileFinder based on preliminary opts and args.
:param list append_config:
List of configuration files to be parsed for configuration.
:param list args:
The list of file arguments passed from the CLI.
"""
if self.config_finder is None:
self.config_finder = config.ConfigFileFinder(
self.option_manager.program_name, args, append_config)
def test_aggregate_options_with_config(optmanager):
"""Verify we aggregate options and config values appropriately."""
arguments = ['flake8', '--select',
'E11,E34,E402,W,F', '--exclude', 'tests/*']
config_finder = config.ConfigFileFinder(
'flake8',
config_file=CLI_SPECIFIED_CONFIG)
options, args = aggregator.aggregate_options(
optmanager, config_finder, arguments)
assert options.select == ['E11', 'E34', 'E402', 'W', 'F']
assert options.ignore == ['E123', 'W234', 'E111']
assert options.exclude == [os.path.abspath('tests/*')]
def test_aggregate_options_with_config(optmanager):
"""Verify we aggregate options and config values appropriately."""
arguments = [
"flake8",
"--select",
"E11,E34,E402,W,F",
"--exclude",
"tests/*",
]
config_finder = config.ConfigFileFinder("flake8",
config_file=CLI_SPECIFIED_CONFIG)
options, args = aggregator.aggregate_options(optmanager, config_finder,
arguments)
assert options.select == ["E11", "E34", "E402", "W", "F"]
assert options.ignore == ["E123", "W234", "E111"]
assert options.exclude == [os.path.abspath("tests/*")]
def check_file(path, flake8ignore, maxlength, maxcomplexity, showshource,
statistics):
"""Run flake8 over a single file, and return the number of failures."""
args = []
if maxlength:
args += ['--max-line-length', maxlength]
if maxcomplexity:
args += ['--max-complexity', maxcomplexity]
if showshource:
args += ['--show-source']
if statistics:
args += ['--statistics']
app = application.Application()
if not hasattr(app, 'parse_preliminary_options_and_args'): # flake8 >= 3.8
prelim_opts, remaining_args = app.parse_preliminary_options(args)
config_finder = config.ConfigFileFinder(
app.program,
prelim_opts.append_config,
config_file=prelim_opts.config,
ignore_config_files=prelim_opts.isolated,
)
app.find_plugins(config_finder)
app.register_plugin_options()
app.parse_configuration_and_cli(config_finder, remaining_args)
else:
app.parse_preliminary_options_and_args(args)
app.make_config_finder()
app.find_plugins()
app.register_plugin_options()
app.parse_configuration_and_cli(args)
if flake8ignore:
app.options.ignore = flake8ignore
app.make_formatter() # fix this
if hasattr(app, 'make_notifier'):
# removed in flake8 3.7+
app.make_notifier()
app.make_guide()
app.make_file_checker_manager()
app.run_checks([str(path)])
app.formatter.start()
app.report_errors()
app.formatter.stop()
return app.result_count
def read_configs(ctx: click.Context, param: click.Parameter,
value: Optional[str]) -> Optional[str]:
"""Read configs through the config param's callback hook."""
# Use black's `read_pyproject_toml` for the default
result = black.read_pyproject_toml(ctx, param, value)
# Use flake8's config file parsing to load setup.cfg, tox.ini, and .blue
# The parsing looks both in the project and user directories.
finder = flake8_config.ConfigFileFinder('blue')
manager = flake8_manager.OptionManager('blue', '0')
parser = MergedConfigParser(manager, finder)
config = parser.parse()
# Merge the configs into Click's `default_map`.
default_map: Dict[str, Any] = {}
default_map.update(ctx.default_map or {})
for key, value in config.items():
key = key.replace('--', '').replace('-', '_')
default_map[key] = value
ctx.default_map = default_map
return result
def get_style_guide(**kwargs):
r"""Provision a StyleGuide for use.
:param \*\*kwargs:
Keyword arguments that provide some options for the StyleGuide.
:returns:
An initialized StyleGuide
:rtype:
:class:`StyleGuide`
"""
application = app.Application()
prelim_opts, remaining_args = application.parse_preliminary_options([])
flake8.configure_logging(prelim_opts.verbose, prelim_opts.output_file)
config_finder = config.ConfigFileFinder(
application.program,
prelim_opts.append_config,
config_file=prelim_opts.config,
ignore_config_files=prelim_opts.isolated,
)
application.find_plugins(config_finder)
application.register_plugin_options()
application.parse_configuration_and_cli(
config_finder,
remaining_args,
)
# We basically want application.initialize to be called but with these
# options set instead before we make our formatter, notifier, internal
# style guide and file checker manager.
options = application.options
for key, value in kwargs.items():
try:
getattr(options, key)
setattr(options, key, value)
except AttributeError:
LOG.error('Could not update option "%s"', key)
application.make_formatter()
application.make_guide()
application.make_file_checker_manager()
return StyleGuide(application)
def get_flake8_style_guide(argv):
# This is a modified version of flake8.legacy.get_style_guide() in which we pass argv through
# to parse_configuration_and_cli(), as opposed to a dict of flake8 options.
# Since we are using config files and a mix plugins, it is not trivial to determine the
# appropriate options to pass into the standard flake8.legacy.get_style_guide();
# passing argv gets it to determine the options for us.
application = flake8_app.Application()
if hasattr(application, 'parse_preliminary_options'):
prelim_opts, remaining_args = application.parse_preliminary_options(
argv)
flake8.configure_logging(prelim_opts.verbose, prelim_opts.output_file)
from flake8.options import config
config_finder = config.ConfigFileFinder(
application.program,
prelim_opts.append_config,
config_file=prelim_opts.config,
ignore_config_files=prelim_opts.isolated)
application.find_plugins(config_finder)
application.register_plugin_options()
application.parse_configuration_and_cli(config_finder, remaining_args)
else:
application.parse_preliminary_options_and_args([])
flake8.configure_logging(application.prelim_opts.verbose,
application.prelim_opts.output_file)
application.make_config_finder()
application.find_plugins()
application.register_plugin_options()
application.parse_configuration_and_cli(argv)
application.make_formatter()
try:
# needed in older flake8 versions to populate the listener
application.make_notifier()
except AttributeError:
pass
application.make_guide()
application.make_file_checker_manager()
return StyleGuide(application)
def test_config_file_default_value():
"""Verify the default 'config_file' attribute value."""
finder = config.ConfigFileFinder("flake8")
assert finder.config_file is None
def config_finder():
"""Generate a simple ConfigFileFinder."""
return config.ConfigFileFinder('flake8', [], [])
def test_generate_possible_local_files(args, expected):
"""Verify generation of all possible config paths."""
finder = config.ConfigFileFinder('flake8', args, [])
assert (list(finder.generate_possible_local_files()) ==
expected)
def test_setting_config_file_value():
"""Verify the 'config_file' attribute matches constructed value."""
config_file_value = "flake8.ini"
finder = config.ConfigFileFinder("flake8", config_file=config_file_value)
assert finder.config_file == config_file_value
def test_windows_detection(platform, is_windows):
"""Verify we detect Windows to the best of our knowledge."""
with mock.patch.object(sys, 'platform', platform):
finder = config.ConfigFileFinder('flake8', None, [])
assert finder.is_windows is is_windows
def test_uses_default_args():
"""Show that we default the args value."""
finder = config.ConfigFileFinder('flake8', None, [])
assert finder.parent == os.path.abspath('.')
def test_read_config_catches_broken_config_files(files):
"""Verify that we do not allow the exception to bubble up."""
_, parsed = config.ConfigFileFinder('flake8')._read_config(*files)
assert BROKEN_CONFIG_PATH not in parsed
def test_local_configs():
"""Verify we return a ConfigParser."""
finder = config.ConfigFileFinder('flake8', None, [])
assert isinstance(finder.local_configs(), configparser.RawConfigParser)
def test_local_config_files(args, extra_config_files, expected):
"""Verify discovery of local config files."""
finder = config.ConfigFileFinder('flake8', args, extra_config_files)
assert list(finder.local_config_files()) == expected
def test_ignore_config_files_default_value():
"""Verify the default 'ignore_config_files' attribute value."""
finder = config.ConfigFileFinder("flake8")
assert finder.ignore_config_files is False
def test_setting_ignore_config_files_value(ignore_config_files_arg):
"""Verify the 'ignore_config_files' attribute matches constructed value."""
finder = config.ConfigFileFinder(
"flake8", ignore_config_files=ignore_config_files_arg)
assert finder.ignore_config_files is ignore_config_files_arg
