tests: add tests for regex and template

Signed-off-by: Henry Schreiner <[email protected]>

Author: henryiii

README.md

@@ -15,7 +15,7 @@ https://github.com/scikit-build/scikit-build-core/issues/230.
 
 > [!WARNING]
 >
-> This plugin is still a WiP!
+> This is still a WiP! The design may still change.
 
 ## For users
 
@@ -64,16 +64,16 @@ needs to have a `"value"` named group (`?P<value>`), which it will set.
 
 **You do not need to depend on dynamic-metadata to write a plugin.** This
 library provides testing and static typing helpers that are not needed at
-runtime.
+runtime, along with a reference implementation that you can either use as
+an example, or use directly if you are fine to require the dependency.
 
 Like PEP 517's hooks, `dynamic-metadata` defines a set of hooks that you can
 implement; one required hook and two optional hooks. The required hook is:
 
 ```python
 def dynamic_metadata(
-    field: str,
-    settings: dict[str, object] | None = None,
-) -> str | dict[str, str | None]: ...  # return the value of the metadata
+    field: str, settings: Mapping[str, Any], project: Mapping[str, Any]
+) -> str | dict[str, Any]: ...  # return the value of the metadata
 ```
 
 The backend will call this hook in the same directory as PEP 517's hooks.
@@ -84,7 +84,8 @@ A plugin can return METADATA 2.2 dynamic status:
 
 ```python
 def dynamic_wheel(
-    field: str, settings: Mapping[str, Any] | None = None
+    field: str,
+    settings: Mapping[str, Any],
 ) -> (
     bool
 ): ...  # Return true if metadata can change from SDist to wheel (METADATA 2.2 feature)
@@ -98,7 +99,7 @@ A plugin can also decide at runtime if it needs extra dependencies:
 
 ```python
 def get_requires_for_dynamic_metadata(
-    settings: Mapping[str, Any] | None = None,
+    settings: Mapping[str, Any],
 ) -> list[str]: ...  # return list of packages to require
 ```
 
@@ -113,6 +114,7 @@ Here is the regex plugin example implementation:
 def dynamic_metadata(
     field: str,
     settings: Mapping[str, Any],
+    _project: Mapping[str, Any],
 ) -> str:
     # Input validation
     if field not in {"version", "description", "requires-python"}:
@@ -147,36 +149,9 @@ library provides some helper functions you can use if you want, but you can
 implement them yourself following the standard provided or vendor the helper
 file (which will be tested and supported).
 
-You should collect the contents of `tool.dynamic-metadata` and load each,
-something like this:
-
-```python
-def load_provider(
-    provider: str,
-    provider_path: str | None = None,
-) -> DynamicMetadataProtocol:
-    if provider_path is None:
-        return importlib.import_module(provider)
-
-    if not Path(provider_path).is_dir():
-        msg = "provider-path must be an existing directory"
-        raise AssertionError(msg)
-
-    try:
-        sys.path.insert(0, provider_path)
-        return importlib.import_module(provider)
-    finally:
-        sys.path.pop(0)
-
-
-for dynamic_metadata in settings.metadata.values():
-    if "provider" in dynamic_metadata:
-        config = dynamic_metadata.copy()
-        provider = config.pop("provider")
-        provider_path = config.pop("provider-path", None)
-        module = load_provider(provider, provider_path)
-        # Run hooks from module
-```
+You should collect the contents of `tool.dynamic-metadata` and load each one.
+You should respect requests for metadata from other plugins, as well; to see
+how to do that, refer to `src/dynamic-metadata/loader.py`.
 
 <!-- prettier-ignore-start -->
 [actions-badge]:            https://github.com/scikit-build/dynamic-metadata/workflows/CI/badge.svg

src/dynamic_metadata/loader.py

@@ -27,7 +27,10 @@ def __dir__() -> list[str]:
 @runtime_checkable
 class DynamicMetadataProtocol(Protocol):
     def dynamic_metadata(
-        self, fields: Iterable[str], settings: dict[str, Any], metadata: dict[str, Any]
+        self,
+        fields: Iterable[str],
+        settings: dict[str, Any],
+        project: Mapping[str, Any],
     ) -> dict[str, Any]: ...
 
 
@@ -40,9 +43,7 @@ def get_requires_for_dynamic_metadata(
 
 @runtime_checkable
 class DynamicMetadataWheelProtocol(DynamicMetadataProtocol, Protocol):
-    def dynamic_wheel(
-        self, field: str, settings: Mapping[str, Any] | None = None
-    ) -> bool: ...
+    def dynamic_wheel(self, field: str, settings: Mapping[str, Any]) -> bool: ...
 
 
 DMProtocols = Union[
@@ -71,7 +72,7 @@ def load_provider(
 
 
 def load_dynamic_metadata(
-    metadata: Mapping[str, Mapping[str, str]],
+    metadata: Mapping[str, Mapping[str, Any]],
 ) -> Generator[tuple[str, DMProtocols | None, dict[str, str]], None, None]:
     for field, orig_config in metadata.items():
         if "provider" in orig_config:
@@ -106,19 +107,14 @@ def __getitem__(self, key: str) -> Any:
             raise ValueError(msg)
 
         provider = self.providers.pop(key)
-        self.project[key] = provider.dynamic_metadata(
-            key, self.settings[key], self.project
-        )
+        self.project[key] = provider.dynamic_metadata(key, self.settings[key], self)
         self.project["dynamic"].remove(key)
 
         return self.project[key]
 
     def __iter__(self) -> Iterator[str]:
         # Iterate over the keys of the static settings
-        yield from self.project
-
-        # Iterate over the keys of the dynamic metadata providers
-        yield from self.providers
+        yield from [*self.project.keys(), *self.providers.keys()]
 
     def __len__(self) -> int:
         return len(self.project) + len(self.providers)
@@ -129,7 +125,7 @@ def __contains__(self, key: object) -> bool:
 
 def process_dynamic_metadata(
     project: Mapping[str, Any],
-    metadata: Mapping[str, Mapping[str, str]],
+    metadata: Mapping[str, Mapping[str, Any]],
 ) -> dict[str, Any]:
     """Process dynamic metadata.
 

src/dynamic_metadata/plugins/__init__.py

@@ -23,7 +23,7 @@ def _process_dynamic_metadata(field: str, action: Callable[[str], str], result:
             msg = f"Field {field!r} must be a list of strings"
             raise RuntimeError(msg)
         return [action(r) for r in result]  # type: ignore[return-value]
-    if field in DICT_STR_FIELDS:
+    if field in DICT_STR_FIELDS | {"readme"}:
         if not isinstance(result, dict) or not all(
             isinstance(v, str) for v in result.values()
         ):

src/dynamic_metadata/plugins/fancy_pypi_readme.py

@@ -7,7 +7,6 @@
 
 __all__ = [
     "dynamic_metadata",
-    "dynamic_requires_needs",
     "get_requires_for_dynamic_metadata",
 ]
 
@@ -19,7 +18,7 @@ def __dir__() -> list[str]:
 def dynamic_metadata(
     field: str,
     settings: dict[str, list[str] | str],
-    metadata: Mapping[str, Any],
+    project: Mapping[str, Any],
 ) -> dict[str, str | None]:
     from hatch_fancy_pypi_readme._builder import build_text
     from hatch_fancy_pypi_readme._config import load_and_validate_config
@@ -42,7 +41,7 @@ def dynamic_metadata(
     if hasattr(config, "substitutions"):
         try:
             text = build_text(
-                config.fragments, config.substitutions, metadata["version"]
+                config.fragments, config.substitutions, project["version"]
             )
         except TypeError:
             # Version 23.2.0 and before don't have a version field
@@ -63,10 +62,3 @@ def get_requires_for_dynamic_metadata(
     _settings: dict[str, object] | None = None,
 ) -> list[str]:
     return ["hatch-fancy-pypi-readme>=22.3"]
-
-
-def dynamic_requires_needs(
-    _field: str,
-    _settings: dict[str, object],
-) -> list[str]:
-    return ["version"]

src/dynamic_metadata/plugins/regex.py

@@ -30,7 +30,7 @@ def _process(match: re.Match[str], remove: str, result: str) -> str:
 def dynamic_metadata(
     field: str,
     settings: Mapping[str, Any],
-    _metadata: Mapping[str, Any],
+    _project: Mapping[str, Any],
 ) -> str:
     # Input validation
     if settings.keys() > KEYS:

src/dynamic_metadata/plugins/setuptools_scm.py

@@ -10,7 +10,7 @@ def __dir__() -> list[str]:
 def dynamic_metadata(
     field: str,
     settings: dict[str, object],
-    _metadata: dict[str, object],
+    _project: dict[str, object],
 ) -> str:
     # this is a classic implementation, waiting for the release of
     # vcs-versioning and an improved public interface

src/dynamic_metadata/plugins/template.py

@@ -7,20 +7,20 @@
 
 from . import _process_dynamic_metadata
 
-__all__ = ["dynamic_metadata", "dynamic_metadata_needs"]
+__all__ = ["dynamic_metadata"]
 
 
 def __dir__() -> list[str]:
     return __all__
 
 
-KEYS = {"needs", "result"}
+KEYS = {"result"}
 
 
 def dynamic_metadata(
     field: str,
     settings: Mapping[str, str | list[str] | dict[str, str] | dict[str, list[str]]],
-    metadata: Mapping[str, Any],
+    project: Mapping[str, Any],
 ) -> str | list[str] | dict[str, str] | dict[str, list[str]]:
     if settings.keys() > KEYS:
         msg = f"Only {KEYS} settings allowed by this plugin"
@@ -34,13 +34,6 @@ def dynamic_metadata(
 
     return _process_dynamic_metadata(
         field,
-        lambda r: r.format(**metadata),
+        lambda r: r.format(project=project),
         result,
     )
-
-
-def dynamic_metadata_needs(
-    field: str,  # noqa: ARG001
-    settings: Mapping[str, Any],
-) -> list[str]:
-    return settings.get("needs", [])

tests/test_package.py

@@ -1,7 +1,68 @@
 from __future__ import annotations
 
-import dynamic_metadata as m
+import dynamic_metadata.loader
 
 
-def test_version():
-    assert m.__version__
+def test_template_basic() -> None:
+    pyproject = dynamic_metadata.loader.process_dynamic_metadata(
+        {
+            "name": "test",
+            "version": "0.1.0",
+            "dynamic": ["requires-python"],
+        },
+        {
+            "requires-python": {
+                "provider": "dynamic_metadata.plugins.template",
+                "result": ">={project[version]}",
+            },
+        },
+    )
+
+    assert pyproject["requires-python"] == ">=0.1.0"
+
+
+def test_template_needs() -> None:
+    # These are intentionally out of order to test the order of processing
+    pyproject = dynamic_metadata.loader.process_dynamic_metadata(
+        {
+            "name": "test",
+            "version": "0.1.0",
+            "dynamic": ["requires-python", "license", "readme"],
+        },
+        {
+            "license": {
+                "provider": "dynamic_metadata.plugins.template",
+                "result": "{project[requires-python]}",
+            },
+            "readme": {
+                "provider": "dynamic_metadata.plugins.template",
+                "result": {"file": "{project[license]}"},
+            },
+            "requires-python": {
+                "provider": "dynamic_metadata.plugins.template",
+                "result": ">={project[version]}",
+            },
+        },
+    )
+
+    assert pyproject["requires-python"] == ">=0.1.0"
+
+
+def test_regex() -> None:
+    pyproject = dynamic_metadata.loader.process_dynamic_metadata(
+        {
+            "name": "test",
+            "version": "0.1.0",
+            "dynamic": ["requires-python"],
+        },
+        {
+            "requires-python": {
+                "provider": "dynamic_metadata.plugins.regex",
+                "input": "pyproject.toml",
+                "regex": r"name = \"(?P<name>.+)\"",
+                "result": ">={name}",
+            },
+        },
+    )
+
+    assert pyproject["requires-python"] == ">=dynamic-metadata"