Internal changes to support tox-gh-actions (#2191)

Author: gaborbernat

docs/changelog/2191.bugfix.rst

@@ -0,0 +1 @@
+Fix the ``tox_configure`` plugin entrypoint is not called -- by :user:`gaborbernat`.

docs/changelog/2191.feature.rst

@@ -0,0 +1,2 @@
+Expose the parsed CLI arguments on the main configuration object for plugins and allow plugins to define their own
+configuration section -- by :user:`gaborbernat`.

src/tox/config/loader/api.py

@@ -49,10 +49,15 @@ def __ne__(self, other: Any) -> bool:
 class Loader(Convert[T]):
     """Loader loads a configuration value and converts it."""
 
-    def __init__(self, overrides: List[Override]) -> None:
+    def __init__(self, section: str, overrides: List[Override]) -> None:
+        self._section_name = section
         self.overrides = {o.key: o for o in overrides}
         self.parent: Optional["Loader[Any]"] = None
 
+    @property
+    def section_name(self) -> str:
+        return self._section_name
+
     @abstractmethod
     def load_raw(self, key: str, conf: Optional["Config"], env_name: Optional[str]) -> T:  # noqa: U100
         """

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

@@ -26,7 +26,7 @@ def __init__(self, section: str, parser: ConfigParser, overrides: List[Override]
         self._section: SectionProxy = parser[section]
         self._parser = parser
         self.core_prefix = core_prefix
-        super().__init__(overrides)
+        super().__init__(section, overrides)
 
     def load_raw(self, key: str, conf: Optional["Config"], env_name: Optional[str]) -> str:
         return self.process_raw(conf, env_name, self._section[key])

src/tox/config/loader/memory.py

@@ -10,7 +10,7 @@
 
 class MemoryLoader(Loader[Any]):
     def __init__(self, **kwargs: Any) -> None:
-        super().__init__([])
+        super().__init__("<memory>", [])
         self.raw: Dict[str, Any] = {**kwargs}
 
     def load_raw(self, key: Any, conf: Optional["Config"], env_name: Optional[str]) -> T:  # noqa: U100

src/tox/config/main.py

@@ -1,41 +1,48 @@
 import os
 from collections import OrderedDict, defaultdict
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Optional, Sequence, Tuple
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, Optional, Sequence, Tuple, Type, TypeVar
 
-from tox.config.loader.api import Loader, Override, OverrideMap
+from tox.config.loader.api import Loader, OverrideMap
 
-from .sets import CoreConfigSet, EnvConfigSet
+from .sets import ConfigSet, CoreConfigSet, EnvConfigSet
 from .source import Source
 
 if TYPE_CHECKING:
     from .cli.parser import Parsed
 
+T = TypeVar("T", bound=ConfigSet)
+
 
 class Config:
     """Main configuration object for tox."""
 
     def __init__(
         self,
         config_source: Source,
-        overrides: List[Override],
+        options: "Parsed",
         root: Path,
         pos_args: Optional[Sequence[str]],
         work_dir: Path,
     ) -> None:
         self._pos_args = None if pos_args is None else tuple(pos_args)
         self._work_dir = work_dir
         self._root = root
+        self._options = options
 
         self._overrides: OverrideMap = defaultdict(list)
-        for override in overrides:
+        for override in options.override:
             self._overrides[override.namespace].append(override)
 
         self._src = config_source
         self._env_to_set: Dict[str, EnvConfigSet] = OrderedDict()
         self._core_set: Optional[CoreConfigSet] = None
         self.register_config_set: Callable[[str, EnvConfigSet], Any] = lambda n, e: None
 
+        from tox.plugin.manager import MANAGER
+
+        MANAGER.tox_configure(self)
+
     def pos_args(self, to_path: Optional[Path]) -> Optional[Tuple[str, ...]]:
         """
         :param to_path: if not None rewrite relative posargs paths from cwd to to_path
@@ -85,18 +92,22 @@ def make(cls, parsed: "Parsed", pos_args: Optional[Sequence[str]], source: Sourc
         work_dir: Path = source.path.parent if parsed.work_dir is None else parsed.work_dir
         return cls(
             config_source=source,
-            overrides=parsed.override,
+            options=parsed,
             pos_args=pos_args,
             root=root,
             work_dir=work_dir,
         )
 
+    @property
+    def options(self) -> "Parsed":
+        return self._options
+
     @property
     def core(self) -> CoreConfigSet:
         """:return: the core configuration"""
         if self._core_set is not None:
             return self._core_set
-        core = CoreConfigSet(self, self._root)
+        core = CoreConfigSet(self, self._root, self.src_path)
         for loader in self._src.get_core(self._overrides):
             core.loaders.append(loader)
 
@@ -106,6 +117,12 @@ def core(self) -> CoreConfigSet:
         self._core_set = core
         return core
 
+    def get_section_config(self, section_name: str, of_type: Type[T]) -> T:
+        conf_set = of_type(self)
+        for loader in self._src.get_section(section_name, self._overrides):
+            conf_set.loaders.append(loader)
+        return conf_set
+
     def get_env(
         self, item: str, package: bool = False, loaders: Optional[Sequence[Loader[Any]]] = None
     ) -> EnvConfigSet:

src/tox/config/of_type.py

@@ -18,19 +18,22 @@
 class ConfigDefinition(ABC, Generic[T]):
     """Abstract base class for configuration definitions"""
 
-    def __init__(self, keys: Iterable[str], desc: str, env_name: Optional[str]) -> None:
+    def __init__(self, keys: Iterable[str], desc: str) -> None:
         self.keys = keys
         self.desc = desc
-        self.env_name = env_name
 
     @abstractmethod
     def __call__(
-        self, conf: "Config", key: Optional[str], loaders: List[Loader[T]], chain: List[str]  # noqa: U100
+        self,
+        conf: "Config",  # noqa: U100
+        loaders: List[Loader[T]],  # noqa: U100
+        env_name: Optional[str],  # noqa: U100
+        chain: Optional[List[str]],  # noqa: U100
     ) -> T:
         raise NotImplementedError
 
     def __eq__(self, o: Any) -> bool:
-        return type(self) == type(o) and (self.keys, self.desc, self.env_name) == (o.keys, o.desc, o.env_name)
+        return type(self) == type(o) and (self.keys, self.desc) == (o.keys, o.desc)
 
     def __ne__(self, o: Any) -> bool:
         return not (self == o)
@@ -43,14 +46,17 @@ def __init__(
         self,
         keys: Iterable[str],
         desc: str,
-        env_name: Optional[str],
         value: Union[Callable[[], T], T],
     ) -> None:
-        super().__init__(keys, desc, env_name)
+        super().__init__(keys, desc)
         self.value = value
 
     def __call__(
-        self, conf: "Config", name: Optional[str], loaders: List[Loader[T]], chain: List[str]  # noqa: U100
+        self,
+        conf: "Config",  # noqa: U100
+        loaders: List[Loader[T]],  # noqa: U100
+        env_name: Optional[str],  # noqa: U100
+        chain: Optional[List[str]],  # noqa: U100
     ) -> T:
         if callable(self.value):
             value = self.value()
@@ -72,36 +78,39 @@ def __init__(
         self,
         keys: Iterable[str],
         desc: str,
-        env_name: Optional[str],
         of_type: Type[T],
         default: Union[Callable[["Config", Optional[str]], T], T],
         post_process: Optional[Callable[[T], T]] = None,
         kwargs: Optional[Mapping[str, Any]] = None,
     ) -> None:
-        super().__init__(keys, desc, env_name)
+        super().__init__(keys, desc)
         self.of_type = of_type
         self.default = default
         self.post_process = post_process
         self.kwargs: Mapping[str, Any] = {} if kwargs is None else kwargs
         self._cache: Union[object, T] = _PLACE_HOLDER
 
     def __call__(
-        self,
-        conf: "Config",
-        name: Optional[str],  # noqa: U100
-        loaders: List[Loader[T]],
-        chain: List[str],
+        self, conf: "Config", loaders: List[Loader[T]], env_name: Optional[str], chain: Optional[List[str]]
     ) -> T:
+        if chain is None:
+            chain = []
         if self._cache is _PLACE_HOLDER:
             for key, loader in product(self.keys, loaders):
+                chain_key = f"{loader.section_name}.{key}"
+                if chain_key in chain:
+                    raise ValueError(f"circular chain detected {', '.join(chain[chain.index(chain_key):])}")
+                chain.append(chain_key)
                 try:
-                    value = loader.load(key, self.of_type, self.kwargs, conf, self.env_name, chain)
+                    value = loader.load(key, self.of_type, self.kwargs, conf, env_name, chain)
                 except KeyError:
                     continue
                 else:
                     break
+                finally:
+                    del chain[-1]
             else:
-                value = self.default(conf, self.env_name) if callable(self.default) else self.default
+                value = self.default(conf, env_name) if callable(self.default) else self.default
             if self.post_process is not None:
                 value = self.post_process(value)  # noqa
             self._cache = value

src/tox/config/sets.py

@@ -30,8 +30,7 @@
 class ConfigSet:
     """A set of configuration that belong together (such as a tox environment settings, core tox settings)"""
 
-    def __init__(self, conf: "Config", name: Optional[str]):
-        self._name = name
+    def __init__(self, conf: "Config"):
         self._conf = conf
         self.loaders: List[Loader[Any]] = []
         self._defined: Dict[str, ConfigDefinition[Any]] = {}
@@ -59,7 +58,7 @@ def add_config(
         :return: the new dynamic config definition
         """
         keys_ = self._make_keys(keys)
-        definition = ConfigDynamicDefinition(keys_, desc, self._name, of_type, default, post_process, kwargs)
+        definition = ConfigDynamicDefinition(keys_, desc, of_type, default, post_process, kwargs)
         result = self._add_conf(keys_, definition)
         return cast(ConfigDynamicDefinition[V], result)
 
@@ -73,7 +72,7 @@ def add_constant(self, keys: Union[str, Sequence[str]], desc: str, value: V) ->
         :return: the new constant config value
         """
         keys_ = self._make_keys(keys)
-        definition = ConfigConstantDefinition(keys_, desc, self._name, value)
+        definition = ConfigConstantDefinition(keys_, desc, value)
         result = self._add_conf(keys_, definition)
         return cast(ConfigConstantDefinition[V], result)
 
@@ -84,12 +83,7 @@ def _make_keys(keys: Union[str, Sequence[str]]) -> Sequence[str]:
     def _add_conf(self, keys: Sequence[str], definition: ConfigDefinition[V]) -> ConfigDefinition[V]:
         key = keys[0]
         if key in self._defined:
-            earlier = self._defined[key]
-            # core definitions may be defined multiple times as long as all their options match, first defined wins
-            if self._name is None and definition == earlier:
-                definition = earlier
-            else:
-                raise ValueError(f"config {key} already defined")
+            self._on_duplicate_conf(key, definition)
         else:
             self._keys[key] = None
             for item in keys:
@@ -98,6 +92,11 @@ def _add_conf(self, keys: Sequence[str], definition: ConfigDefinition[V]) -> Con
                 self._defined[key] = definition
         return definition
 
+    def _on_duplicate_conf(self, key: str, definition: ConfigDefinition[V]) -> None:
+        earlier = self._defined[key]
+        if definition != earlier:  # pragma: no branch
+            raise ValueError(f"config {key} already defined")
+
     def __getitem__(self, item: str) -> Any:
         """
         Get the config value for a given key (will materialize in case of dynamic config).
@@ -116,18 +115,14 @@ def load(self, item: str, chain: Optional[List[str]] = None) -> Any:
         :return: the configuration value
         """
         config_definition = self._defined[item]
-        if chain is None:
-            chain = []
-        env_name = "tox" if self._name is None else f"testenv:{self._name}"
-        key = f"{env_name}.{item}"
-        if key in chain:
-            raise ValueError(f"circular chain detected {', '.join(chain[chain.index(key):])}")
-        chain.append(key)
-        return config_definition(self._conf, item, self.loaders, chain)
+        return config_definition.__call__(self._conf, self.loaders, self.name, chain)
+
+    @property
+    def name(self) -> Optional[str]:
+        return None
 
     def __repr__(self) -> str:
-        values = (v for v in (f"name={self._name!r}" if self._name else "", f"loaders={self.loaders!r}") if v)
-        return f"{self.__class__.__name__}({', '.join(values)})"
+        return f"{self.__class__.__name__}(loaders={self.loaders!r})"
 
     def __iter__(self) -> Iterator[str]:
         """:return: iterate through the defined config keys (primary keys used)"""
@@ -166,8 +161,9 @@ def primary_key(self, key: str) -> str:
 class CoreConfigSet(ConfigSet):
     """Configuration set for the core tox config"""
 
-    def __init__(self, conf: "Config", root: Path) -> None:
-        super().__init__(conf, name=None)
+    def __init__(self, conf: "Config", root: Path, src_path: Path) -> None:
+        super().__init__(conf)
+        self.add_constant(keys=["config_file_path"], desc="path to the configuration file", value=src_path)
         self.add_config(
             keys=["tox_root", "toxinidir"],
             of_type=Path,
@@ -198,12 +194,16 @@ def work_dir_builder(conf: "Config", env_name: Optional[str]) -> Path:  # noqa
             desc="define environments to automatically run",
         )
 
+    def _on_duplicate_conf(self, key: str, definition: ConfigDefinition[V]) -> None:  # noqa: U100
+        pass  # core definitions may be defined multiple times as long as all their options match, first defined wins
+
 
 class EnvConfigSet(ConfigSet):
     """Configuration set for a tox environment"""
 
-    def __init__(self, conf: "Config", name: Optional[str]):
-        super().__init__(conf, name=name)
+    def __init__(self, conf: "Config", name: str):
+        self._name = name
+        super().__init__(conf)
         self.default_set_env_loader: Callable[[], Mapping[str, str]] = lambda: {}
 
         def set_env_post_process(values: SetEnv) -> SetEnv:
@@ -220,7 +220,10 @@ def set_env_post_process(values: SetEnv) -> SetEnv:
 
     @property
     def name(self) -> str:
-        return self._name  # type: ignore
+        return self._name
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self._name!r}, loaders={self.loaders!r})"
 
 
 __all__ = (

src/tox/config/source/api.py

@@ -28,6 +28,17 @@ def get_core(self, override_map: OverrideMap) -> Iterator[Loader[Any]]:  # noqa:
         """
         raise NotImplementedError
 
+    @abstractmethod
+    def get_section(self, name: str, override_map: OverrideMap) -> Iterator[Loader[Any]]:  # noqa: U100
+        """
+        Return a loader that loads the core configuration values.
+
+        :param name: name of the section to load
+        :param override_map: a list of overrides to apply
+        :returns: the core loader from this source
+        """
+        raise NotImplementedError
+
     @abstractmethod
     def get_env_loaders(
         self, env_name: str, override_map: OverrideMap, package: bool, conf: ConfigSet  # noqa: U100