[WIP] Support tox.toml

Author: ziima

src/tox/config/loader/toml.py

@@ -0,0 +1,100 @@
+"""Loader for TOML configuration files.
+
+This is experimental API! Expect things to be broken.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Iterator, Sequence
+
+from tox.config.types import Command, EnvList
+
+from .api import Loader, Override
+from .str_convert import StrConvert
+
+if TYPE_CHECKING:
+    from tox.config.main import Config
+
+    from .section import Section
+
+
+# TODO: Use MemoryLoader instead?
+class TomlLoader(Loader[Any]):
+    """Load configuration from data parsed from TOML file.
+
+    This is experimental API! Expect things to be broken.
+    """
+
+    def __init__(
+        self,
+        section: Section,
+        raw: dict[str, Any],
+        overrides: list[Override],
+        core_section: Section,
+        section_key: str | None = None,
+    ) -> None:
+        super().__init__(section, overrides)
+        self.raw = raw
+        # TODO: These are probably useless for TOML loader. Copied from IniLoader.
+        self.core_section = core_section
+        self._section_key = section_key
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(section={self._section.key}, overrides={self.overrides!r})"
+
+    def load_raw(self, key: Any, conf: Config | None, env_name: str | None) -> Any:  # noqa: ARG002
+        return self.raw[self._section_key or self.section.key][key]
+
+    def found_keys(self) -> set[str]:
+        return set(self.raw[self._section_key or self.section.key])
+
+    def get_section(self, name: str) -> Any:
+        # TODO: Make this part of API?
+        # needed for non tox environment replacements
+        if name in self.raw:
+            return self.raw[name]
+        return None
+
+    # TODO: Mostly duplicates MemoryLoader
+    @staticmethod
+    def to_bool(value: Any) -> bool:
+        return bool(value)
+
+    @staticmethod
+    def to_str(value: Any) -> str:
+        return str(value)
+
+    @staticmethod
+    def to_list(value: Any, of_type: type[Any]) -> Iterator[Any]:  # noqa: ARG004
+        return iter(value)
+
+    @staticmethod
+    def to_set(value: Any, of_type: type[Any]) -> Iterator[Any]:  # noqa: ARG004
+        return iter(value)
+
+    @staticmethod
+    def to_dict(value: Any, of_type: tuple[type[Any], type[Any]]) -> Iterator[tuple[Any, Any]]:  # noqa: ARG004
+        return value.items()  # type: ignore[no-any-return]
+
+    @staticmethod
+    def to_path(value: Any) -> Path:
+        return Path(value)
+
+    @staticmethod
+    def to_command(value: Any) -> Command:
+        if isinstance(value, Command):
+            return value
+        if isinstance(value, str):
+            return StrConvert.to_command(value)
+        raise TypeError(value)
+
+    @staticmethod
+    def to_env_list(value: Any) -> EnvList:
+        if isinstance(value, EnvList):
+            return value
+        if isinstance(value, str):
+            return StrConvert.to_env_list(value)
+        if isinstance(value, Sequence):
+            return EnvList(value)
+        raise TypeError(value)

src/tox/config/source/discover.py

@@ -9,12 +9,16 @@
 
 from .legacy_toml import LegacyToml
 from .setup_cfg import SetupCfg
+from .toml import ToxToml
 from .tox_ini import ToxIni
 
+# from .toml import PyProjectToml
+
 if TYPE_CHECKING:
     from .api import Source
 
-SOURCE_TYPES: tuple[type[Source], ...] = (ToxIni, SetupCfg, LegacyToml)
+# SOURCE_TYPES: tuple[type[Source], ...] = (ToxIni, ToxToml, PyProjectToml, SetupCfg, LegacyToml)
+SOURCE_TYPES: tuple[type[Source], ...] = (ToxIni, ToxToml, SetupCfg, LegacyToml)
 
 
 def discover_source(config_file: Path | None, root_dir: Path | None) -> Source:

src/tox/config/source/toml.py

@@ -0,0 +1,142 @@
+"""Support for TOML config sources.
+
+This is experimental API! Expect things to be broken.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from itertools import chain
+from typing import TYPE_CHECKING, Iterable, Iterator
+
+import tomllib
+
+from tox.config.loader.ini.factor import find_envs
+from tox.config.loader.section import Section
+from tox.config.loader.toml import TomlLoader
+
+from .api import Source
+from .ini_section import CORE, PKG_ENV_PREFIX, TEST_ENV_PREFIX, IniSection
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from tox.config.loader.api import OverrideMap
+    from tox.config.sets import ConfigSet
+
+
+class TomlSource(Source):
+    """Configuration sourced from a toml file (such as tox.toml).
+
+    This is experimental API! Expect things to be broken.
+    """
+
+    CORE_SECTION = CORE
+
+    def __init__(self, path: Path, content: str | None = None) -> None:
+        super().__init__(path)
+        if content is None:
+            if not path.exists():
+                raise ValueError
+            content = path.read_text()
+        self._raw = tomllib.loads(content)
+        self._section_mapping: defaultdict[str, list[str]] = defaultdict(list)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(path={self.path})"
+
+    def transform_section(self, section: Section) -> Section:  # noqa: PLR6301
+        return IniSection(section.prefix, section.name)
+
+    def get_loader(self, section: Section, override_map: OverrideMap) -> TomlLoader | None:
+        # look up requested section name in the generative testenv mapping to find the real config source
+        for key in self._section_mapping.get(section.name) or []:
+            if section.prefix is None or Section.from_key(key).prefix == section.prefix:
+                break
+        else:
+            # if no matching section/prefix is found, use the requested section key as-is (for custom prefixes)
+            key = section.key
+        if key in self._raw:
+            return TomlLoader(
+                section=section,
+                raw=self._raw,
+                overrides=override_map.get(section.key, []),
+                core_section=self.CORE_SECTION,
+                section_key=key,
+            )
+        return None
+
+    def get_base_sections(self, base: list[str], in_section: Section) -> Iterator[Section]:  # noqa: PLR6301
+        for a_base in base:
+            section = IniSection.from_key(a_base)
+            yield section  # the base specifier is explicit
+            if in_section.prefix is not None:  # no prefix specified, so this could imply our own prefix
+                yield IniSection(in_section.prefix, a_base)
+
+    def sections(self) -> Iterator[IniSection]:
+        for key in self._raw:
+            yield IniSection.from_key(key)
+
+    def envs(self, core_config: ConfigSet) -> Iterator[str]:
+        seen = set()
+        for name in self._discover_tox_envs(core_config):
+            if name not in seen:
+                seen.add(name)
+                yield name
+
+    def _discover_tox_envs(self, core_config: ConfigSet) -> Iterator[str]:
+        def register_factors(envs: Iterable[str]) -> None:
+            known_factors.update(chain.from_iterable(e.split("-") for e in envs))
+
+        explicit = list(core_config["env_list"])
+        yield from explicit
+        known_factors: set[str] = set()
+        register_factors(explicit)
+
+        # discover all additional defined environments, including generative section headers
+        for section in self.sections():
+            if section.is_test_env:
+                register_factors(section.names)
+                for name in section.names:
+                    self._section_mapping[name].append(section.key)
+                    yield name
+        # add all conditional markers that are not part of the explicitly defined sections
+        for section in self.sections():
+            yield from self._discover_from_section(section, known_factors)
+
+    def _discover_from_section(self, section: IniSection, known_factors: set[str]) -> Iterator[str]:
+        for value in self._raw[section.key].values():
+            if isinstance(value, bool):
+                # It's not a value with env definition.
+                continue
+            # XXX: We munch the value to multiline string to parse it by the library utils.
+            merged_value = "\n".join(str(v) for v in tuple(value))
+            for env in find_envs(merged_value):
+                if set(env.split("-")) - known_factors:
+                    yield env
+
+    def get_tox_env_section(self, item: str) -> tuple[Section, list[str], list[str]]:  # noqa: PLR6301
+        return IniSection.test_env(item), [TEST_ENV_PREFIX], [PKG_ENV_PREFIX]
+
+    def get_core_section(self) -> Section:
+        return self.CORE_SECTION
+
+
+class ToxToml(TomlSource):
+    """Configuration sourced from a tox.toml file.
+
+    This is experimental API! Expect things to be broken.
+    """
+
+    FILENAME = "tox.toml"
+
+
+# TODO: Section model is way too configparser precific for this to work easily.
+# class PyProjectToml(TomlSource):
+#     """Configuration sourced from a pyproject.toml file.
+
+#     This is experimental API! Expect things to be broken.
+#     """
+
+#     FILENAME = "pyproject.toml"
+#     CORE_SECTION = IniSection("tool", "tox")

