andreoliwa / nitpick / 481

pending completion

Build # 481

Build Type

push

travis-ci-com

Committed by

andreoliwa

Commit Message

test(setup.cfg): "section dot field" on comma separated values

Run Details

299 of 354 branches covered (84.46%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 2 files covered. (100.0%)

1 existing line in 1 file now uncovered.

1056 of 1112 relevant lines covered (94.96%)

2.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.94

/src/nitpick/files/setup_cfg.py

"""Checker for the `setup.cfg <https://docs.python.org/3/distutils/configfile.html>` config file."""
from configparser import ConfigParser
from io import StringIO
from typing import Any, Dict, List, Set, Tuple

import dictdiffer

from nitpick.files.base import BaseFile
from nitpick.typedefs import YieldFlake8Error


class SetupCfgFile(BaseFile):
    """Checker for the `setup.cfg <https://docs.python.org/3/distutils/configfile.html>`_ config file.

    Example: :ref:`flake8 configuration <default-flake8>`.
    """

    file_name = "setup.cfg"
    error_base_number = 320
    COMMA_SEPARATED_VALUES = "comma_separated_values"

    expected_sections = set()  # type: Set[str]
    missing_sections = set()  # type: Set[str]

    def __init__(self) -> None:
        super().__init__()
        self.comma_separated_values = set(self.nitpick_file_dict.get(self.COMMA_SEPARATED_VALUES, []))  # type: Set[str]

    def suggest_initial_contents(self) -> str:
        """Suggest the initial content for this missing file."""
        return self.get_missing_output()

    def get_missing_output(self, actual_sections: Set[str] = None) -> str:
        """Get a missing output string example from the missing sections in setup.cfg."""
        self.expected_sections = set(self.file_dict.keys())
        self.missing_sections = self.expected_sections - (actual_sections or set())

        if self.missing_sections:
            missing_cfg = ConfigParser()
            for section in sorted(self.missing_sections):
                expected_config = self.file_dict[section]  # type: Dict
                if not isinstance(expected_config, dict):
                    # Silently ignore invalid sections for now, to avoid exceptions.
                    # This should be solved in https://github.com/andreoliwa/nitpick/issues/69
                    continue
                missing_cfg[section] = expected_config
            return self.get_example_cfg(missing_cfg)
        return ""

    def check_rules(self) -> YieldFlake8Error:
        """Check missing sections and missing key/value pairs in setup.cfg."""
        setup_cfg = ConfigParser()
        setup_cfg.read_file(self.file_path.open())

        actual_sections = set(setup_cfg.sections())
        missing = self.get_missing_output(actual_sections)
        if missing:
            yield self.flake8_error(1, " has some missing sections. Use this:", missing)

        for section in self.expected_sections - self.missing_sections:
            expected_dict = self.file_dict[section]
            actual_dict = dict(setup_cfg[section])
            # TODO: add a class Ini(BaseFormat) and move this dictdiffer code there
            for diff_type, key, values in dictdiffer.diff(actual_dict, expected_dict):
                if diff_type == dictdiffer.CHANGE:
                    yield from self.compare_different_keys(section, key, values[0], values[1])
                elif diff_type == dictdiffer.ADD:
                    yield from self.show_missing_keys(section, key, values)

    def compare_different_keys(self, section, key, raw_actual: Any, raw_expected: Any) -> YieldFlake8Error:
        """Compare different keys, with special treatment when they are lists or numeric."""
        combined = "{}.{}".format(section, key)
        if combined in self.comma_separated_values:
            # The values might contain spaces
            actual_set = {s.strip() for s in raw_actual.split(",")}
            expected_set = {s.strip() for s in raw_expected.split(",")}
            missing = expected_set - actual_set
            if missing:
                yield self.flake8_error(
                    2,
                    " has missing values in the {!r} key. Include those values:".format(key),
                    "[{}]\n{} = (...),{}".format(section, key, ",".join(sorted(missing))),
                )
            return

        if isinstance(raw_actual, (int, float, bool)) or isinstance(raw_expected, (int, float, bool)):
            # A boolean "True" or "true" has the same effect on setup.cfg.
            actual = str(raw_actual).lower()
            expected = str(raw_expected).lower()
        else:
            actual = raw_actual
            expected = raw_expected
        if actual != expected:
            yield self.flake8_error(
                3,
                ": [{}]{} is {} but it should be like this:".format(section, key, raw_actual),
                "[{}]\n{} = {}".format(section, key, raw_expected),
            )

    def show_missing_keys(  # pylint: disable=unused-argument
        self, section, key, values: List[Tuple[str, Any]]
    ) -> YieldFlake8Error:
        """Show the keys that are not present in a section."""
        missing_cfg = ConfigParser()
        missing_cfg[section] = dict(values)
        output = self.get_example_cfg(missing_cfg)
        yield self.flake8_error(4, ": section [{}] has some missing key/value pairs. Use this:".format(section), output)

    @staticmethod
    def get_example_cfg(config_parser: ConfigParser) -> str:
        """Print an example of a config parser in a string instead of a file."""
        string_stream = StringIO()
        config_parser.write(string_stream)
        output = string_stream.getvalue().strip()
        return output

1	"""Checker for the `setup.cfg <https://docs.python.org/3/distutils/configfile.html>` config file."""
2	from configparser import ConfigParser	3✔
3	from io import StringIO	3✔
4	from typing import Any, Dict, List, Set, Tuple	3✔
5
6	import dictdiffer	3✔
7
8	from nitpick.files.base import BaseFile	3✔
9	from nitpick.typedefs import YieldFlake8Error	3✔
10
11
12	class SetupCfgFile(BaseFile):	3✔
13	"""Checker for the `setup.cfg <https://docs.python.org/3/distutils/configfile.html>`_ config file.
14
15	Example: :ref:`flake8 configuration <default-flake8>`.
16	"""
17
18	file_name = "setup.cfg"	3✔
19	error_base_number = 320	3✔
20	COMMA_SEPARATED_VALUES = "comma_separated_values"	3✔
21
22	expected_sections = set() # type: Set[str]	3✔
23	missing_sections = set() # type: Set[str]	3✔
24
25	def __init__(self) -> None:	3✔
26	super().__init__()	3✔
27	self.comma_separated_values = set(self.nitpick_file_dict.get(self.COMMA_SEPARATED_VALUES, [])) # type: Set[str]	3✔
28
29	def suggest_initial_contents(self) -> str:	3✔
30	"""Suggest the initial content for this missing file."""
31	return self.get_missing_output()	3✔
32
33	def get_missing_output(self, actual_sections: Set[str] = None) -> str:	3✔
34	"""Get a missing output string example from the missing sections in setup.cfg."""
35	self.expected_sections = set(self.file_dict.keys())	3✔
36	self.missing_sections = self.expected_sections - (actual_sections or set())	3✔
37
38	if self.missing_sections:	3✔
39	missing_cfg = ConfigParser()	3✔
40	for section in sorted(self.missing_sections):	3✔
41	expected_config = self.file_dict[section] # type: Dict	3✔
42	if not isinstance(expected_config, dict):	3!
43	# Silently ignore invalid sections for now, to avoid exceptions.
44	# This should be solved in https://github.com/andreoliwa/nitpick/issues/69
UNCOV 45	continue	×
46	missing_cfg[section] = expected_config	3✔
47	return self.get_example_cfg(missing_cfg)	3✔
48	return ""	3✔
49
50	def check_rules(self) -> YieldFlake8Error:	3✔
51	"""Check missing sections and missing key/value pairs in setup.cfg."""
52	setup_cfg = ConfigParser()	3✔
53	setup_cfg.read_file(self.file_path.open())	3✔
54
55	actual_sections = set(setup_cfg.sections())	3✔
56	missing = self.get_missing_output(actual_sections)	3✔
57	if missing:	3✔
58	yield self.flake8_error(1, " has some missing sections. Use this:", missing)	3✔
59
60	for section in self.expected_sections - self.missing_sections:	3✔
61	expected_dict = self.file_dict[section]	3✔
62	actual_dict = dict(setup_cfg[section])	3✔
63	# TODO: add a class Ini(BaseFormat) and move this dictdiffer code there
64	for diff_type, key, values in dictdiffer.diff(actual_dict, expected_dict):	3✔
65	if diff_type == dictdiffer.CHANGE:	3✔
66	yield from self.compare_different_keys(section, key, values[0], values[1])	3✔
67	elif diff_type == dictdiffer.ADD:	3✔
68	yield from self.show_missing_keys(section, key, values)	3✔
69
70	def compare_different_keys(self, section, key, raw_actual: Any, raw_expected: Any) -> YieldFlake8Error:	3✔
71	"""Compare different keys, with special treatment when they are lists or numeric."""
72	combined = "{}.{}".format(section, key)	3✔
73	if combined in self.comma_separated_values:	3✔
74	# The values might contain spaces
75	actual_set = {s.strip() for s in raw_actual.split(",")}	3✔
76	expected_set = {s.strip() for s in raw_expected.split(",")}	3✔
77	missing = expected_set - actual_set	3✔
78	if missing:	3!
79	yield self.flake8_error(	3✔
80	2,
81	" has missing values in the {!r} key. Include those values:".format(key),
82	"[{}]\n{} = (...),{}".format(section, key, ",".join(sorted(missing))),
83	)
84	return	3✔
85
86	if isinstance(raw_actual, (int, float, bool)) or isinstance(raw_expected, (int, float, bool)):	3!
87	# A boolean "True" or "true" has the same effect on setup.cfg.
88	actual = str(raw_actual).lower()	3✔
89	expected = str(raw_expected).lower()	3✔
90	else:
91	actual = raw_actual	×
92	expected = raw_expected	×
93	if actual != expected:	3✔
94	yield self.flake8_error(	3✔
95	3,
96	": [{}]{} is {} but it should be like this:".format(section, key, raw_actual),
97	"[{}]\n{} = {}".format(section, key, raw_expected),
98	)
99
100	def show_missing_keys( # pylint: disable=unused-argument	3✔
101	self, section, key, values: List[Tuple[str, Any]]
102	) -> YieldFlake8Error:
103	"""Show the keys that are not present in a section."""
104	missing_cfg = ConfigParser()	3✔
105	missing_cfg[section] = dict(values)	3✔
106	output = self.get_example_cfg(missing_cfg)	3✔
107	yield self.flake8_error(4, ": section [{}] has some missing key/value pairs. Use this:".format(section), output)	3✔
108
109	@staticmethod	3✔
110	def get_example_cfg(config_parser: ConfigParser) -> str:	3✔
111	"""Print an example of a config parser in a string instead of a file."""
112	string_stream = StringIO()	3✔
113	config_parser.write(string_stream)	3✔
114	output = string_stream.getvalue().strip()	3✔
115	return output	3✔

andreoliwa / nitpick / 481

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous