chore: apply formatting

test/git/repo_test.lua

@@ -235,27 +235,33 @@ t.test("status_entry_for: exact match on case-sensitive repo", function()
     t.eq(r:status_entry_for("foo"), nil, "case mismatch returns nil")
 end)
 
-t.test("status_entry_for: case-insensitive fallback when core.ignorecase=true", function()
-    local dir = h.make_repo({ Foo = "x" })
-    h.git(dir, "config", "core.ignorecase", "true")
-    t.write(dir, "Foo", "modified")
-    local r = assert(require("git.core.repo").resolve(dir))
-    wait_initial(r)
-    t.truthy(r:status_entry_for("Foo"), "exact match")
-    t.truthy(r:status_entry_for("foo"), "lowercase finds Foo")
-    t.truthy(r:status_entry_for("FOO"), "uppercase finds Foo")
-end)
+t.test(
+    "status_entry_for: case-insensitive fallback when core.ignorecase=true",
+    function()
+        local dir = h.make_repo({ Foo = "x" })
+        h.git(dir, "config", "core.ignorecase", "true")
+        t.write(dir, "Foo", "modified")
+        local r = assert(require("git.core.repo").resolve(dir))
+        wait_initial(r)
+        t.truthy(r:status_entry_for("Foo"), "exact match")
+        t.truthy(r:status_entry_for("foo"), "lowercase finds Foo")
+        t.truthy(r:status_entry_for("FOO"), "uppercase finds Foo")
+    end
+)
 
