| # SPDX-License-Identifier: Apache-2.0 |
| # Copyright © 2022-2024 Intel Corporation |
| |
| """Type definitions for cargo manifest files.""" |
| |
| from __future__ import annotations |
| |
| import dataclasses |
| import os |
| import typing as T |
| |
| from . import version |
| from ..mesonlib import MesonException, lazy_property |
| from .. import mlog |
| |
| if T.TYPE_CHECKING: |
| from typing_extensions import Protocol, Self |
| |
| from . import raw |
| from .raw import EDITION, CRATE_TYPE |
| |
| # Copied from typeshed. Blarg that they don't expose this |
| class DataclassInstance(Protocol): |
| __dataclass_fields__: T.ClassVar[dict[str, dataclasses.Field[T.Any]]] |
| |
| _DI = T.TypeVar('_DI', bound='DataclassInstance') |
| _R = T.TypeVar('_R', bound='raw._BaseBuildTarget') |
| |
| _EXTRA_KEYS_WARNING = ( |
| "This may (unlikely) be an error in the cargo manifest, or may be a missing " |
| "implementation in Meson. If this issue can be reproduced with the latest " |
| "version of Meson, please help us by opening an issue at " |
| "https://github.com/mesonbuild/meson/issues. Please include the crate and " |
| "version that is generating this warning if possible." |
| ) |
| |
| |
| def fixup_meson_varname(name: str) -> str: |
| """Fixup a meson variable name |
| |
| :param name: The name to fix |
| :return: the fixed name |
| """ |
| return name.replace('-', '_') |
| |
| |
| @T.overload |
| def _depv_to_dep(depv: raw.FromWorkspace) -> raw.FromWorkspace: ... |
| |
| @T.overload |
| def _depv_to_dep(depv: raw.DependencyV) -> raw.Dependency: ... |
| |
| def _depv_to_dep(depv: T.Union[raw.FromWorkspace, raw.DependencyV]) -> T.Union[raw.FromWorkspace, raw.Dependency]: |
| return {'version': depv} if isinstance(depv, str) else depv |
| |
| |
| def _raw_to_dataclass(raw: T.Mapping[str, object], cls: T.Type[_DI], |
| msg: str, **kwargs: T.Callable[[T.Any], object]) -> _DI: |
| """Fixup raw cargo mappings to ones more suitable for python to consume as dataclass. |
| |
| * Replaces any `-` with `_` in the keys. |
| * Optionally pass values through the functions in kwargs, in order to do |
| recursive conversions. |
| * Remove and warn on keys that are coming from cargo, but are unknown to |
| our representations. |
| |
| This is intended to give users the possibility of things proceeding when a |
| new key is added to Cargo.toml that we don't yet handle, but to still warn |
| them that things might not work. |
| |
| :param data: The raw data to look at |
| :param cls: The Dataclass derived type that will be created |
| :param msg: the header for the error message. Usually something like "In N structure". |
| :return: The original data structure, but with all unknown keys removed. |
| """ |
| new_dict = {} |
| unexpected = set() |
| fields = {x.name for x in dataclasses.fields(cls)} |
| for orig_k, v in raw.items(): |
| k = fixup_meson_varname(orig_k) |
| if k not in fields: |
| unexpected.add(orig_k) |
| continue |
| if k in kwargs: |
| v = kwargs[k](v) |
| new_dict[k] = v |
| |
| if unexpected: |
| mlog.warning(msg, 'has unexpected keys', '"{}".'.format(', '.join(sorted(unexpected))), |
| _EXTRA_KEYS_WARNING) |
| return cls(**new_dict) |
| |
| |
| @T.overload |
| def _inherit_from_workspace(raw: raw.Package, |
| raw_from_workspace: T.Optional[T.Mapping[str, object]], |
| msg: str, |
| **kwargs: T.Callable[[T.Any, T.Any], object]) -> raw.Package: ... |
| |
| @T.overload |
| def _inherit_from_workspace(raw: T.Union[raw.FromWorkspace, raw.Dependency], |
| raw_from_workspace: T.Optional[T.Mapping[str, object]], |
| msg: str, |
| **kwargs: T.Callable[[T.Any, T.Any], object]) -> raw.Dependency: ... |
| |
| def _inherit_from_workspace(raw_: T.Union[raw.FromWorkspace, raw.Package, raw.Dependency], # type: ignore[misc] |
| raw_from_workspace: T.Optional[T.Mapping[str, object]], |
| msg: str, |
| **kwargs: T.Callable[[T.Any, T.Any], object]) -> T.Mapping[str, object]: |
| # allow accesses by non-literal key below |
| raw = T.cast('T.Mapping[str, object]', raw_) |
| |
| if not raw_from_workspace: |
| if raw.get('workspace', False) or \ |
| any(isinstance(v, dict) and v.get('workspace', False) for v in raw): |
| raise MesonException(f'Cargo.toml file requests {msg} from workspace') |
| |
| return raw |
| |
| result = {k: v for k, v in raw.items() if k != 'workspace'} |
| for k, v in raw.items(): |
| if isinstance(v, dict) and v.get('workspace', False): |
| if k in raw_from_workspace: |
| result[k] = raw_from_workspace[k] |
| if k in kwargs: |
| result[k] = kwargs[k](v, result[k]) |
| else: |
| del result[k] |
| |
| if raw.get('workspace', False): |
| for k, v in raw_from_workspace.items(): |
| if k not in result or k in kwargs: |
| if k in kwargs: |
| v = kwargs[k](raw.get(k), v) |
| result[k] = v |
| return result |
| |
| |
| @dataclasses.dataclass |
| class Package: |
| |
| """Representation of a Cargo Package entry, with defaults filled in.""" |
| |
| name: str |
| version: str |
| description: T.Optional[str] = None |
| resolver: T.Optional[str] = None |
| authors: T.List[str] = dataclasses.field(default_factory=list) |
| edition: EDITION = '2015' |
| rust_version: T.Optional[str] = None |
| documentation: T.Optional[str] = None |
| readme: T.Optional[str] = None |
| homepage: T.Optional[str] = None |
| repository: T.Optional[str] = None |
| license: T.Optional[str] = None |
| license_file: T.Optional[str] = None |
| keywords: T.List[str] = dataclasses.field(default_factory=list) |
| categories: T.List[str] = dataclasses.field(default_factory=list) |
| workspace: T.Optional[str] = None |
| build: T.Optional[str] = None |
| links: T.Optional[str] = None |
| exclude: T.List[str] = dataclasses.field(default_factory=list) |
| include: T.List[str] = dataclasses.field(default_factory=list) |
| publish: bool = True |
| metadata: T.Dict[str, T.Any] = dataclasses.field(default_factory=dict) |
| default_run: T.Optional[str] = None |
| autolib: bool = True |
| autobins: bool = True |
| autoexamples: bool = True |
| autotests: bool = True |
| autobenches: bool = True |
| |
| @lazy_property |
| def api(self) -> str: |
| return version.api(self.version) |
| |
| @classmethod |
| def from_raw(cls, raw_pkg: raw.Package, workspace: T.Optional[Workspace] = None) -> Self: |
| raw_ws_pkg = None |
| if workspace is not None: |
| raw_ws_pkg = workspace.package |
| |
| raw_pkg = _inherit_from_workspace(raw_pkg, raw_ws_pkg, f'Package entry {raw_pkg["name"]}') |
| return _raw_to_dataclass(raw_pkg, cls, f'Package entry {raw_pkg["name"]}') |
| |
| @dataclasses.dataclass |
| class SystemDependency: |
| |
| """ Representation of a Cargo system-deps entry |
| https://docs.rs/system-deps/latest/system_deps |
| """ |
| |
| name: str |
| version: str = '' |
| optional: bool = False |
| feature: T.Optional[str] = None |
| # TODO: convert values to dataclass |
| feature_overrides: T.Dict[str, T.Dict[str, str]] = dataclasses.field(default_factory=dict) |
| |
| @classmethod |
| def from_raw(cls, name: str, raw: T.Union[T.Dict[str, T.Any], str]) -> SystemDependency: |
| if isinstance(raw, str): |
| raw = {'version': raw} |
| name = raw.get('name', name) |
| version = raw.get('version', '') |
| optional = raw.get('optional', False) |
| feature = raw.get('feature') |
| # Everything else are overrides when certain features are enabled. |
| feature_overrides = {k: v for k, v in raw.items() if k not in {'name', 'version', 'optional', 'feature'}} |
| return cls(name, version, optional, feature, feature_overrides) |
| |
| @lazy_property |
| def meson_version(self) -> T.List[str]: |
| vers = self.version.split(',') if self.version else [] |
| result: T.List[str] = [] |
| for v in vers: |
| v = v.strip() |
| if v[0] not in '><=': |
| v = f'>={v}' |
| result.append(v) |
| return result |
| |
| def enabled(self, features: T.Set[str]) -> bool: |
| return self.feature is None or self.feature in features |
| |
| @dataclasses.dataclass |
| class Dependency: |
| |
| """Representation of a Cargo Dependency Entry.""" |
| |
| package: str |
| version: str = '' |
| registry: T.Optional[str] = None |
| git: T.Optional[str] = None |
| branch: T.Optional[str] = None |
| rev: T.Optional[str] = None |
| path: T.Optional[str] = None |
| optional: bool = False |
| default_features: bool = True |
| features: T.List[str] = dataclasses.field(default_factory=list) |
| |
| @lazy_property |
| def meson_version(self) -> T.List[str]: |
| return version.convert(self.version) |
| |
| @lazy_property |
| def api(self) -> str: |
| # Extract wanted API version from version constraints. |
| api = set() |
| for v in self.meson_version: |
| if v.startswith(('>=', '==')): |
| api.add(version.api(v[2:].strip())) |
| elif v.startswith('='): |
| api.add(version.api(v[1:].strip())) |
| if not api: |
| return '0' |
| elif len(api) == 1: |
| return api.pop() |
| else: |
| raise MesonException(f'Cannot determine minimum API version from {self.version}.') |
| |
| @classmethod |
| def from_raw_dict(cls, name: str, raw_dep: T.Union[raw.FromWorkspace, raw.Dependency], member_path: str = '', raw_ws_dep: T.Optional[raw.Dependency] = None) -> Dependency: |
| raw_dep = _inherit_from_workspace(raw_dep, raw_ws_dep, |
| f'Dependency entry {name}', |
| path=lambda pkg_path, ws_path: os.path.relpath(ws_path, member_path), |
| features=lambda pkg_path, ws_path: (pkg_path or []) + (ws_path or [])) |
| raw_dep.setdefault('package', name) |
| return _raw_to_dataclass(raw_dep, cls, f'Dependency entry {name}') |
| |
| @classmethod |
| def from_raw(cls, name: str, raw_depv: T.Union[raw.FromWorkspace, raw.DependencyV], member_path: str = '', workspace: T.Optional[Workspace] = None) -> Dependency: |
| """Create a dependency from a raw cargo dictionary or string""" |
| raw_ws_dep: T.Optional[raw.Dependency] = None |
| if workspace is not None: |
| raw_ws_depv = workspace.dependencies.get(name, {}) |
| raw_ws_dep = _depv_to_dep(raw_ws_depv) |
| |
| raw_dep = _depv_to_dep(raw_depv) |
| return cls.from_raw_dict(name, raw_dep, member_path, raw_ws_dep) |
| |
| |
| @dataclasses.dataclass |
| class BuildTarget(T.Generic[_R]): |
| |
| name: str |
| path: str |
| crate_type: T.List[CRATE_TYPE] |
| |
| # https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-test-field |
| # True for lib, bin, test |
| test: bool = True |
| |
| # https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-doctest-field |
| # True for lib |
| doctest: bool = False |
| |
| # https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-bench-field |
| # True for lib, bin, benchmark |
| bench: bool = True |
| |
| # https://doc.rust-lang.org/cargo/reference/cargo-targets.html#the-doc-field |
| # True for libraries and binaries |
| doc: bool = False |
| |
| harness: bool = True |
| edition: EDITION = '2015' |
| required_features: T.List[str] = dataclasses.field(default_factory=list) |
| plugin: bool = False |
| |
| @classmethod |
| def from_raw(cls, raw: _R) -> Self: |
| name = raw.get('name', '<anonymous>') |
| return _raw_to_dataclass(raw, cls, f'Binary entry {name}') |
| |
| @dataclasses.dataclass |
| class Library(BuildTarget['raw.LibTarget']): |
| |
| """Representation of a Cargo Library Entry.""" |
| |
| doctest: bool = True |
| doc: bool = True |
| path: str = os.path.join('src', 'lib.rs') |
| proc_macro: bool = False |
| crate_type: T.List[CRATE_TYPE] = dataclasses.field(default_factory=lambda: ['lib']) |
| doc_scrape_examples: bool = True |
| |
| @classmethod |
| def from_raw(cls, raw: raw.LibTarget, fallback_name: str) -> Self: # type: ignore[override] |
| # We need to set the name field if it's not set manually, including if |
| # other fields are set in the lib section |
| raw.setdefault('name', fallback_name) |
| return _raw_to_dataclass(raw, cls, f'Library entry {raw["name"]}') |
| |
| |
| @dataclasses.dataclass |
| class Binary(BuildTarget['raw.BuildTarget']): |
| |
| """Representation of a Cargo Bin Entry.""" |
| |
| doc: bool = True |
| crate_type: T.List[CRATE_TYPE] = dataclasses.field(default_factory=lambda: ['bin']) |
| |
| @classmethod |
| def from_raw(cls, raw: raw.BuildTarget) -> Self: |
| if 'path' not in raw: |
| raw['path'] = os.path.join('bin', raw['name'] + '.rs') |
| return super().from_raw(raw) |
| |
| |
| @dataclasses.dataclass |
| class Test(BuildTarget['raw.BuildTarget']): |
| |
| """Representation of a Cargo Test Entry.""" |
| |
| bench: bool = True |
| crate_type: T.List[CRATE_TYPE] = dataclasses.field(default_factory=lambda: ['bin']) |
| |
| @classmethod |
| def from_raw(cls, raw: raw.BuildTarget) -> Self: |
| if 'path' not in raw: |
| raw['path'] = os.path.join('tests', raw['name'] + '.rs') |
| return super().from_raw(raw) |
| |
| @dataclasses.dataclass |
| class Benchmark(BuildTarget['raw.BuildTarget']): |
| |
| """Representation of a Cargo Benchmark Entry.""" |
| |
| test: bool = True |
| crate_type: T.List[CRATE_TYPE] = dataclasses.field(default_factory=lambda: ['bin']) |
| |
| @classmethod |
| def from_raw(cls, raw: raw.BuildTarget) -> Self: |
| if 'path' not in raw: |
| raw['path'] = os.path.join('benches', raw['name'] + '.rs') |
| return super().from_raw(raw) |
| |
| |
| @dataclasses.dataclass |
| class Example(BuildTarget['raw.BuildTarget']): |
| |
| """Representation of a Cargo Example Entry.""" |
| |
| crate_type: T.List[CRATE_TYPE] = dataclasses.field(default_factory=lambda: ['bin']) |
| |
| @classmethod |
| def from_raw(cls, raw: raw.BuildTarget) -> Self: |
| if 'path' not in raw: |
| raw['path'] = os.path.join('examples', raw['name'] + '.rs') |
| return super().from_raw(raw) |
| |
| |
| @dataclasses.dataclass |
| class Manifest: |
| |
| """Cargo Manifest definition. |
| |
| Most of these values map up to the Cargo Manifest, but with default values |
| if not provided. |
| |
| Cargo subprojects can contain what Meson wants to treat as multiple, |
| interdependent, subprojects. |
| |
| :param path: the path within the cargo subproject. |
| """ |
| |
| package: Package |
| dependencies: T.Dict[str, Dependency] = dataclasses.field(default_factory=dict) |
| dev_dependencies: T.Dict[str, Dependency] = dataclasses.field(default_factory=dict) |
| build_dependencies: T.Dict[str, Dependency] = dataclasses.field(default_factory=dict) |
| lib: T.Optional[Library] = None |
| bin: T.List[Binary] = dataclasses.field(default_factory=list) |
| test: T.List[Test] = dataclasses.field(default_factory=list) |
| bench: T.List[Benchmark] = dataclasses.field(default_factory=list) |
| example: T.List[Example] = dataclasses.field(default_factory=list) |
| features: T.Dict[str, T.List[str]] = dataclasses.field(default_factory=dict) |
| target: T.Dict[str, T.Dict[str, Dependency]] = dataclasses.field(default_factory=dict) |
| |
| path: str = '' |
| |
| def __post_init__(self) -> None: |
| self.features.setdefault('default', []) |
| |
| @lazy_property |
| def system_dependencies(self) -> T.Dict[str, SystemDependency]: |
| return {k: SystemDependency.from_raw(k, v) for k, v in self.package.metadata.get('system-deps', {}).items()} |
| |
| @classmethod |
| def from_raw(cls, raw: raw.Manifest, path: str = '', workspace: T.Optional[Workspace] = None, member_path: str = '') -> Self: |
| # Libs are always auto-discovered and there's no other way to handle them, |
| # which is unfortunate for reproducability |
| pkg = Package.from_raw(raw['package'], workspace) |
| if pkg.autolib and 'lib' not in raw and \ |
| os.path.exists(os.path.join(path, 'src/lib.rs')): |
| raw['lib'] = {} |
| fixed = _raw_to_dataclass(raw, cls, f'Cargo.toml package {raw["package"]["name"]}', |
| package=lambda x: pkg, |
| dependencies=lambda x: {k: Dependency.from_raw(k, v, member_path, workspace) for k, v in x.items()}, |
| dev_dependencies=lambda x: {k: Dependency.from_raw(k, v, member_path, workspace) for k, v in x.items()}, |
| build_dependencies=lambda x: {k: Dependency.from_raw(k, v, member_path, workspace) for k, v in x.items()}, |
| lib=lambda x: Library.from_raw(x, raw['package']['name']), |
| bin=lambda x: [Binary.from_raw(b) for b in x], |
| test=lambda x: [Test.from_raw(b) for b in x], |
| bench=lambda x: [Benchmark.from_raw(b) for b in x], |
| example=lambda x: [Example.from_raw(b) for b in x], |
| target=lambda x: {k: {k2: Dependency.from_raw(k2, v2, member_path, workspace) for k2, v2 in v.get('dependencies', {}).items()} |
| for k, v in x.items()}) |
| fixed.path = path |
| return fixed |
| |
| |
| @dataclasses.dataclass |
| class Workspace: |
| |
| """Cargo Workspace definition. |
| """ |
| |
| resolver: str = dataclasses.field(default_factory=lambda: '2') |
| members: T.List[str] = dataclasses.field(default_factory=list) |
| exclude: T.List[str] = dataclasses.field(default_factory=list) |
| default_members: T.List[str] = dataclasses.field(default_factory=list) |
| |
| # inheritable settings are kept in raw format, for use with _inherit_from_workspace |
| package: T.Optional[raw.Package] = None |
| dependencies: T.Dict[str, raw.Dependency] = dataclasses.field(default_factory=dict) |
| lints: T.Dict[str, T.Any] = dataclasses.field(default_factory=dict) |
| metadata: T.Dict[str, T.Any] = dataclasses.field(default_factory=dict) |
| |
| # A workspace can also have a root package. |
| root_package: T.Optional[Manifest] = dataclasses.field(init=False) |
| |
| @classmethod |
| def from_raw(cls, raw: raw.VirtualManifest) -> Workspace: |
| ws_raw = raw['workspace'] |
| fixed = _raw_to_dataclass(ws_raw, cls, 'Workspace') |
| return fixed |
| |
| |
| @dataclasses.dataclass |
| class CargoLockPackage: |
| |
| """A description of a package in the Cargo.lock file format.""" |
| |
| name: str |
| version: str |
| source: T.Optional[str] = None |
| checksum: T.Optional[str] = None |
| dependencies: T.List[str] = dataclasses.field(default_factory=list) |
| |
| @classmethod |
| def from_raw(cls, raw: raw.CargoLockPackage) -> CargoLockPackage: |
| return _raw_to_dataclass(raw, cls, 'Cargo.lock package') |
| |
| |
| @dataclasses.dataclass |
| class CargoLock: |
| |
| """A description of the Cargo.lock file format.""" |
| |
| version: int = 1 |
| package: T.List[CargoLockPackage] = dataclasses.field(default_factory=list) |
| metadata: T.Dict[str, str] = dataclasses.field(default_factory=dict) |
| |
| @classmethod |
| def from_raw(cls, raw: raw.CargoLock) -> CargoLock: |
| return _raw_to_dataclass(raw, cls, 'Cargo.lock', |
| package=lambda x: [CargoLockPackage.from_raw(p) for p in x]) |
