Implement local git reading.

Author: jessemyers-lettuce

pyproject.toml

@@ -42,7 +42,8 @@ types = [
 
 [project.scripts]
 
-commit = "bot.cli.commit:main"
+read-commit = "bot.cli.commit:read"
+write-commit = "bot.cli.commit:write"
 
 [build-system]
 

src/bot/cli/commit.py

@@ -1,13 +1,56 @@
 from pathlib import Path
 
 from click import Path as PathType
-from click import command, option
+from click import command, option, secho
 from github.Auth import AppAuth
 
+from ..dtos import Tree
 from ..local import read_commit
 from ..remote import write_commit
 
 
+def print_tree(tree: Tree, parent: Path, depth: int = 0) -> None:
+    slash = "\\"
+    space = " " * depth
+
+    secho(f"{space}{slash} {tree.path.relative_to(parent)}", fg="green")
+
+    for blob in tree.blobs:
+        operation = "+" if blob.sha else "-"
+        color = "cyan" if blob.sha else "red"
+        secho(f"{space}|- ({operation}) {blob.path.relative_to(tree.path)}", fg=color)
+
+    for child in tree.trees:
+        print_tree(child, tree.path, depth + 1)
+
+
+@command()
+@option(
+    "--repo-path",
+    "--repo",
+    type=PathType(
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        path_type=Path,
+    ),
+    required=True,
+)
+@option(
+    "--ref",
+    required=True,
+)
+def read(
+    *,
+    repo_path: Path,
+    ref: str,
+) -> None:
+    commit = read_commit(repo_path, ref)
+
+    secho(f"Commit: {commit.message}", fg="green")
+    print_tree(commit.tree, Path())
+
+
 @command()
 @option(
     "--application-id",
@@ -36,7 +79,7 @@
     "--ref",
     required=True,
 )
-def main(
+def write(
     *,
     application_id: str,
     private_key: str,

src/bot/dtos.py

@@ -1,28 +1,24 @@
 """Data transfer objects between git implementations."""
-from dataclasses import dataclass
-
-from .enums import Mode, Type
+from dataclasses import dataclass, field
+from pathlib import Path
 
 
 @dataclass(frozen=True)
 class Blob:
     """A blob references file content."""
 
-    path: str
-    sha: str
+    path: Path
+    sha: str | None
 
 
 @dataclass(frozen=True)
 class Tree:
     """A tree references one or other trees or blobs."""
 
-    path: str
-    mode: Mode
-    sha: str
-    type: Type
+    path: Path
 
-    blobs: list[Blob]
-    trees: list["Tree"]
+    blobs: list[Blob] = field(default_factory=list)
+    trees: list["Tree"] = field(default_factory=list)
 
 
 @dataclass(frozen=True)

src/bot/local.py

@@ -1,47 +1,138 @@
 from pathlib import Path
+from typing import Generator
 
-from git import Repo
+from git import Diff, Repo
+from git.objects import Commit
 
-from .dtos import Commit, Tree
-from .enums import Mode, Type
+from .dtos import Blob as BlobDTO
+from .dtos import Commit as CommitDTO
+from .dtos import Tree as TreeDTO
 
+ROOT = Path()
 
-def read_commit(repo_path: Path, ref: str) -> Commit:
-    # Find the commit at the given ref in the local repo.
-    repo = Repo(repo_path)
-    commit = repo.commit(ref)
 
+def iter_blobs(item: Diff) -> Generator[BlobDTO, None, None]:
+    match (item.change_type):
+        case "A":
+            # File added
+            assert item.b_path is not None
+            assert item.b_blob is not None
+
+            yield BlobDTO(
+                path=Path(item.b_path.lstrip("/")),
+                sha=item.b_blob.hexsha,
+            )
+        case "D":
+            # File deleted
+            assert item.a_path is not None
+
+            yield BlobDTO(
+                path=Path(item.a_path.lstrip("/")),
+                sha=None,
+            )
+        case "C":
+            # File copied
+            assert item.a_path is not None
+            assert item.a_blob is not None
+            assert item.b_path is not None
+            assert item.b_blob is not None
+
+            yield BlobDTO(
+                path=Path(item.b_path.lstrip("/")),
+                sha=item.b_blob.hexsha,
+            )
+        case "R":
+            # File renamed
+            assert item.a_path is not None
+            assert item.a_blob is not None
+            assert item.b_path is not None
+            assert item.b_blob is not None
+
+            yield BlobDTO(
+                path=Path(item.a_path.lstrip("/")),
+                sha=None,
+            )
+            yield BlobDTO(
+                path=Path(item.b_path.lstrip("/")),
+                sha=item.b_blob.hexsha,
+            )
+        case "M":
+            # File modified
+            assert item.b_path is not None
+            assert item.b_blob is not None
+
+            yield BlobDTO(
+                path=Path(item.b_path.lstrip("/")),
+                sha=item.b_blob.hexsha,
+            )
+        case "T":
+            # File changed type (TODO)
+            raise NotImplementedError("Diff type 'T' is not supported.")
+        case _:
+            raise ValueError(f"Unexpected diff type: {item.change_type}")
+
+
+def build_trees(blobs: list[BlobDTO]) -> TreeDTO:
+    trees: dict[Path, TreeDTO] = {}
+
+    # Create the root tree
+    root = trees[ROOT] = TreeDTO(path=ROOT)
+
+    # Create all trees
+    for blob in blobs:
+        path = blob.path.parent
+        while path != ROOT:
+            trees.setdefault(path, TreeDTO(path))
+            path = path.parent
+
+    # Attach blobs to trees
+    for blob in blobs:
+        trees[blob.path.parent].blobs.append(blob)
+
+    # Attach all trees to their parents
+    for tree in trees.values():
+        if tree.path == ROOT:
+            continue
+
+        trees[tree.path.parent].trees.append(tree)
+
+    return root
+
+
+def find_parent(commit: Commit) -> Commit:
     if not commit.parents:
         raise ValueError("Cannot create a repo's initial commit.")
 
     if len(commit.parents) > 1:
         raise ValueError("Cannot create a merge commit.")
 
-    parent = commit.parents[0]
+    return commit.parents[0]
 
-    # Compute the diff between the commit and its parent
-    diff = commit.diff(parent.hexsha)
-
-    # Inspect the diff to create a commit
-    for item in diff:
-        # TODO
-        pass
 
+def extract_message(commit: Commit) -> str:
     if isinstance(commit.message, str):
-        message = commit.message
+        return commit.message
     else:
-        message = commit.message.decode("utf-8")
+        return commit.message.decode("utf-8")
+
+
+def read_commit(repo_path: Path, ref: str) -> CommitDTO:
+    # Find the commit at the given ref in the local repo.
+    repo = Repo(repo_path)
+    commit = repo.commit(ref)
+
+    # Compute the diff between the parent and this commit
+    parent = find_parent(commit)
+    diff = parent.diff(commit.hexsha)
+
+    # Inspect the diff to create a commit
+    blobs = [blob for diff_item in diff for blob in iter_blobs(diff_item)]
+
+    root = build_trees(blobs)
 
-    return Commit(
+    return CommitDTO(
         base_tree=parent.tree.hexsha,
-        message=message,
+        message=extract_message(commit),
         parents=[parent.hexsha],
-        tree=Tree(
-            path="",
-            mode=Mode.SUBDIRECTORY,
-            type=Type.TREE,
-            blobs=[],
-            trees=[],
-            sha="",
-        ),
+        tree=root,
     )

src/bot/tests/test_local.py

@@ -0,0 +1,96 @@
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from git import Diff
+from pytest import fixture
+
+from bot.dtos import Blob
+from bot.local import build_trees, iter_blobs
+
+
+@fixture
+def diff() -> Diff:
+    item = MagicMock()
+    item.a_path = "foo"
+    item.a_blob.hexsha = "0000"
+    item.b_path = "bar"
+    item.b_blob.hexsha = "1111"
+    return item
+
+
+def test_iter_blobs_a(diff: Diff) -> None:
+    diff.change_type = "A"
+
+    blobs = list(iter_blobs(diff))
+    assert len(blobs) == 1
+    assert str(blobs[0].path) == "bar"
+    assert blobs[0].sha is not None
+
+
+def test_iter_blobs_d(diff: Diff) -> None:
+    diff.change_type = "D"
+
+    blobs = list(iter_blobs(diff))
+    assert len(blobs) == 1
+    assert str(blobs[0].path) == "foo"
+    assert blobs[0].sha is None
+
+
+def test_iter_blobs_c(diff: Diff) -> None:
+    diff.change_type = "C"
+
+    blobs = list(iter_blobs(diff))
+    assert len(blobs) == 1
+    assert str(blobs[0].path) == "bar"
+    assert blobs[0].sha is not None
+
+
+def test_iter_blobs_r(diff: Diff) -> None:
+    diff.change_type = "R"
+
+    blobs = list(iter_blobs(diff))
+    assert len(blobs) == 2
+    assert str(blobs[0].path) == "foo"
+    assert blobs[0].sha is None
+    assert str(blobs[1].path) == "bar"
+    assert blobs[1].sha is not None
+
+
+def test_iter_blobs_m(diff: Diff) -> None:
+    diff.change_type = "M"
+
+    blobs = list(iter_blobs(diff))
+    assert len(blobs) == 1
+    assert str(blobs[0].path) == "bar"
+    assert blobs[0].sha is not None
+
+
+def test_build_trees() -> None:
+    blobs = [
+        Blob(path=Path("foo/bar/baz.txt"), sha="0000"),
+        Blob(path=Path("foo/qux.html"), sha="1111"),
+    ]
+
+    root = build_trees(blobs)
+
+    assert root.path == Path()
+    assert len(root.blobs) == 0
+    assert len(root.trees) == 1
+
+    foo = root.trees[0]
+    assert foo.path == Path("foo")
+    assert len(foo.blobs) == 1
+    assert len(foo.trees) == 1
+
+    qux = foo.blobs[0]
+    assert qux.path == Path("foo/qux.html")
+    assert qux.sha is not None
+
+    bar = foo.trees[0]
+    assert bar.path == Path("foo/bar")
+    assert len(bar.blobs) == 1
+    assert len(bar.trees) == 0
+
+    baz = bar.blobs[0]
+    assert baz.path == Path("foo/bar/baz.txt")
+    assert baz.sha is not None