tests/config/cli/test_cli_ini.py

@@ -145,10 +145,16 @@ def test_cli_ini_with_interpolated(tmp_path: Path, monkeypatch: MonkeyPatch) ->
     [
         pytest.param("", "tox.ini", "[tox]", id="ini-dir"),
         pytest.param("tox.ini", "tox.ini", "[tox]", id="ini"),
+        pytest.param("", "tox.toml", "[tox]", id="toml-dir"),
+        pytest.param("tox.toml", "tox.toml", "[tox]", id="toml"),
         pytest.param("", "setup.cfg", "[tox:tox]", id="cfg-dir"),
         pytest.param("setup.cfg", "setup.cfg", "[tox:tox]", id="cfg"),
-        pytest.param("", "pyproject.toml", '[tool.tox]\nlegacy_tox_ini = """\n[tox]\n"""\n', id="toml-dir"),
-        pytest.param("pyproject.toml", "pyproject.toml", '[tool.tox]\nlegacy_tox_ini = """\n[tox]\n"""\n', id="toml"),
+        # pytest.param("", "pyproject.toml", '[tool.tox]', id="toml-dir"),
+        # pytest.param("pyproject.toml", "pyproject.toml", '[tool.tox]', id="toml"),
+        pytest.param("", "pyproject.toml", '[tool.tox]\nlegacy_tox_ini = """\n[tox]\n"""\n', id="toml-legacy-dir"),
+        pytest.param(
+            "pyproject.toml", "pyproject.toml", '[tool.tox]\nlegacy_tox_ini = """\n[tox]\n"""\n', id="toml-legacy"
+        ),
     ],
 )
 def test_conf_arg(tmp_path: Path, conf_arg: str, filename: str, content: str) -> None:

