Add write-tree and ls-tree scaffolding to Git class

- Implemented `write_tree` method in `Git` class to recursively hash directories and files.
- Added scaffolding for `ls-tree` command with placeholder logic.
- Updated CLI parser to support `ls-tree` with `--name-only` flag.
- Removed `create_blob` from `utils` in favor of `Git.create_blob`.
- Refactored tests to use new `Git` class methods and added initial tests for `write_tree`.
- Updated `.gitignore` to exclude PyCharm `.idea` directory.

Author: LesPrimus

.gitignore

@@ -151,3 +151,6 @@ dmypy.json
 
 # Cython debug symbols
 cython_debug/
+
+# Pycharm
+.idea

app/models/git.py

@@ -4,14 +4,18 @@
 
 __all__ = ["Git"]
 
-from app.utils import create_blob
-
 NULL_BYTE = b"\x00"
 
 
 class Git:
-    @classmethod
-    def init_repo(cls):
+    ignore_patterns = {".git", "__pycache__", ".pytest_cache", ".venv", "HEAD"}
+
+    def __init__(self):
+        self.git_folder = pathlib.Path(".git")
+        self.objects_folder = self.git_folder / "objects"
+
+    @staticmethod
+    def init_repo():
         path = pathlib.Path(".")
         dirs = [".git", ".git/objects", ".git/refs"]
         for _dir in dirs:
@@ -21,22 +25,62 @@ def init_repo(cls):
             f.write("ref: refs/heads/main\n")
         return
 
-    @classmethod
-    def cat_file(cls, hash_: str, *, pretty_print: bool = False):
+    def cat_file(self, hash_: str, *, pretty_print: bool = False):
         from app.models import Blob
 
-        path = pathlib.Path(".git", "objects", hash_[:2], hash_[2:])
+        path = self.objects_folder / hash_[:2] / hash_[2:]
         with path.open("rb") as f:
             data = zlib.decompress(f.read())
         header, _, body = data.partition(NULL_BYTE)
         if pretty_print:
             sys.stdout.write(body.decode())
         return Blob(header=header, body=body)
 
-    @classmethod
-    def hash_object(cls, path: pathlib.Path, *, write: bool = False, pretty_print: bool = True):
+    def create_blob(self, content: str, *, write: bool = True) -> str:
+        # Format the blob object
+        blob = f"blob {len(content)}\0{content}"
+        # Convert to bytes
+        blob_bytes = blob.encode()
+        # Compress using zlib
+        compressed = zlib.compress(blob_bytes)
+
+        # Calculate SHA-1 hash
+        import hashlib
+
+        hash_object = hashlib.sha1(blob_bytes)
+        hash_value = hash_object.hexdigest()
+
+        if write:
+            path = self.objects_folder / hash_value[:2]
+            path.mkdir(exist_ok=True)
+
+            with (path / hash_value[2:]).open("wb") as f:
+                f.write(compressed)
+        return hash_value
+
+    def hash_object(
+        self, path: pathlib.Path, *, write: bool = False, pretty_print: bool = True
+    ):
         with path.open("r") as f:
-            hash_value = create_blob(f.read(), write=write)
+            hash_value = self.create_blob(f.read(), write=write)
         if pretty_print:
             sys.stdout.write(hash_value)
         return hash_value
+
+    @classmethod
+    def ls_tree(cls, hash_value: str, *, name_only: bool = False):
+        raise NotImplementedError
+
+    def write_tree(self, working_directory: pathlib.Path = None):
+        working_directory = working_directory or pathlib.Path(".")
+        hash_values = []
+
+        for path in working_directory.iterdir():
+            if path.name in self.ignore_patterns:
+                continue
+            if path.is_dir():
+                hash_values.extend(self.write_tree(path))
+            if path.is_file():
+                hash_values.append(self.hash_object(path))
+
+        return hash_values

app/utils.py

@@ -23,28 +23,10 @@ def get_parser():
     hash_object_parser = subparsers.add_parser("hash-object")
     hash_object_parser.add_argument("path", type=pathlib.Path)
     hash_object_parser.add_argument("-w", "--write", action="store_true")
-    return parser
-
-
-def create_blob(content: str, *, write: bool = True) -> str:
-    # Format the blob object
-    blob = f"blob {len(content)}\0{content}"
-    # Convert to bytes
-    blob_bytes = blob.encode()
-    # Compress using zlib
-    compressed = zlib.compress(blob_bytes)
 
-    # Calculate SHA-1 hash
-    import hashlib
+    # ls-tree
+    ls_tree_parser = subparsers.add_parser("ls-tree")
+    ls_tree_parser.add_argument("--name-only", action="store_true")
+    ls_tree_parser.add_argument("hash_value")
 
-    hash_object = hashlib.sha1(blob_bytes)
-    hash_value = hash_object.hexdigest()
-
-    if write:
-        # Create directory structure
-        path = pathlib.Path(".git/objects", hash_value[:2])
-        path.mkdir(exist_ok=True)
-
-        with (path / hash_value[2:]).open("wb") as f:
-            f.write(compressed)
-    return hash_value
+    return parser

tests/test_git.py

@@ -4,7 +4,6 @@
 import pytest
 
 from app.main import Git
-from app.utils import create_blob
 
 
 @pytest.fixture
@@ -25,7 +24,7 @@ def test_init_repo(self, change_to_tmp_dir):
     def test_cat_file(self, change_to_tmp_dir):
         git = Git()
         git.init_repo()
-        hash_value = create_blob("some content")
+        hash_value = git.create_blob("some content")
         blob = git.cat_file(hash_value)
         assert blob.header == f"blob {len(blob.body)}".encode()
         assert blob.body == b"some content"
@@ -35,7 +34,9 @@ def test_cat_file(self, change_to_tmp_dir):
         "content, expected_hash_value",
         [("hello world\n", "3b18e512dba79e4c8300dd08aeb37f8e728b8dad")],
     )
-    def test_hash_object(self, change_to_tmp_dir, content, expected_hash_value, write, capsys):
+    def test_hash_object(
+        self, change_to_tmp_dir, content, expected_hash_value, write, capsys
+    ):
         git = Git()
         git.init_repo()
         tmp_file = change_to_tmp_dir / "file.txt"
@@ -48,3 +49,20 @@ def test_hash_object(self, change_to_tmp_dir, content, expected_hash_value, writ
         )
         assert expected_path.exists() == write
         assert capsys.readouterr().out == hash_value
+
+    def test_write_tree(self, change_to_tmp_dir):
+        git = Git()
+        git.init_repo()
+        #
+        parent_dir = change_to_tmp_dir / "parent_dir"
+        parent_dir.mkdir()
+        file1 = parent_dir / "file1.txt"
+        file1.write_text("hello")
+        #
+        child_dir = parent_dir / "child_dir"
+        child_dir.mkdir()
+        file2 = child_dir / "file2.txt"
+        file2.write_text("World")
+        #
+        hash_values = git.write_tree()
+        assert 0, "Finish writing tree"

tests/test_utils.py

@@ -30,6 +30,18 @@
                 command="hash-object", path=pathlib.Path("some_file.txt"), write=True
             ),
         ),
+        (
+            ["ls-tree", "some_hash"],
+            Namespace(command="ls-tree", name_only=False, hash_value="some_hash"),
+        ),
+        (
+            [
+                "ls-tree",
+                "--name-only",
+                "some_hash",
+            ],
+            Namespace(command="ls-tree", name_only=True, hash_value="some_hash"),
+        ),
     ],
 )
 def test_parser(params, expected):