fix(tag): address missing tagger review feedback

Review item #2274 (comment)
reports that "reading them raises `AttributeError`" when native decoding has
no tagger, and requests preserving initialized fields through a CLI fallback.
Four SHA-1/SHA-256 regressions reproduce the native failure. The two cases
with a message also expose CLI loss of the first message line, so falling
back alone would not restore complete metadata.

Adapt `Tag.tagger()` returning `None` to the existing empty `Actor` and zero
date/offset defaults through `parse_actor_and_date("")`. Gix already exposes
the absence correctly; no new Git semantics or fallback is required. Make
the CLI parser recognize the optional tagger header and preserve the entire
message. Git 2.54.0's `tag.c::parse_tag_buffer()` accepts an absent tagger
and sets its date to zero. The existing GIX-28 strict writer gap remains open.

All four regressions now pass on both backends; the native cases forbid
`Git.execute()` during metadata access. Reference and CLI object/index tests
pass on CLI (105 tests, 24 subtests) and Gix (105 tests, 24 subtests).
Ruff, ShellCheck and mypy pass.

Author: codex

doc/gix-backend.md

@@ -130,7 +130,9 @@ these editing fallbacks.
 
 Commit metadata uses `Repository.find_commit().decode()` plus structured
 `Commit.author()`/`committer()` signatures. Tag metadata uses
-`Repository.find_tag().decode()` and `Tag.tagger()`. Decoded extra headers retain
+`Repository.find_tag().decode()` and `Tag.tagger()`. A missing native tagger maps
+to GitPython's empty actor and zero date/offset; tag reads remain native.
+Decoded extra headers retain
 `gpgsig`. Raw Gix object bytes are used only for object streams. If repository
 capabilities require CLI fallback, metadata uses `git cat-file`: general formatted
 Git queries cannot faithfully expose all signature headers or arbitrary tags.

git/objects/tag.py

@@ -113,7 +113,9 @@ def _set_cache_(self, attr: str) -> None:
                 self.object = object_type(self.repo, bytes.fromhex(data["target"]))
                 self.tag = data["name"].decode(defenc, "replace")
                 signature = data["tagger"]
-                if signature is not None:
+                if signature is None:
+                    self.tagger, self.tagged_date, self.tagger_tz_offset = parse_actor_and_date("")
+                else:
                     self.tagger = Actor(
                         signature.name.decode(defenc, "replace"), signature.email.decode(defenc, "replace")
                     )
@@ -144,21 +146,10 @@ def _set_cache_(self, attr: str) -> None:
 
             self.tag = lines[2][4:]  # tag <tag name>
 
-            if len(lines) > 3:
-                tagger_info = lines[3]  # tagger <actor> <date>
-                (
-                    self.tagger,
-                    self.tagged_date,
-                    self.tagger_tz_offset,
-                ) = parse_actor_and_date(tagger_info)
-
-            # Line 4 empty - it could mark the beginning of the next header.
-            # In case there really is no message, it would not exist.
-            # Otherwise a newline separates header from message.
-            if len(lines) > 5:
-                self.message = "\n".join(lines[5:])
-            else:
-                self.message = ""
+            has_tagger = len(lines) > 3 and lines[3].startswith("tagger ")
+            self.tagger, self.tagged_date, self.tagger_tz_offset = parse_actor_and_date(lines[3] if has_tagger else "")
+            message_start = 5 if has_tagger else 4
+            self.message = "\n".join(lines[message_start:])
         # END check our attributes
         else:
             super()._set_cache_(attr)

test/test_refs.py

@@ -71,6 +71,27 @@ def test_non_utf8_tag_names_resolve(object_format):
                 assert repo.commit(tag.path) == repo.head.commit
 
 
+@pytest.mark.parametrize("object_format", ["sha1", "sha256"])
+@pytest.mark.parametrize("message", ["", "release\nmore"])
+def test_tag_without_tagger_initializes_all_metadata(object_format, message):
+    with fixture_repo("refs.sh", "tag-no-tagger", object_format, "message" if message else "empty") as repo:
+        oid = (Path(repo.working_tree_dir).parent / "tag-id").read_text().strip()
+        expected = repo.head.commit
+        tag = TagObject(repo, bytes.fromhex(oid))
+        native_guard = (
+            patch.object(Git, "execute", side_effect=AssertionError("unexpected tag metadata CLI call"))
+            if _backend.name == "gix"
+            else contextlib.nullcontext()
+        )
+        with native_guard:
+            assert tag.object == expected
+            assert tag.tag == "no-tagger"
+            assert tag.tagger == Actor("", None)
+            assert tag.tagged_date == 0
+            assert tag.tagger_tz_offset == 0
+            assert tag.message == message
+
+
 class TestRefs(TestBase):
     def test_from_path(self):
         # Should be able to create any reference directly.

tests/fixtures/refs.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 set -eu
-git init --initial-branch=master repo
+git init --initial-branch=master --object-format="${2:-sha1}" repo
 cd repo
 printf 'initial\n' > file.txt
 git add file.txt
@@ -22,6 +22,14 @@ case "$1" in
             printf 'tagger Mallory <m@evil.example> 1700000001 +0000\n\nrelease\n'
         } | git hash-object -w -t tag --literally --stdin >../tag-id
         ;;
+    tag-no-tagger)
+        {
+            printf 'object %s\ntype commit\ntag no-tagger\n\n' "$(git rev-parse HEAD)"
+            if test "$3" = message; then
+                printf 'release\nmore\n'
+            fi
+        } | git hash-object -w -t tag --literally --stdin >../tag-id
+        ;;
     outside)
         git rev-parse HEAD > ../outside-ref
         ;;