!squash more

Author: tony

src/libvcs/cmd/git.py

@@ -11,11 +11,24 @@
 
 from libvcs._internal.run import ProgressCallbackProtocol, run
 from libvcs._internal.types import StrOrBytesPath, StrPath
-from libvcs._vendor.version import InvalidVersion, parse
+from libvcs._vendor.version import InvalidVersion, Version, parse as parse_version
 
 _CMD = t.Union[StrOrBytesPath, Sequence[StrOrBytesPath]]
 
 
+class InvalidBuildOptions(ValueError):
+    """Raised when a git version output is in an unexpected format.
+
+    >>> InvalidBuildOptions("...")
+    Traceback (most recent call last):
+        ...
+    libvcs.cmd.git.InvalidBuildOptions: Unexpected git version output format: ...
+    """
+
+    def __init__(self, version: str, *args: object) -> None:
+        return super().__init__(f"Unexpected git version output format: {version}")
+
+
 @dataclasses.dataclass
 class GitVersionInfo:
     """Information about the git version."""
@@ -1778,7 +1791,7 @@ def version(
         # libvcs special behavior
         check_returncode: bool | None = None,
         **kwargs: t.Any,
-    ) -> str:
+    ) -> Version:
         """Get git version. Wraps `git version <https://git-scm.com/docs/git-version>`_.
 
         Parameters
@@ -1788,29 +1801,44 @@ def version(
 
         Returns
         -------
-        str
-            Raw version string output
+        Version
+            Parsed semantic version object from git version output
+
+        Raises
+        ------
+        InvalidVersion
+            If the git version output is in an unexpected format
 
         Examples
         --------
         >>> git = Git(path=example_git_repo.path)
 
-        >>> git.version()
-        'git version ...'
+        >>> version = git.version()
+        >>> isinstance(version.major, int)
+        True
 
-        >>> git.version(build_options=True)
-        'git version ...'
+        >>> version = git.version(build_options=True)
+        >>> isinstance(version.major, int)
+        True
         """
         local_flags: list[str] = []
 
         if build_options is True:
             local_flags.append("--build-options")
 
-        return self.run(
+        output = self.run(
             ["version", *local_flags],
             check_returncode=check_returncode,
         )
 
+        # Extract version string and parse it
+        if output.startswith("git version "):
+            version_str = output.split("\n", 1)[0].replace("git version ", "").strip()
+            return parse_version(version_str)
+
+        # Raise exception if output format is unexpected
+        raise InvalidVersion(f"Unexpected git version output format: {output}")
+
     def build_options(
         self,
         *,
@@ -1826,6 +1854,11 @@ def build_options(
         GitVersionInfo
             Dataclass containing structured information about the git version and build
 
+        Raises
+        ------
+        InvalidBuildOptions
+            If the git build options output is in an unexpected format
+
         Examples
         --------
         >>> git = Git(path=example_git_repo.path)
@@ -1835,51 +1868,57 @@ def build_options(
         >>> isinstance(version_info.version, str)
         True
         """
-        output = self.version(build_options=True, check_returncode=check_returncode)
+        # Get raw output directly using run() instead of version()
+        output = self.run(
+            ["version", "--build-options"],
+            check_returncode=check_returncode,
+        )
 
         # Parse the output into a structured format
         result = GitVersionInfo(version="")
 
         # First line is always "git version X.Y.Z"
         lines = output.strip().split("\n")
-        if lines and lines[0].startswith("git version "):
-            version_str = lines[0].replace("git version ", "").strip()
-            result.version = version_str
-
-            # Parse semantic version components
-            try:
-                parsed_version = parse(version_str)
-                result.version_info = (
-                    parsed_version.major,
-                    parsed_version.minor,
-                    parsed_version.micro,
-                )
-            except InvalidVersion:
-                # Fall back to string-only if can't be parsed
-                result.version_info = None
-
-            # Parse additional build info
-            for line in lines[1:]:
-                line = line.strip()
-                if not line:
-                    continue
-
-                if ":" in line:
-                    key, value = line.split(":", 1)
-                    key = key.strip()
-                    value = value.strip()
-
-                    if key == "cpu":
-                        result.cpu = value
-                    elif key == "sizeof-long":
-                        result.sizeof_long = value
-                    elif key == "sizeof-size_t":
-                        result.sizeof_size_t = value
-                    elif key == "shell-path":
-                        result.shell_path = value
-                # Special handling for the commit line which often has no colon
-                elif "commit" in line:
-                    result.commit = line
+        if not lines or not lines[0].startswith("git version "):
+            raise InvalidBuildOptions(f"Unexpected git version output format: {output}")
+
+        version_str = lines[0].replace("git version ", "").strip()
+        result.version = version_str
+
+        # Parse semantic version components
+        try:
+            parsed_version = parse_version(version_str)
+            result.version_info = (
+                parsed_version.major,
+                parsed_version.minor,
+                parsed_version.micro,
+            )
+        except InvalidVersion:
+            # Fall back to string-only if can't be parsed
+            result.version_info = None
+
+        # Parse additional build info
+        for line in lines[1:]:
+            line = line.strip()
+            if not line:
+                continue
+
+            if ":" in line:
+                key, value = line.split(":", 1)
+                key = key.strip()
+                value = value.strip()
+
+                if key == "cpu":
+                    result.cpu = value
+                elif key == "sizeof-long":
+                    result.sizeof_long = value
+                elif key == "sizeof-size_t":
+                    result.sizeof_size_t = value
+                elif key == "shell-path":
+                    result.shell_path = value
+            # Special handling for the commit line which often has no colon
+            elif "commit" in line and "no commit" not in line.lower():
+                result.commit = line
 
         return result