add julia module

Author: mustafasoylu

src/somesy/julia/__init__.py

@@ -0,0 +1,4 @@
+"""Julia module."""
+from .writer import Julia
+
+__all__ = ["Julia"]

src/somesy/julia/models.py

@@ -0,0 +1,68 @@
+"""Julia model."""
+import uuid
+from typing import Optional, Set
+
+from packaging.version import parse as parse_version
+from pydantic import (
+    BaseModel,
+    EmailStr,
+    Field,
+    TypeAdapter,
+    field_validator,
+)
+from typing_extensions import Annotated
+
+EMailAddress = TypeAdapter(EmailStr)
+
+
+class JuliaConfig(BaseModel):
+    """Julia configuration model."""
+
+    model_config = dict(use_enum_values=True)
+
+    name: Annotated[
+        str,
+        Field(description="Package name"),
+    ]
+    version: Annotated[
+        str,
+        Field(
+            pattern=r"^\d+(\.\d+)*((a|b|rc)\d+)?(post\d+)?(dev\d+)?$",
+            description="Package version",
+        ),
+    ]
+    uuid: Annotated[str, Field(description="Package UUID")]
+    authors: Annotated[Optional[Set[str]], Field(description="Package authors")] = None
+
+    @field_validator("version")
+    @classmethod
+    def validate_version(cls, v):
+        """Validate version using PEP 440."""
+        try:
+            _ = parse_version(v)
+        except ValueError as err:
+            raise ValueError("Invalid version") from err
+        return v
+
+    @field_validator("authors")
+    @classmethod
+    def validate_email_format(cls, v):
+        """Validate email format."""
+        for author in v:
+            if (
+                not isinstance(author, str)
+                or " " not in author
+                or not EMailAddress.validate_python(author.split(" ")[-1][1:-1])
+            ):
+                raise ValueError("Invalid email format")
+        return v
+
+    @field_validator("uuid")
+    @classmethod
+    def validate_uuid(cls, v):
+        """Validate uuid field."""
+        try:
+            _ = uuid.UUID(v)
+        except ValueError as err:
+            raise ValueError("Invalid UUID") from err
+        return v

src/somesy/julia/writer.py

@@ -0,0 +1,81 @@
+"""Julia writer."""
+import logging
+import re
+from pathlib import Path
+from typing import Optional
+
+import tomlkit
+from rich.pretty import pretty_repr
+
+from somesy.core.models import Person, ProjectMetadata
+from somesy.core.writer import ProjectMetadataWriter
+
+from .models import JuliaConfig
+
+logger = logging.getLogger("somesy")
+
+
+class Julia(ProjectMetadataWriter):
+    """Julia config file handler parsed from Project.toml."""
+
+    def __init__(self, path: Path):
+        """Julia config file handler parsed from Project.toml.
+
+        See [somesy.core.writer.ProjectMetadataWriter.__init__][].
+        """
+        super().__init__(path, create_if_not_exists=False)
+
+    def _load(self) -> None:
+        """Load Project.toml file."""
+        with open(self.path) as f:
+            self._data = tomlkit.load(f)
+
+    def _validate(self) -> None:
+        """Validate poetry config using pydantic class.
+
+        In order to preserve toml comments and structure, tomlkit library is used.
+        Pydantic class only used for validation.
+        """
+        config = dict(self._get_property([]))
+        logger.debug(
+            f"Validating config using {JuliaConfig.__name__}: {pretty_repr(config)}"
+        )
+        JuliaConfig(**config)
+
+    def save(self, path: Optional[Path] = None) -> None:
+        """Save the julia file."""
+        path = path or self.path
+        with open(path, "w") as f:
+            tomlkit.dump(self._data, f)
+
+    @staticmethod
+    def _from_person(person: Person):
+        """Convert project metadata person object to poetry string for person format "full name <email>."""
+        return f"{person.full_name} <{person.email}>"
+
+    @staticmethod
+    def _to_person(person_obj: str) -> Person:
+        """Parse poetry person string to a Person."""
+        m = re.match(r"\s*([^<]+)<([^>]+)>", person_obj)
+        names, mail = (
+            list(map(lambda s: s.strip(), m.group(1).split())),
+            m.group(2).strip(),
+        )
+        # NOTE: for our purposes, does not matter what are given or family names,
+        # we only compare on full_name anyway.
+        return Person(
+            **{
+                "given-names": " ".join(names[:-1]),
+                "family-names": names[-1],
+                "email": mail,
+            }
+        )
+
+    def sync(self, metadata: ProjectMetadata) -> None:
+        """Sync output file with other metadata files."""
+        self.name = metadata.name
+
+        if metadata.version:
+            self.version = metadata.version
+
+        self._sync_authors(metadata)