[refactor] Create a config parsing class indpendant from Pylinter

This will permit to parse config file without having to instantiate
a linter for tool working on pylint configuration like #5462

Author: Pierre-Sassoulas

pylint/config/config_file_parser.py

@@ -23,24 +23,23 @@
     from pylint.lint import PyLinter
 
 
-class _ConfigurationFileParser:
+class _RawConfParser:
     """Class to parse various formats of configuration files."""
 
-    def __init__(self, verbose: bool, linter: PyLinter) -> None:
-        self.verbose_mode = verbose
-        self.linter = linter
+    @staticmethod
+    def parse_ini_file(file_path: Path) -> tuple[dict[str, str], list[str]]:
+        """Parse and handle errors of a ini configuration file.
 
-    def _parse_ini_file(self, file_path: Path) -> tuple[dict[str, str], list[str]]:
-        """Parse and handle errors of a ini configuration file."""
+        Raises configparser.Error
+        """
         parser = configparser.ConfigParser(inline_comment_prefixes=("#", ";"))
-
         # Use this encoding in order to strip the BOM marker, if any.
         with open(file_path, encoding="utf_8_sig") as fp:
             parser.read_file(fp)
 
         config_content: dict[str, str] = {}
         options: list[str] = []
-        ini_file_with_sections = self._ini_file_with_sections(file_path)
+        ini_file_with_sections = _RawConfParser._ini_file_with_sections(file_path)
         for section in parser.sections():
             if ini_file_with_sections and not section.startswith("pylint"):
                 continue
@@ -58,15 +57,14 @@ def _ini_file_with_sections(file_path: Path) -> bool:
             return True
         return False
 
-    def _parse_toml_file(self, file_path: Path) -> tuple[dict[str, str], list[str]]:
-        """Parse and handle errors of a toml configuration file."""
-        try:
-            with open(file_path, mode="rb") as fp:
-                content = tomllib.load(fp)
-        except tomllib.TOMLDecodeError as e:
-            self.linter.add_message("config-parse-error", line=0, args=str(e))
-            return {}, []
+    @staticmethod
+    def parse_toml_file(file_path: Path) -> tuple[dict[str, str], list[str]]:
+        """Parse and handle errors of a toml configuration file.
 
+        Raises tomllib.TOMLDecodeError
+        """
+        with open(file_path, mode="rb") as fp:
+            content = tomllib.load(fp)
         try:
             sections_values = content["tool"]["pylint"]
         except KeyError:
@@ -86,12 +84,16 @@ def _parse_toml_file(self, file_path: Path) -> tuple[dict[str, str], list[str]]:
                 options += [f"--{opt}", values]
         return config_content, options
 
+    @staticmethod
     def parse_config_file(
-        self, file_path: Path | None
+        file_path: Path | None, verbose: bool
     ) -> tuple[dict[str, str], list[str]]:
-        """Parse a config file and return str-str pairs."""
+        """Parse a config file and return str-str pairs.
+
+        Raises tomllib.TOMLDecodeError, configparser.Error
+        """
         if file_path is None:
-            if self.verbose_mode:
+            if verbose:
                 print(
                     "No config file found, using default configuration", file=sys.stderr
                 )
@@ -101,13 +103,44 @@ def parse_config_file(
         if not file_path.exists():
             raise OSError(f"The config file {file_path} doesn't exist!")
 
-        if self.verbose_mode:
+        if verbose:
             print(f"Using config file {file_path}", file=sys.stderr)
 
+        if file_path.suffix == ".toml":
+            return _RawConfParser.parse_toml_file(file_path)
+        return _RawConfParser.parse_ini_file(file_path)
+
+
+class _ConfigurationFileParser:
+    """Class to parse various formats of configuration files."""
+
+    def __init__(self, verbose: bool, linter: PyLinter) -> None:
+        self.verbose_mode = verbose
+        self.linter = linter
+
+    def _parse_ini_file(self, file_path: Path) -> tuple[dict[str, str], list[str]]:
+        """Parse and handle errors of a ini configuration file."""
+        return _RawConfParser.parse_ini_file(file_path)
+
+    @staticmethod
+    def _ini_file_with_sections(file_path: Path) -> bool:
+        """Return whether the file uses sections."""
+        return _RawConfParser._ini_file_with_sections(file_path)
+
+    def _parse_toml_file(self, file_path: Path) -> tuple[dict[str, str], list[str]]:
+        """Parse and handle errors of a toml configuration file."""
+        try:
+            return _RawConfParser.parse_toml_file(file_path)
+        except tomllib.TOMLDecodeError as e:
+            self.linter.add_message("config-parse-error", line=0, args=str(e))
+            return {}, []
+
+    def parse_config_file(
+        self, file_path: Path | None
+    ) -> tuple[dict[str, str], list[str]]:
+        """Parse a config file and return str-str pairs."""
         try:
-            if file_path.suffix == ".toml":
-                return self._parse_toml_file(file_path)
-            return self._parse_ini_file(file_path)
+            return _RawConfParser.parse_config_file(file_path, self.verbose_mode)
         except (configparser.Error, tomllib.TOMLDecodeError) as e:
             self.linter.add_message("config-parse-error", line=0, args=str(e))
             return {}, []