feat(#44): Support multiline config value for INI config (#45)

Co-authored-by: deepsource-autofix[bot] <62050782+deepsource-autofix[bot]@users.noreply.github.com>

Author: phuongfi91

src/nitpick/plugins/ini.py

@@ -5,7 +5,7 @@
 import copy
 from configparser import ConfigParser, DuplicateOptionError, Error, MissingSectionHeaderError, ParsingError
 from io import StringIO
-from typing import TYPE_CHECKING, Any, ClassVar, Iterator
+from typing import TYPE_CHECKING, Any, ClassVar, Iterable, Iterator
 
 import dictdiffer
 from configupdater import ConfigUpdater, Space
@@ -67,9 +67,17 @@ def post_init(self):
         self.updater = ConfigUpdater()
         self.comma_separated_values = set(self.comma_separated_values_dict.get(self.filename, []))
 
-        if not self.needs_top_section:
-            return
         if all(isinstance(v, dict) for v in self.expected_config.values()):
+            for section in self.expected_config:
+                for key, value in self.expected_config[section].items():
+                    if self._is_multiline_value(section, key, value):
+                        # Convert the value to a string that's compatible with ConfigUpdater
+                        # Remove the indent to be diff-able later with values in self.updater,
+                        # which was read from existing config
+                        lines = [line.strip() for line in value.strip().split("\n")]
+                        self.expected_config[section][key] = self._get_configupdater_values(lines, indent="")
+            return
+        if not self.needs_top_section:
             return
 
         new_config = {TOP_SECTION: {}}
@@ -134,6 +142,12 @@ def get_missing_output(self) -> str:
         parser = ConfigParser()
         for section in sorted(missing, key=lambda s: "0" if s == TOP_SECTION else f"1{s}"):
             expected_config: dict = self.expected_config[section]
+            for k, v in expected_config.items():  # pylint: disable=invalid-name
+                if self._is_multiline_value(section, k, v):
+                    # Convert the value to a string that's compatible with ConfigUpdater
+                    lines = [line.strip() for line in v.strip().split("\n")]
+                    expected_config[k] = self._get_configupdater_values(lines)
+
             if self.autofix:
                 if self.updater.last_block:
                     self.updater.last_block.add_after.space(1)
@@ -143,6 +157,22 @@ def get_missing_output(self) -> str:
             parser[section] = expected_config
         return self.contents_without_top_section(self.get_example_cfg(parser))
 
+    def _is_multiline_value(self, section: str, key: str, value: int | str) -> bool:
+        """Check if the value is a multiline value."""
+        return f"{section}.{key}" not in self.comma_separated_values and "\n" in str(value)
+
+    @staticmethod
+    def _get_configupdater_values(values: Iterable[str], separator="\n", indent=4 * " "):
+        """Convert a list of values to a string compatible with ConfigUpdater.
+
+        This is similar to the ConfigUpdater's set_values() method
+        """
+        values = list(values).copy()
+        if "\n" in separator:
+            values = ["", *values]
+            separator = separator + indent
+        return separator.join(values)
+
     # TODO: refactor: convert the contents to dict (with IniConfig().sections?) and mimic other plugins doing dict diffs
     def enforce_rules(self) -> Iterator[Fuss]:
         """Enforce rules on missing sections and missing key/value pairs in an INI file."""
@@ -323,13 +353,28 @@ def compare_different_keys(self, section, key, raw_actual: Any, raw_expected: An
             actual = str(raw_actual).lower()
             expected = str(raw_expected).lower()
         else:
+            if self._is_multiline_value(section, key, raw_expected):
+                # Find missing lines that should be in the expected value
+                actual_lines = [line.strip() for line in raw_actual.strip().split("\n")]
+                expected_lines = [line.strip() for line in raw_expected.strip().split("\n")]
+                missing_lines = set(expected_lines) - set(actual_lines)
+                # expected value should be the actual lines plus the missing lines
+                raw_expected = raw_actual
+                for line in missing_lines:
+                    raw_expected += "\n" + line
+
             actual = raw_actual
             expected = raw_expected
         if actual == expected:
             return
 
         if self.autofix:
-            self.updater[section][key].value = expected
+            if self._is_multiline_value(section, key, expected):
+                # Handle multiline config using ConfigUpdater's set_values()
+                expected_lines = [line.strip() for line in expected.strip().split("\n")]
+                self.updater[section][key].set_values(expected_lines)
+            else:
+                self.updater[section][key].value = expected
             self.dirty = True
         if section == TOP_SECTION:
             yield self.reporter.make_fuss(

tests/test_ini.py

@@ -635,10 +635,7 @@ def test_comma_separated_values_in_multiline_config_value_should_be_enforced_if_
             ".flake8",
             Violations.MISSING_OPTION.code,
             ": section [flake8] has some missing key/value pairs. Use this:",
-            "[flake8]\n"
-            "per-file-ignores = \n"
-            "\t  tests/*.py:WPS116,WPS118\n"
-            "\t  tests_2/*.py:WPS116,WPS118,WPS218",
+            "[flake8]\nper-file-ignores = \n\t  tests/*.py:WPS116,WPS118\n\t  tests_2/*.py:WPS116,WPS118,WPS218",
         )
     ).assert_file_contents(
         ".flake8",
@@ -689,3 +686,108 @@ def test_comma_separated_values_in_multiline_config_value_should_be_without_viol
           tests_2/*.py:WPS116,WPS118,WPS218
         """,
     )
+
+
+def test_multiline_config_value_should_be_enforced_if_some_lines_are_missing(tmp_path):
+    """Target multiline config value is missing some lines."""
+    ProjectMock(tmp_path).save_file(
+        ".coveragerc",
+        """
+        [report]
+        exclude_also =
+            pragma: no cover
+            def __repr__
+        """,
+    ).style(
+        """
+        [".coveragerc".report]
+        exclude_also = \"\"\"
+            def __repr__
+            def __str__
+        \"\"\"
+        """
+    ).api_check_then_fix(
+        Fuss(
+            True,
+            ".coveragerc",
+            Violations.OPTION_HAS_DIFFERENT_VALUE.code,
+            ": [report]exclude_also is \npragma: no cover\ndef __repr__ but it should be like this:",
+            "[report]\nexclude_also = \npragma: no cover\ndef __repr__\ndef __str__",
+        )
+    ).assert_file_contents(
+        ".coveragerc",
+        """
+        [report]
+        exclude_also =
+            pragma: no cover
+            def __repr__
+            def __str__
+        """,
+    )
+
+
+def test_multiline_config_value_should_be_enforced_if_missing_entirely(tmp_path):
+    """Target multiline config is missing entirely."""
+    ProjectMock(tmp_path).save_file(
+        ".coveragerc",
+        """
+        [run]
+        relative_files = True
+        """,
+    ).style(
+        """
+        [".coveragerc".report]
+        exclude_also = \"\"\"
+            pragma: no cover
+            def __repr__
+        \"\"\"
+        """
+    ).api_check_then_fix(
+        Fuss(
+            True,
+            ".coveragerc",
+            Violations.MISSING_SECTIONS.code,
+            " has some missing sections. Use this:",
+            "[report]\nexclude_also = \n\t    pragma: no cover\n\t    def __repr__",
+        )
+    ).assert_file_contents(
+        ".coveragerc",
+        """
+        [run]
+        relative_files = True
+
+        [report]
+        exclude_also =
+            pragma: no cover
+            def __repr__
+        """,
+    )
+
+
+def test_multiline_config_value_should_be_without_violation_if_no_changes(tmp_path):
+    """Target multiline config is unchanged."""
+    ProjectMock(tmp_path).save_file(
+        ".coveragerc",
+        """
+        [report]
+        exclude_also =
+            pragma: no cover
+            def __repr__
+        """,
+    ).style(
+        """
+        [".coveragerc".report]
+        exclude_also = \"\"\"
+            pragma: no cover
+            def __repr__
+        \"\"\"
+        """
+    ).api_check_then_fix().assert_file_contents(
+        ".coveragerc",
+        """
+        [report]
+        exclude_also =
+            pragma: no cover
+            def __repr__
+        """,
+    )