# SPDX-FileCopyrightText: 2022-present Angus Hollands # # SPDX-License-Identifier: MIT from __future__ import annotations import json import os.path import re import urllib.parse from typing import Any from hatchling.metadata.plugin.interface import MetadataHookInterface AUTHOR_PATTERN = ( r"^(?P[^<(]+?)?[ \t]*(?:<(?P[^>(]+?)>)?[ \t]*(?:\((?P[^)]+?)\)|$)" ) REPOSITORY_PATTERN = r"^(?:(gist|bitbucket|gitlab|github):)?(.*?)$" REPOSITORY_TABLE = { "gitlab": "https://gitlab.com", "github": "https://github.com", "gist": "https://gist.github.com", "bitbucket": "https://bitbucket.org", } class NodeJSMetadataHook(MetadataHookInterface): PLUGIN_NAME = "nodejs" def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.__path = None self.__fields = None self.__contributors_as_maintainers = None self.__homepage_label = None self.__bugs_label = None self.__repository_label = None @property def path(self) -> str: if self.__path is None: version_file = self.config.get("path", "package.json") if not isinstance(version_file, str): raise TypeError( "Option `path` for metadata hook `{}` must be a string".format( self.PLUGIN_NAME ) ) self.__path = version_file return self.__path @property def fields(self) -> None | set[str]: if self.__fields is None: fields = self.config.get("fields", None) if fields is None: self.__fields = None else: if not ( isinstance(fields, list) and all(isinstance(f, str) for f in fields) ): raise TypeError( "Option `fields` for metadata hook `{}` " "must be a list of strings".format(self.PLUGIN_NAME) ) self.__fields = set(fields) return self.__fields @property def contributors_as_maintainers(self) -> bool: if self.__contributors_as_maintainers is None: contributors_as_maintainers = self.config.get( "contributors-as-maintainers", True ) if not isinstance(contributors_as_maintainers, bool): raise TypeError( "Option `contributors-as-maintainers` for metadata hook `{}` " "must be a boolean".format(self.PLUGIN_NAME) ) self.__contributors_as_maintainers = contributors_as_maintainers return self.__contributors_as_maintainers @property def homepage_label(self) -> bool: if self.__homepage_label is None: homepage_label = self.config.get("homepage-label", "Homepage") if not isinstance(homepage_label, str): raise TypeError( "Option `homepage-label` for metadata hook `{}` " "must be a string".format(self.PLUGIN_NAME) ) self.__homepage_label = homepage_label return self.__homepage_label @property def bugs_label(self) -> bool: if self.__bugs_label is None: bug_tracker_label = self.config.get("bugs-label", "Bug Tracker") if not isinstance(bug_tracker_label, str): raise TypeError( "Option `bugs-label` for metadata hook `{}` " "must be a string".format(self.PLUGIN_NAME) ) self.__bugs_label = bug_tracker_label return self.__bugs_label @property def repository_label(self) -> bool: if self.__repository_label is None: bug_tracker_label = self.config.get("repository-label", "Repository") if not isinstance(bug_tracker_label, str): raise TypeError( "Option `repository-label` for metadata hook `{}` " "must be a string".format(self.PLUGIN_NAME) ) self.__repository_label = bug_tracker_label return self.__repository_label def load_package_data(self): path = os.path.normpath(os.path.join(self.root, self.path)) if not os.path.isfile(path): raise OSError(f"file does not exist: {self.path}") with open(path, "r", encoding="utf-8") as f: return json.load(f) def _parse_bugs(self, bugs: str | dict[str, str]) -> str | None: if isinstance(bugs, str): return bugs if "url" not in bugs: return None return bugs["url"] def _parse_person(self, person: dict[str, str]) -> dict[str, str]: result = {} if isinstance(person, dict): if {"url", "email"} & person.keys(): result["name"] = person["name"] if "email" in person: result["email"] = person["email"] return result else: author = person["name"] else: author = person match = re.match(AUTHOR_PATTERN, author) if match is None: raise ValueError(f"Invalid author name: {author}") name, email, _ = match.groups() result = {"name": name} if email is not None: result["email"] = email return result def _parse_repository(self, repository: str | dict[str, str]) -> str: if isinstance(repository, str): match = re.match(REPOSITORY_PATTERN, repository) if match is None: raise ValueError(f"Invalid repository string: {repository}") kind, identifier = match.groups() if kind is None: kind = "github" return urllib.parse.urljoin(REPOSITORY_TABLE[kind], identifier) return repository["url"] def update(self, metadata: dict[str, Any]): package = self.load_package_data() new_metadata = {"name": package["name"]} authors = None maintainers = None if "author" in package: authors = [self._parse_person(package["author"])] if "contributors" in package: contributors = [self._parse_person(p) for p in package["contributors"]] if self.contributors_as_maintainers: maintainers = contributors else: authors = [*(authors or []), *contributors] if authors is not None: new_metadata["authors"] = authors if maintainers is not None: new_metadata["maintainers"] = maintainers if "keywords" in package: new_metadata["keywords"] = package["keywords"] if "description" in package: new_metadata["description"] = package["description"] if "license" in package: new_metadata["license"] = package["license"] # Construct URLs urls = {} if "homepage" in package: urls[self.homepage_label] = package["homepage"] if "bugs" in package: bugs_url = self._parse_bugs(package["bugs"]) if bugs_url is not None: urls[self.bugs_label] = bugs_url if "repository" in package: urls[self.repository_label] = self._parse_repository(package["repository"]) # Write URLs if urls: new_metadata["urls"] = urls # Only use required metadata metadata.update( { k: v for k, v in new_metadata.items() if (self.fields is None or k in self.fields) } )