disable error raise on users without email in package.json

Author: mustafasoylu

src/somesy/package_json/models.py

@@ -1,13 +1,16 @@
 """package.json validation models."""
 
 import re
+from logging import getLogger
 from typing import List, Optional, Union
 
 from pydantic import BaseModel, EmailStr, Field, field_validator
 from typing_extensions import Annotated
 
 from somesy.core.types import HttpUrlStr
 
+logger = getLogger("somesy")
+
 
 class PackageAuthor(BaseModel):
     """Package author model."""
@@ -74,7 +77,7 @@ class PackageJsonConfig(BaseModel):
 
     # convert package author to dict if it is a string
     @classmethod
-    def convert_author(cls, author: str) -> PackageAuthor:
+    def convert_author(cls, author: str) -> Optional[PackageAuthor]:
         """Convert author string to PackageAuthor model."""
         # parse author string to "name <email> (url)" format with regex
         author_match = re.match(NPM_PKG_AUTHOR, author)
@@ -84,6 +87,8 @@ def convert_author(cls, author: str) -> PackageAuthor:
         author_email = author_match[2]
         author_url = author_match[3]
 
+        if author_email is None:
+            return None
         return PackageAuthor(name=author_name, email=author_email, url=author_url)
 
     @field_validator("name")
@@ -116,7 +121,17 @@ def validate_people(cls, v):
         people = []
         for p in v:
             if isinstance(p, str):
-                people.append(cls.convert_author(p))
-            else:
+                author = cls.convert_author(p)
+                if author is not None:
+                    people.append(cls.convert_author(p))
+                else:
+                    logger.warning(
+                        f"Invalid email format for maintainer/contributor {p}, omitting."
+                    )
+            elif p.email is not None:
                 people.append(p)
+            else:
+                logger.warning(
+                    f"Invalid email format for maintainer/contributor {p}, omitting."
+                )
         return people

src/somesy/package_json/writer.py

@@ -35,6 +35,12 @@ def __init__(
     @property
     def authors(self):
         """Return the only author of the package.json file as list."""
+        # check if the author has the correct format
+        if isinstance(author := self._get_property(self._get_key("authors")), str):
+            author = PackageJsonConfig.convert_author(author)
+            if author is None:
+                return []
+
         return [self._get_property(self._get_key("authors"))]
 
     @authors.setter
@@ -43,10 +49,49 @@ def authors(self, authors: List[Person]) -> None:
         authors = self._from_person(authors[0])
         self._set_property(self._get_key("authors"), authors)
 
+    @property
+    def maintainers(self):
+        """Return the maintainers of the package.json file."""
+        # check if the maintainer has the correct format
+        maintainers = self._get_property(self._get_key("maintainers"))
+        # return empty list if maintainers is None
+        if maintainers is None:
+            return []
+
+        maintainers_valid = []
+
+        for maintainer in maintainers:
+            if isinstance(maintainer, str):
+                maintainer = PackageJsonConfig.convert_author(maintainer)
+                if maintainer is None:
+                    continue
+            maintainers_valid.append(maintainer)
+        return maintainers_valid
+
+    @maintainers.setter
+    def maintainers(self, maintainers: List[Person]) -> None:
+        """Set the maintainers of the project."""
+        maintainers = [self._from_person(m) for m in maintainers]
+        self._set_property(self._get_key("maintainers"), maintainers)
+
     @property
     def contributors(self):
         """Return the contributors of the package.json file."""
-        return self._get_property(self._get_key("contributors"))
+        # check if the contributor has the correct format
+        contributors = self._get_property(self._get_key("contributors"))
+        # return empty list if contributors is None
+        if contributors is None:
+            return []
+
+        contributors_valid = []
+
+        for contributor in contributors:
+            if isinstance(contributor, str):
+                contributor = PackageJsonConfig.convert_author(contributor)
+                if contributor is None:
+                    continue
+            contributors_valid.append(contributor)
+        return contributors_valid
 
     @contributors.setter
     def contributors(self, contributors: List[Person]) -> None:
@@ -91,9 +136,12 @@ def _to_person(person) -> Person:
         """Convert package.json dict or str for person format to project metadata person object."""
         if isinstance(person, str):
             # parse from package.json format
-            person = PackageJsonConfig.convert_author(person).model_dump(
-                exclude_none=True
-            )
+            person = PackageJsonConfig.convert_author(person)
+
+            if person is None:
+                return None
+
+            person = person.model_dump(exclude_none=True)
 
         names = list(map(lambda s: s.strip(), person["name"].split()))
         person_obj = {

tests/output/test_package_json_writer.py

@@ -48,6 +48,39 @@ def test_from_to_person(person: Person):
     assert p.email == person.email
     assert p.orcid == person.orcid
 
+    # without email
+    p = PackageJSON._to_person("John Doe")
+    assert p is None
+
+
+def test_only_name(package_json: PackageJSON, person: Person):
+    package_json._data["author"] = "John Doe"
+    package_json._data["maintainers"] = ["Jane Doe"]
+
+    assert len(package_json.authors) == 0
+    assert len(package_json.maintainers) == 0
+
+    # merge and see if it works
+    pm = ProjectMetadata(
+        name="My awesome project",
+        description="Project description",
+        license=LicenseEnum.MIT,
+        version="0.1.0",
+        people=[
+            person.model_copy(
+                update=dict(author=True, publication_author=True, maintainer=True)
+            )
+        ],
+    )
+    package_json.sync(pm)
+
+    assert len(package_json.authors) == 1
+    assert len(package_json.maintainers) == 1
+
+    assert package_json.authors[0]["name"] == person.full_name
+    assert package_json.authors[0]["email"] == person.email
+    assert package_json.authors[0]["url"] == str(person.orcid)
+
 
 def test_person_merge(package_json_file, person: Person):
     pj = PackageJSON(package_json_file)