Fixed the issue where path dependencies were not relative to the manifest file, instead they were relative the run directory

Author: allRisc

CHANGELOG.md

@@ -6,6 +6,14 @@ All notable changes to ``FastSandPM`` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+0.2.0
+----------------------------------------------------------------------
+
+### Fixed
+- Path dependencies are now resolved to absolute paths relative to the manifest file's directory
+  when loading via `get_manifest()`. Previously, relative paths were left as-is which could cause
+  issues when the working directory differed from the manifest location.
+
 0.1.0
 ----------------------------------------------------------------------
 

src/fastsandpm/manifest.py

@@ -57,12 +57,13 @@
     PlainValidator,
     RootModel,
     ValidationError,
+    ValidationInfo,
     WithJsonSchema,
     field_validator,
     model_validator,
 )
 
-from fastsandpm.dependencies.requirements import ConcreteRequirement
+from fastsandpm.dependencies.requirements import ConcreteRequirement, PathRequirement
 from fastsandpm.registries import Registries
 from fastsandpm.versioning import LibraryVersion
 
@@ -404,6 +405,48 @@ def parse_optional_dependencies(cls, data: Any) -> Any:
         data["optional_dependencies"] = new_opt_deps
         return data
 
+    @model_validator(mode="after")
+    def _resolve_path_requirement_paths(self, info: ValidationInfo) -> Manifest:
+        """Resolve relative paths in PathRequirements to absolute paths.
+
+        Creates a new Manifest with all relative path dependencies resolved
+        relative to the manifest file's directory.
+
+        Args:
+            manifest: The parsed Manifest object.
+            manifest_dir: The directory containing the manifest file.
+
+        Returns:
+            A new Manifest with resolved path dependencies.
+        """
+        if isinstance(info.context, dict) and "manifest_dir" in info.context:
+            manifest_dir = pathlib.Path(info.context["manifest_dir"])
+        else:
+            # No manifest directory context provided (e.g., loading from bytes)
+            # Keep relative paths as-is
+            return self
+
+        def resolve_dep(dep: ConcreteRequirement) -> ConcreteRequirement:
+            """Resolve paths in a single dependency."""
+            if isinstance(dep, PathRequirement) and not dep.path.is_absolute():
+                resolved_path = (manifest_dir / dep.path).resolve()
+                return dep.model_copy(update={"path": resolved_path})
+            return dep
+
+        # Resolve paths in required dependencies
+        new_deps = Dependencies([resolve_dep(dep) for dep in self.dependencies])
+
+        # Resolve paths in optional dependencies
+        new_opt_deps: dict[str, Dependencies] = {}
+        for group_name, deps in self.optional_dependencies.items():
+            new_opt_deps[group_name] = Dependencies([resolve_dep(dep) for dep in deps])
+
+        # Create new manifest with resolved paths
+        self.dependencies = new_deps
+        self.optional_dependencies = new_opt_deps
+
+        return self
+
 
 #: The default manifest filename
 MANIFEST_FILENAME = "proj.toml"
@@ -413,13 +456,14 @@ def get_manifest(path: os.PathLike) -> Manifest:
     """Load and parse a manifest from a repository path.
 
     Looks for a `proj.toml` file in the specified directory, parses it,
-    and returns a Manifest object.
+    and returns a Manifest object. Relative paths in path dependencies are
+    resolved to absolute paths relative to the manifest file's directory.
 
     Args:
         path: Path to the repository directory containing the proj.toml file.
 
     Returns:
-        The parsed Manifest object.
+        The parsed Manifest object with resolved path dependencies.
 
     Raises:
         ManifestNotFoundError: If the proj.toml file does not exist at the path.
@@ -454,10 +498,13 @@ def get_manifest(path: os.PathLike) -> Manifest:
 
     # Parse the data into a Manifest object
     try:
-        return Manifest.model_validate(data)
+        manifest = Manifest.model_validate(data, context={"manifest_dir": path.resolve()})
     except ValidationError as e:
         raise ManifestParseError(path, str(e)) from e
 
+    # Resolve relative paths in path dependencies
+    return manifest
+
 
 def get_manifest_from_bytes(content: bytes, source: str = "<bytes>") -> Manifest:
     """Parse a manifest from raw bytes content.

tests/manifest/test_get_manifest.py

@@ -173,7 +173,11 @@ def test_get_manifest_with_git_dependencies(self, tmp_path: pathlib.Path) -> Non
         assert dep5.version == DirectVersionSpecifier(LibraryVersion("1.0.0"))
 
     def test_get_manifest_with_path_dependencies(self, tmp_path: pathlib.Path) -> None:
-        """Test loading manifest with path dependencies."""
+        """Test loading manifest with path dependencies.
+
+        Relative paths should be resolved to absolute paths relative to
+        the manifest file's directory.
+        """
         manifest_content = """
 [package]
 name = "with-path-deps"
@@ -192,11 +196,15 @@ def test_get_manifest_with_path_dependencies(self, tmp_path: pathlib.Path) -> No
 
         local = manifest.dependencies.get_by_name("local_dep")
         assert isinstance(local, PathRequirement)
-        assert local.path == pathlib.Path("./local_utils")
+        # Relative paths should be resolved to absolute paths
+        assert local.path.is_absolute()
+        assert local.path == (tmp_path / "local_utils").resolve()
 
         parent = manifest.dependencies.get_by_name("parent_dep")
         assert isinstance(parent, PathRequirement)
-        assert parent.path == pathlib.Path("../sibling_project")
+        # Relative paths should be resolved to absolute paths
+        assert parent.path.is_absolute()
+        assert parent.path == (tmp_path / ".." / "sibling_project").resolve()
 
     def test_get_manifest_with_mixed_dependencies(self, tmp_path: pathlib.Path) -> None:
         """Test loading manifest with mixed dependency types."""
@@ -539,3 +547,37 @@ def test_get_manifest_from_bytes_with_git_dependencies(self) -> None:
         assert git_dep is not None
         assert isinstance(git_dep, BranchGitRequirement)
         assert git_dep.branch == "main"
+
+    def test_get_manifest_from_bytes_with_path_dependencies(self) -> None:
+        """Test parsing manifest with path dependencies from bytes.
+
+        When loading from bytes without a file context, relative paths
+        should remain as-is (not resolved to absolute paths).
+        """
+        content = b"""
+[package]
+name = "path-deps-pkg"
+version = "1.0.0"
+description = "Package with path dependencies"
+
+[dependencies]
+local_dep = {path = "./local_utils"}
+parent_dep = {path = "../sibling"}
+"""
+        manifest = get_manifest_from_bytes(content)
+
+        assert len(manifest.dependencies) == 2
+
+        local_dep = manifest.dependencies.get_by_name("local_dep")
+        assert local_dep is not None
+        assert isinstance(local_dep, PathRequirement)
+        # Paths should remain relative when loading from bytes
+        assert local_dep.path == pathlib.Path("./local_utils")
+        assert not local_dep.path.is_absolute()
+
+        parent_dep = manifest.dependencies.get_by_name("parent_dep")
+        assert parent_dep is not None
+        assert isinstance(parent_dep, PathRequirement)
+        # Paths should remain relative when loading from bytes
+        assert parent_dep.path == pathlib.Path("../sibling")
+        assert not parent_dep.path.is_absolute()