!squash more

Author: tony

src/vcspull/models.py renamed to src/vcspull/schemas.py

@@ -1,35 +1,27 @@
-"""Pydantic models for vcspull configuration."""
+"""Pydantic schemas for vcspull configuration."""
 
 from __future__ import annotations
 
+import enum
 import os
 import pathlib
 import typing as t
-from enum import Enum
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
 
 from pydantic import (
     BaseModel,
     ConfigDict,
-    Field,
-    HttpUrl,
+    RootModel,
     field_validator,
-    model_validator,
 )
 
-if t.TYPE_CHECKING:
-    from libvcs._internal.types import VCSLiteral
-    from libvcs.sync.git import GitSyncRemoteDict
-
 # Type aliases for better readability
-PathLike = Union[str, Path]
+PathLike = t.Union[str, pathlib.Path]
 ConfigName = str
 SectionName = str
 ShellCommand = str
 
 
-class VCSType(str, Enum):
+class VCSType(str, enum.Enum):
     """Supported version control systems."""
 
     GIT = "git"
@@ -42,8 +34,8 @@ class GitRemote(BaseModel):
 
     name: str
     url: str
-    fetch: Optional[str] = None
-    push: Optional[str] = None
+    fetch: str | None = None
+    push: str | None = None
 
 
 class RepositoryModel(BaseModel):
@@ -67,10 +59,10 @@ class RepositoryModel(BaseModel):
 
     vcs: str
     name: str
-    path: Union[str, Path]
+    path: str | pathlib.Path
     url: str
