lib.version.Dependency: Beautify exceptions

Add a dependent_package parameter to Dependency's constructor, and use it
in exceptions the class raises.

Signed-off-by: Jan Lindemann <jan@janware.com>

src/python/jw/pkg/lib/version/Dependency.py

@@ -5,13 +5,13 @@ import re
 from functools import cached_property
 from typing import TYPE_CHECKING, override
 
-from ..log import WARNING, log
+from ..log import get_caller_pos
 from .base import Boundary, Lookup, Syntax
 from .Version import Version
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
-    from typing import ClassVar
+    from typing import ClassVar, Never
 
 class Dependency:  # export
     """A single package dependency: a package name and an optional
@@ -24,30 +24,33 @@ class Dependency:  # export
 
     __SPLIT_RE: ClassVar[re.Pattern[str]] = re.compile('([=><]+)')
 
+    @property
+    def __target_prefix(self) -> str:
+        if self.__dependent_package is None:
+            return ''
+        return f' Package "{self.__dependent_package}"'
+
+    def __raise(self, msg: str, cls: type[Exception] = Error) -> Never:
+        mod, file, line = get_caller_pos()
+        raise cls(f'[{file}:{line}]{self.__target_prefix}: {msg}')
+
     @cached_property
     def __parsed_spec(self) -> tuple[str, Boundary | None]:
         parts = [part.strip() for part in self.__SPLIT_RE.split(self.__spec)]
         match len(parts):
             case 1:
                 if not parts[0]:
-                    raise Dependency.Error(f'Invalid dependency spec "{self.__spec}"')
+                    self.__raise(f'Invalid dependency spec "{self.__spec}"')
                 return parts[0], None
             case 3:
                 if not parts[0] or not parts[2]:
-                    raise Dependency.Error(f'Invalid dependency spec "{self.__spec}"')
+                    self.__raise(f'Invalid dependency spec "{self.__spec}"')
-                if parts[2] == 'REVISION':
-                    log(
-                        WARNING,
-                        f'Spec "{self.__spec}": a bare REVISION renders as a bare '
-                        'number, which RPM reads as a version constraint, not a '
-                        'release constraint'
-                    )
                 return parts[0], Boundary(
                     op=parts[1],
                     version=Version(parts[0], parts[2], self.__lookup_version),
                 )
             case _:
-                raise Dependency.Error(f'Invalid dependency spec "{self.__spec}"')
+                self.__raise(f'Invalid dependency spec "{self.__spec}"')
 
     def __version_boundaries(
         self,
@@ -69,12 +72,13 @@ class Dependency:  # export
             case '<' | '<=':
                 ret.append(specified)
             case _:
-                raise NotImplementedError(
+                self.__raise(
                     (
                         'Expanding version boundary '
                         f'"{self.full_name} {specified.op} {specified.version}" '
                         'is not yet implemented'
-                    )
+                    ),
+                    cls = NotImplementedError,
                 )
         return ret
 
@@ -84,18 +88,24 @@ class Dependency:  # export
         self,
         spec: str,
         lookup_version: Lookup | None = None,
+        dependent_package: str | None = None,
     ) -> None:
         self.__spec = spec
         self.__lookup_version = lookup_version
+        self.__dependent_package = dependent_package
 
     @override
     def __str__(self) -> str:
         return self.__spec
 
+    @property
+    def dependent_package(self) -> str | None:
+        return self.__dependent_package
+
     @cached_property
     def current_version(self) -> str:
         if not self.__lookup_version:
-            raise Dependency.Error(
+            self.__raise(
                 f'Tried to look up "{self.__spec}" for package '
                 f'"{self.base_name}" without lookup function'
             )
@@ -155,9 +165,13 @@ class Dependency:  # export
         cls,
         spec: str,
         lookup_version: Lookup | None = None,
+        dependent_package: str | None = None,
     ) -> Sequence[Dependency]:
         """Split a comma-separated specification into Dependency objects"""
         return [
-            Dependency(spec = spec.strip(), lookup_version = lookup_version)
+            Dependency(
-            for spec in spec.split(',')
+                spec = spec.strip(),
+                lookup_version = lookup_version,
+                dependent_package = dependent_package,
+            ) for spec in spec.split(',')
         ]