Add conditional settings

Author: ziima

src/tox/config/loader/convert.py

@@ -4,9 +4,11 @@
 from abc import ABC, abstractmethod
 from collections import OrderedDict
 from inspect import isclass
+from itertools import chain
 from pathlib import Path
-from typing import Any, Callable, Dict, Generic, Iterator, List, Literal, Optional, Set, TypeVar, Union, cast
+from typing import Any, Callable, Dict, Generic, Iterable, Iterator, List, Literal, Optional, Set, TypeVar, Union, cast
 
+from tox.config.loader.ini.factor import find_factor_groups
 from tox.config.types import Command, EnvList
 
 _NO_MAPPING = object()
@@ -16,6 +18,44 @@
 Factory = Optional[Callable[[object], T]]  # note the argument is anything, due e.g. memory loader can inject anything
 
 
+class ConditionalValue(Generic[T]):
+    """Value with a condition."""
+
+    def __init__(self, value: T, condition: str | None) -> None:
+        self.value = value
+        self.condition = condition
+        self._groups = tuple(find_factor_groups(condition)) if condition is not None else ()
+
+    def matches(self, env_name: str) -> bool:
+        """Return whether the value matches the environment name."""
+        if self.condition is None:
+            return True
+
+        # Split env_name to factors.
+        env_factors = set(chain.from_iterable([(i for i, _ in a) for a in find_factor_groups(env_name)]))
+
+        matches = []
+        for group in self._groups:
+            group_matches = []
+            for factor, negate in group:
+                group_matches.append((factor in env_factors) ^ negate)
+            matches.append(all(group_matches))
+        return any(matches)
+
+
+class ConditionalSetting(Generic[T]):
+    """Setting whose value depends on various conditions."""
+
+    def __init__(self, values: typing.Iterable[ConditionalValue[T]]) -> None:
+        self.values = tuple(values)
+
+    def filter(self, env_name: str) -> Iterable[T]:
+        """Filter values for the environment."""
+        for value in self.values:
+            if value.matches(env_name):
+                yield value.value
+
+
 class Convert(ABC, Generic[T]):
     """A class that converts a raw type to a given tox (python) type."""
 

src/tox/config/loader/ini/factor.py

@@ -60,7 +60,11 @@ def expand_factors(value: str) -> Iterator[tuple[list[list[tuple[str, bool]]] |
 
 
 def find_factor_groups(value: str) -> Iterator[list[tuple[str, bool]]]:
-    """Transform '{py,!pi}-{a,b},c' to [{'py', 'a'}, {'py', 'b'}, {'pi', 'a'}, {'pi', 'b'}, {'c'}]."""
+    """Transform '{py,!pi}-{a,b},c' to [[('py', False), ('a', False)],
+    [('py', False), ('b', False)],
+    [('pi', True), ('a', False)],
+    [('pi', False), ('b', True)],
+    [('c', False)]]."""
     for env in expand_env_with_negation(value):
         result = [name_with_negate(f) for f in env.split("-")]
         yield result

tests/config/loader/test_convert.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import Any, Iterable
+
+import pytest
+
+from tox.config.loader.convert import ConditionalSetting, ConditionalValue
+
+
+@pytest.mark.parametrize(
+    ("condition", "env_name", "result"),
+    [
+        (None, "a", True),
+        (None, "a-b", True),
+        ("a", "a", True),
+        ("!a", "a", False),
+        ("a", "b", False),
+        ("!a", "b", True),
+        ("a", "a-b", True),
+        ("!a", "a-b", False),
+        # or
+        ("a,b", "a", True),
+        ("a,b", "b", True),
+        ("a,b", "c", False),
+        ("a,b", "a-b", True),
+        ("!a,!b", "c", True),
+        # and
+        ("a-b", "a", False),
+        ("a-b", "c", False),
+        ("a-b", "a-b", True),
+        ("a-!b", "a-b", False),
+        ("!a-b", "a-b", False),
+    ],
+)
+def test_conditional_value_matches(condition: str, env_name: str, result: bool) -> None:
+    assert ConditionalValue(42, condition).matches(env_name) is result
+
+
+@pytest.mark.parametrize(
+    ("values", "env_name", "result"),
+    [
+        ([], "a", []),
+        ([ConditionalValue(42, None)], "a", [42]),
+        ([ConditionalValue(42, None)], "b", [42]),
+        ([ConditionalValue(42, "!a")], "a", []),
+        ([ConditionalValue(42, "!a")], "b", [42]),
+        ([ConditionalValue(42, "a"), ConditionalValue(43, "!a")], "a", [42]),
+        ([ConditionalValue(42, "a"), ConditionalValue(43, "!a")], "b", [43]),
+        ([ConditionalValue(42, "a"), ConditionalValue(43, "a")], "a", [42, 43]),
+    ],
+)
+def test_conditional_setting_filter(values: Iterable[ConditionalValue], env_name: str, result: list[Any]) -> None:
+    setting = ConditionalSetting(values)
+    assert list(setting.filter(env_name)) == result