-t.test("_invalidate matches stash_refs on refs/stash and logs/refs/stash", function()
-    local dir = h.make_repo({ a = "x" })
-    local r = assert(require("git.core.repo").resolve(dir))
-    r._cache.stash_refs = {}
-    r:_invalidate("refs/stash")
-    t.eq(r._cache.stash_refs, nil)
-    r._cache.stash_refs = {}
-    r:_invalidate("logs/refs/stash")
-    t.eq(r._cache.stash_refs, nil)
-end)
+t.test(
+    "_invalidate matches stash_refs on refs/stash and logs/refs/stash",
+    function()
+        local dir = h.make_repo({ a = "x" })
+        local r = assert(require("git.core.repo").resolve(dir))
+        r._cache.stash_refs = {}
+        r:_invalidate("refs/stash")
+        t.eq(r._cache.stash_refs, nil)
+        r._cache.stash_refs = {}
+        r:_invalidate("logs/refs/stash")
+        t.eq(r._cache.stash_refs, nil)
+    end
+)
 
 t.test("refresh with invalidate=true wipes cache on next fetch", function()
     local dir = h.make_repo({ a = "x" })
@@ -271,83 +277,103 @@ t.test("refresh with invalidate=true wipes cache on next fetch", function()
     t.eq(r._cache["resolve:abc"], nil)
 end)
 
-t.test("refresh emits change.paths listing structurally-changed paths", function()
-    local dir = h.make_repo({ a = "1", b = "1" })
-    local r = assert(require("git.core.repo").resolve(dir))
-    wait_initial(r)
-    t.write(dir, "a", "2")
-    ---@type ow.Git.Repo.Change?
-    local change_seen
-    local unsub = r:on("change", function(change)
-        change_seen = change
-    end)
-    r:refresh()
-    t.wait_for(function()
-        return change_seen ~= nil
-    end, "refresh emit", 2000)
-    unsub()
-    local change = assert(change_seen)
-    t.truthy(change.paths["a"])
-    t.falsy(change.paths["b"], "b is unchanged structurally")
-end)
+t.test(
+    "refresh emits change.paths listing structurally-changed paths",
+    function()
+        local dir = h.make_repo({ a = "1", b = "1" })
+        local r = assert(require("git.core.repo").resolve(dir))
+        wait_initial(r)
+        t.write(dir, "a", "2")
+        ---@type ow.Git.Repo.Change?
+        local change_seen
+        local unsub = r:on("change", function(change)
+            change_seen = change
+        end)
+        r:refresh()
+        t.wait_for(function()
+            return change_seen ~= nil
+        end, "refresh emit", 2000)
+        unsub()
+        local change = assert(change_seen)
+        t.truthy(change.paths["a"])
+        t.falsy(change.paths["b"], "b is unchanged structurally")
+    end
+)
 
-t.test("submodule: parent enumerates initialized submodules by default", function()
-    local outer_path = h.make_submodule_repo()
-    local outer = assert(require("git.core.repo").resolve(outer_path))
-    t.truthy(outer._submodules["sub"], "sub recorded as submodule")
-end)
+t.test(
+    "submodule: parent enumerates initialized submodules by default",
+    function()
+        local outer_path = h.make_submodule_repo()
+        local outer = assert(require("git.core.repo").resolve(outer_path))
+        t.truthy(outer._submodules["sub"], "sub recorded as submodule")
+    end
+)
 
-t.test("submodule: eagerly creates child Repos and subscribes by default", function()
-    local outer_path = h.make_submodule_repo()
-    local outer = assert(require("git.core.repo").resolve(outer_path))
-    wait_initial(outer)
-    local inner = require("git.core.repo").all()[outer_path .. "/sub"]
-    t.truthy(inner, "inner Repo eagerly created")
-    t.truthy(outer._submodules["sub"] and outer._submodules["sub"].unsub, "inner subscribed by outer")
+t.test(
+    "submodule: eagerly creates child Repos and subscribes by default",
+    function()
+        local outer_path = h.make_submodule_repo()
+        local outer = assert(require("git.core.repo").resolve(outer_path))
+        wait_initial(outer)
+        local inner = require("git.core.repo").all()[outer_path .. "/sub"]
+        t.truthy(inner, "inner Repo eagerly created")
+        t.truthy(
+            outer._submodules["sub"] and outer._submodules["sub"].unsub,
+            "inner subscribed by outer"
+        )
 
-    t.write(outer_path .. "/sub", "a", "modified\n")
-    ---@type ow.Git.Repo.Change?
-    local outer_change
-    local unsub = outer:on("change", function(change)
-        outer_change = change
-    end)
-    inner:refresh()
-    t.wait_for(function()
-        return outer_change ~= nil
-    end, "outer notified by inner refresh", 2000)
-    unsub()
+        t.write(outer_path .. "/sub", "a", "modified\n")
+        ---@type ow.Git.Repo.Change?
+        local outer_change
+        local unsub = outer:on("change", function(change)
+            outer_change = change
+        end)
+        inner:refresh()
+        t.wait_for(function()
+            return outer_change ~= nil
+        end, "outer notified by inner refresh", 2000)
+        unsub()
 
-    local entry = outer.status.entries["sub"]
-    t.truthy(entry, "outer sub entry now present")
-    t.eq(entry.kind, "changed")
-end)
+        local entry = outer.status.entries["sub"]
+        t.truthy(entry, "outer sub entry now present")
+        t.eq(entry.kind, "changed")
+    end
+)
 
-t.test("submodule: no eager creation when flag is explicitly disabled", function()
-    vim.g.git_submodule_recursion = false
-    t.defer(function()
-        vim.g.git_submodule_recursion = nil
-    end)
-    local outer_path = h.make_submodule_repo()
-    local outer = assert(require("git.core.repo").resolve(outer_path))
-    wait_initial(outer)
-    t.eq(
-        require("git.core.repo").all()[outer_path .. "/sub"],
-        nil,
-        "inner Repo not created when flag is false"
-    )
-    t.eq(next(outer._submodules), nil)
-end)
+t.test(
+    "submodule: no eager creation when flag is explicitly disabled",
+    function()
+        vim.g.git_submodule_recursion = false
+        t.defer(function()
+            vim.g.git_submodule_recursion = nil
+        end)
+        local outer_path = h.make_submodule_repo()
+        local outer = assert(require("git.core.repo").resolve(outer_path))
+        wait_initial(outer)
+        t.eq(
+            require("git.core.repo").all()[outer_path .. "/sub"],
+            nil,
+            "inner Repo not created when flag is false"
+        )
+        t.eq(next(outer._submodules), nil)
+    end
+)
 
-t.test("submodule: outer created after inner picks up existing child", function()
-    local outer_path = h.make_submodule_repo()
-    local inner = assert(
-        require("git.core.repo").resolve(outer_path .. "/sub")
-    )
-    wait_initial(inner)
-    local outer = assert(require("git.core.repo").resolve(outer_path))
-    wait_initial(outer)
-    t.truthy(outer._submodules["sub"] and outer._submodules["sub"].unsub, "outer subscribed to pre-existing inner")
-end)
+t.test(
+    "submodule: outer created after inner picks up existing child",
+    function()
+        local outer_path = h.make_submodule_repo()
+        local inner =
+            assert(require("git.core.repo").resolve(outer_path .. "/sub"))
+        wait_initial(inner)
+        local outer = assert(require("git.core.repo").resolve(outer_path))
+        wait_initial(outer)
+        t.truthy(
+            outer._submodules["sub"] and outer._submodules["sub"].unsub,
+            "outer subscribed to pre-existing inner"
+        )
+    end
+)
 
 t.test("watcher cleans up after a slash-branch dir is removed", function()
     local dir = h.make_repo({ a = "x" })