-    remotes: Optional[Dict[str, GitRemote]] = None
-    shell_command_after: Optional[List[str]] = None
+    remotes: dict[str, GitRemote] | None = None
+    shell_command_after: list[str] | None = None
 
     model_config = ConfigDict(
         extra="forbid",
@@ -97,15 +89,14 @@ def validate_vcs(cls, v: str) -> str:
         ValueError
             If VCS type is invalid
         """
-        if v.lower() not in ("git", "hg", "svn"):
-            raise ValueError(
-                f"Invalid VCS type: {v}. Supported types are: git, hg, svn"
-            )
+        if v.lower() not in {"git", "hg", "svn"}:
+            msg = f"Invalid VCS type: {v}. Supported types are: git, hg, svn"
+            raise ValueError(msg)
         return v.lower()
 
     @field_validator("path")
     @classmethod
-    def validate_path(cls, v: Union[str, Path]) -> Path:
+    def validate_path(cls, v: str | pathlib.Path) -> pathlib.Path:
         """Validate and convert path to Path object.
 
         Parameters
@@ -127,12 +118,13 @@ def validate_path(cls, v: Union[str, Path]) -> Path:
             # Convert to string first to handle Path objects
             path_str = str(v)
             # Expand environment variables and user directory
-            expanded_path = os.path.expandvars(path_str)
-            expanded_path = os.path.expanduser(expanded_path)
-            # Convert to Path object
-            return Path(expanded_path)
+            path_obj = pathlib.Path(path_str)
+            # Use Path methods instead of os.path
+            expanded_path = pathlib.Path(os.path.expandvars(str(path_obj)))
+            return expanded_path.expanduser()
         except Exception as e:
-            raise ValueError(f"Invalid path: {v}. Error: {str(e)}")
+            msg = f"Invalid path: {v}. Error: {e!s}"
+            raise ValueError(msg) from e
 
     @field_validator("url")
     @classmethod
@@ -157,29 +149,30 @@ def validate_url(cls, v: str, info: t.Any) -> str:
             If URL is invalid
         """
         if not v:
-            raise ValueError("URL cannot be empty")
+            msg = "URL cannot be empty"
+            raise ValueError(msg)
 
         # Different validation based on VCS type
-        values = info.data
-        vcs_type = values.get("vcs", "").lower()
+        # Keeping this but not using yet - can be expanded later
+        # vcs_type = values.get("vcs", "").lower()
 
         # Basic validation for all URL types
         if v.strip() == "":
-            raise ValueError("URL cannot be empty or whitespace")
+            msg = "URL cannot be empty or whitespace"
+            raise ValueError(msg)
 
         # VCS-specific validation could be added here
         # For now, just return the URL as is
         return v
 
 
-class ConfigSectionModel(BaseModel):
+class ConfigSectionDictModel(RootModel[dict[str, RepositoryModel]]):
     """Configuration section model containing repositories.
 
-    A section is a logical grouping of repositories, typically by project or organization.
+    A section is a logical grouping of repositories, typically by project or
+    organization.
     """
 
-    __root__: Dict[str, RepositoryModel] = Field(default_factory=dict)
-
     def __getitem__(self, key: str) -> RepositoryModel:
         """Get repository by name.
 
@@ -193,17 +186,17 @@ def __getitem__(self, key: str) -> RepositoryModel:
         RepositoryModel
             Repository configuration
         """
-        return self.__root__[key]
+        return self.root[key]
 
-    def __iter__(self) -> t.Iterator[str]:
-        """Iterate over repository names.
+    def keys(self) -> t.KeysView[str]:
+        """Get repository names.
 
         Returns
         -------
-        Iterator[str]
-            Iterator of repository names
+        KeysView[str]
+            View of repository names
         """
-        return iter(self.__root__)
+        return self.root.keys()
 
     def items(self) -> t.ItemsView[str, RepositoryModel]:
         """Get items as name-repository pairs.
@@ -213,7 +206,7 @@ def items(self) -> t.ItemsView[str, RepositoryModel]:
         ItemsView[str, RepositoryModel]
             View of name-repository pairs
         """
-        return self.__root__.items()
+        return self.root.items()
 
     def values(self) -> t.ValuesView[RepositoryModel]:
         """Get repository configurations.
@@ -223,18 +216,17 @@ def values(self) -> t.ValuesView[RepositoryModel]:
         ValuesView[RepositoryModel]
             View of repository configurations
         """
-        return self.__root__.values()
+        return self.root.values()
 
 
-class ConfigModel(BaseModel):
+class ConfigDictModel(RootModel[dict[str, ConfigSectionDictModel]]):
     """Complete configuration model containing sections.
 
-    A configuration is a collection of sections, where each section contains repositories.
+    A configuration is a collection of sections, where each section contains
+    repositories.
     """
 
-    __root__: Dict[str, ConfigSectionModel] = Field(default_factory=dict)
-
-    def __getitem__(self, key: str) -> ConfigSectionModel:
+    def __getitem__(self, key: str) -> ConfigSectionDictModel:
         """Get section by name.
 
         Parameters
@@ -244,40 +236,40 @@ def __getitem__(self, key: str) -> ConfigSectionModel:
 
         Returns
         -------
-        ConfigSectionModel
+        ConfigSectionDictModel
             Section configuration
         """
-        return self.__root__[key]
+        return self.root[key]
 
-    def __iter__(self) -> t.Iterator[str]:
-        """Iterate over section names.
+    def keys(self) -> t.KeysView[str]:
+        """Get section names.
 
         Returns
         -------
-        Iterator[str]
-            Iterator of section names
+        KeysView[str]
+            View of section names
         """
-        return iter(self.__root__)
+        return self.root.keys()
 
-    def items(self) -> t.ItemsView[str, ConfigSectionModel]:
+    def items(self) -> t.ItemsView[str, ConfigSectionDictModel]:
         """Get items as section-repositories pairs.
 
         Returns
         -------
-        ItemsView[str, ConfigSectionModel]
+        ItemsView[str, ConfigSectionDictModel]
             View of section-repositories pairs
         """
-        return self.__root__.items()
+        return self.root.items()
 
-    def values(self) -> t.ValuesView[ConfigSectionModel]:
+    def values(self) -> t.ValuesView[ConfigSectionDictModel]:
         """Get section configurations.
 
         Returns
         -------
-        ValuesView[ConfigSectionModel]
+        ValuesView[ConfigSectionDictModel]
             View of section configurations
         """
-        return self.__root__.values()
+        return self.root.values()
 
 
 # Raw configuration models for initial parsing without validation
@@ -286,50 +278,89 @@ class RawRepositoryModel(BaseModel):
 
     vcs: str
     name: str
-    path: Union[str, Path]
+    path: str | pathlib.Path
     url: str
-    remotes: Optional[Dict[str, Dict[str, Any]]] = None
-    shell_command_after: Optional[List[str]] = None
+    remotes: dict[str, dict[str, t.Any]] | None = None
+    shell_command_after: list[str] | None = None
 
     model_config = ConfigDict(
         extra="allow",  # Allow extra fields in raw config
         str_strip_whitespace=True,
     )
 
 
-class RawConfigSectionModel(BaseModel):
-    """Raw configuration section model before validation."""
+# Use a type alias for the complex type in RawConfigSectionDictModel
+RawRepoDataType = t.Union[RawRepositoryModel, str, dict[str, t.Any]]
 
-    __root__: Dict[str, Union[RawRepositoryModel, str, Dict[str, Any]]] = Field(
-        default_factory=dict
-    )
+
+class RawConfigSectionDictModel(RootModel[dict[str, RawRepoDataType]]):
+    """Raw configuration section model before validation."""
 
 
-class RawConfigModel(BaseModel):
+class RawConfigDictModel(RootModel[dict[str, RawConfigSectionDictModel]]):
     """Raw configuration model before validation and processing."""
 
-    __root__: Dict[str, RawConfigSectionModel] = Field(default_factory=dict)
-
 
 # Functions to convert between raw and validated models
 def convert_raw_to_validated(
-    raw_config: RawConfigModel,
-    cwd: t.Callable[[], Path] = Path.cwd,
-) -> ConfigModel:
+    raw_config: RawConfigDictModel,
+    cwd: t.Callable[[], pathlib.Path] = pathlib.Path.cwd,
+) -> ConfigDictModel:
     """Convert raw configuration to validated configuration.
 
     Parameters
     ----------
-    raw_config : RawConfigModel
+    raw_config : RawConfigDictModel
         Raw configuration
     cwd : Callable[[], Path], optional
         Function to get current working directory, by default Path.cwd
 
     Returns
     -------
-    ConfigModel
+    ConfigDictModel
         Validated configuration
     """
-    # Implementation will go here
-    # This will handle shorthand syntax, variable resolution, etc.
-    pass 
+    # Create a new ConfigDictModel
+    config = ConfigDictModel(root={})
+
+    # Process each section in the raw config
+    for section_name, raw_section in raw_config.root.items():
+        # Create a new section in the validated config
+        config.root[section_name] = ConfigSectionDictModel(root={})
+
+        # Process each repository in the section
+        for repo_name, raw_repo_data in raw_section.root.items():
+            # Handle string shortcuts (URL strings)
+            if isinstance(raw_repo_data, str):
+                # Convert string URL to a repository model
+                repo_model = RepositoryModel(
+                    vcs="git",  # Default to git for string URLs
+                    name=repo_name,
+                    path=cwd() / repo_name,  # Default path is repo name in current dir
+                    url=raw_repo_data,
+                )
+            # Handle direct dictionary data
+            elif isinstance(raw_repo_data, dict):
+                # Ensure name is set
+                if "name" not in raw_repo_data:
+                    raw_repo_data["name"] = repo_name
+
+                # Validate and convert path
+                if "path" in raw_repo_data:
+                    path = raw_repo_data["path"]
+                    # Convert relative paths to absolute using cwd
+                    path_obj = pathlib.Path(os.path.expandvars(str(path))).expanduser()
+                    if not path_obj.is_absolute():
+                        path_obj = cwd() / path_obj
+                    raw_repo_data["path"] = path_obj
+
+                # Create repository model
+                repo_model = RepositoryModel.model_validate(raw_repo_data)
+            else:
+                # Skip invalid repository data
+                continue
+
+            # Add repository to the section
+            config.root[section_name].root[repo_name] = repo_model
+
+    return config