tests/config/conftest.py

@@ -5,10 +5,17 @@
 import pytest
 
 if TYPE_CHECKING:
-    from tests.conftest import ToxIniCreator
+    from tests.conftest import ToxIniCreator, ToxTomlCreator
     from tox.config.main import Config
 
 
 @pytest.fixture()
 def empty_config(tox_ini_conf: ToxIniCreator) -> Config:
+    """Make and return an empty INI config file."""
     return tox_ini_conf("")
+
+
+@pytest.fixture()
+def empty_toml_config(tox_toml_conf: ToxTomlCreator) -> Config:
+    """Make and return an empty TOML config file."""
+    return tox_toml_conf("")

tests/config/loader/toml/conftest.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable
+
+import pytest
+import tomllib
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@pytest.fixture()
+def mk_toml_conf(tmp_path: Path) -> Callable[[str], dict[str, Any]]:
+    def _func(raw: str) -> dict[str, Any]:
+        filename = tmp_path / "demo.toml"
+        filename.write_bytes(raw.encode("utf-8"))  # win32: avoid CR normalization - what you pass is what you get
+        with filename.open("rb") as file_handler:
+            return tomllib.load(file_handler)
+
+    return _func

tests/config/loader/toml/test_toml_loader.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable
+
+from tox.config.loader.api import ConfigLoadArgs, Override
+from tox.config.loader.toml import TomlLoader
+from tox.config.source.ini_section import IniSection
+
+if TYPE_CHECKING:
+    from configparser import ConfigParser
+
+
+def test_toml_loader_keys(mk_toml_conf: Callable[[str], ConfigParser]) -> None:
+    core = IniSection(None, "tox")
+    loader = TomlLoader(core, mk_toml_conf("\n[tox]\n\na='b'\nc='d'\n\n"), [], core_section=core)
+    assert loader.found_keys() == {"a", "c"}
+
+
+def test_toml_loader_repr(mk_toml_conf: Callable[[str], ConfigParser]) -> None:
+    core = IniSection(None, "tox")
+    loader = TomlLoader(core, mk_toml_conf("\n[tox]\n\na='b'\nc='d'\n\n"), [Override("tox.a=1")], core_section=core)
+    assert repr(loader) == "TomlLoader(section=tox, overrides={'a': [Override('tox.a=1')]})"
+
+
+def test_toml_loader_has_section(mk_toml_conf: Callable[[str], ConfigParser]) -> None:
+    core = IniSection(None, "tox")
+    loader = TomlLoader(core, mk_toml_conf("[magic]\n[tox]\n\na='b'\nc='d'\n\n"), [], core_section=core)
+    assert loader.get_section("magic") is not None
+
+
+def test_toml_loader_has_no_section(mk_toml_conf: Callable[[str], ConfigParser]) -> None:
+    core = IniSection(None, "tox")
+    loader = TomlLoader(core, mk_toml_conf("[tox]\n\na='b'\nc='d'\n\n"), [], core_section=core)
+    assert loader.get_section("magic") is None
+
+
+def test_toml_loader_raw(mk_toml_conf: Callable[[str], ConfigParser]) -> None:
+    core = IniSection(None, "tox")
+    args = ConfigLoadArgs([], "name", None)
+    loader = TomlLoader(core, mk_toml_conf("[tox]\na='b'"), [], core_section=core)
+    result = loader.load(key="a", of_type=str, conf=None, factory=None, args=args)
+    assert result == "b"

tests/config/source/test_discover.py

@@ -10,7 +10,7 @@
 
 def out_no_src(path: Path) -> str:
     return (
-        f"ROOT: No tox.ini or setup.cfg or pyproject.toml found, assuming empty tox.ini at {path}\n"
+        f"ROOT: No tox.ini or tox.toml or setup.cfg or pyproject.toml found, assuming empty tox.ini at {path}\n"
         f"default environments:\npy -> [no description]\n"
     )