feat: add git utils for getting git commit hash

The current method for getting the git commit hash is to evaluate git
commands as part of hjson wildcard substitution. Presumably as a means
of making it more generic and supporting other version control systems.

However the opentitan HJSON builds up a markdown string containing a URL
link to github. Then DVSim parses that string with a regex. Which
couples the somewhat generic mechanism to an exact implementation.

This commit adds some generic git utility functions to work directly
with git from within DVSim and bypass HJSON calculated values. If we are
going to be calling Git, I'd rather do that directly from DVSim, rather
than some uncontrolled system call eval in HJSON. If we need to add
flexibility to support different systems then we can add that in the
future using a plugin system in DVSim and declaratively switching
between version control system (i.e. git) and hosting solution (i.e.
github) in the HJSON if required.

The current solution is highly coupled and doesn't allow for extension.
This solution is still git/github specific, but adds scope for later
extension if required. It also removes the dependence on one more eval
in the OpenTitan HJSON.

Signed-off-by: James McCorrie <[email protected]>

Author: machshev

pyproject.toml

@@ -19,6 +19,7 @@ dependencies = [
     # Keep sorted
     "click>=8.1.7",
     "enlighten>=1.12.4",
+    "gitpython>=3.1.45",
     "hjson>=3.1.0",
     "jinja2>=3.1.6",
     "logzero>=1.7.0",

src/dvsim/utils/git.py

@@ -2,13 +2,39 @@
 # Licensed under the Apache License, Version 2.0, see LICENSE for details.
 # SPDX-License-Identifier: Apache-2.0
 
-"""Git utinity functions."""
+"""Git utility functions."""
 
-from dvsim.utils.subprocess import run_cmd
+import logging as log
+from pathlib import Path
 
-__all__ = ("git_commit_hash",)
+from git import Repo
 
+__all__ = ("repo_root",)
 
-def git_commit_hash() -> str:
+
+def repo_root(path: Path) -> Path | None:
+    """Given a sub dir in a git repo provide the root path.
+
+    Where the provided path is not part of a repo then None is returned.
+    """
+    if (path / ".git").exists():
+        return path
+
+    for p in path.parents:
+        if (p / ".git").exists():
+            return p
+
+    return None
+
+
+def git_commit_hash(path: Path | None = None) -> str:
     """Hash of the current git commit."""
-    return run_cmd("git rev-parse HEAD")
+    root = repo_root(path=path if path else Path.cwd())
+
+    if root is None:
+        log.error("no git repo found at %s", root)
+        raise ValueError
+
+    r = Repo(root)
+
+    return r.head.commit.hexsha

tests/utils/test_git.py

@@ -0,0 +1,55 @@
+# Copyright lowRISC contributors (OpenTitan project).
+# Licensed under the Apache License, Version 2.0, see LICENSE for details.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Test git helpers."""
+
+from typing import TYPE_CHECKING
+
+from git import Repo
+from hamcrest import assert_that, equal_to
+
+from dvsim.utils.git import git_commit_hash, repo_root
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+__all__ = ()
+
+
+class TestGit:
+    """Test git helpers."""
+
+    @staticmethod
+    def test_repo_root(tmp_path: "Path") -> None:
+        """Test git repo root can be found."""
+        repo_root_path = tmp_path / "repo"
+        repo_root_path.mkdir()
+
+        Repo.init(path=repo_root_path)
+
+        # from the actual repo root
+        assert_that(repo_root(path=repo_root_path), equal_to(repo_root_path))
+
+        # from the repo sub dir
+        sub_dir_path = repo_root_path / "a"
+        sub_dir_path.mkdir()
+        assert_that(repo_root(path=sub_dir_path), equal_to(repo_root_path))
+
+        # from outside the repo
+        assert_that(repo_root(path=tmp_path), equal_to(None))
+
+    @staticmethod
+    def test_git_commit_hash(tmp_path: "Path") -> None:
+        """Test that the expected git commit sha is returned."""
+        r = Repo.init(path=tmp_path)
+
+        file = tmp_path / "a"
+        file.write_text("file to commit")
+        r.index.add([file])
+        r.index.commit("initial commit")
+
+        assert_that(
+            git_commit_hash(tmp_path),
+            equal_to(r.head.commit.hexsha),
+        )