refactor module functions into methods on store types

crates/signed_state/src/checkouts.rs

@@ -11,7 +11,7 @@ use signed_git::Repo;
 use utils::same_repo_url;
 
 use crate::backend::{Backend, BackendEvent};
-use crate::git_store::repo_mirror_root;
+use crate::git_store::Mirrors;
 use crate::local_repos::LocalReposStore;
 use crate::refresh::{RefreshGate, RefreshRequest};
 use crate::repos::RepoListStore;
@@ -308,7 +308,7 @@ impl CheckoutsStore {
 
         let announcements = RepoListStore::global(cx).read(cx).announcements.clone();
         let scanned = LocalReposStore::global(cx).read(cx).repos.clone();
-        let cache_root = repo_mirror_root().canonicalize().ok();
+        let cache_root = Mirrors::root().canonicalize().ok();
 
         let requested: Vec<(RepoAddr, Option<String>)> = self
             .status_requested
@@ -350,7 +350,8 @@ impl CheckoutsStore {
                 facts.push((path.clone(), origin, root));
             }
 
-            let associations = resolve_associations(&remembered, &facts, announcements.iter());
+            let associations =
+                CheckoutsStore::resolve_associations(&remembered, &facts, announcements.iter());
 
             // Missing directories are stale records, drop them.
             let associations: HashMap<RepoAddr, Vec<PathBuf>> = associations
@@ -359,7 +360,7 @@ impl CheckoutsStore {
                 .collect();
 
             let (statuses, push_statuses) =
-                compute_statuses(&associations, &requested, &push_requested, true);
+                CheckoutsStore::compute_statuses(&associations, &requested, &push_requested, true);
 
             Ok::<_, Error>((associations, statuses, push_statuses))
         });
@@ -485,7 +486,7 @@ impl CheckoutsStore {
 
         let work = cx.background_spawn(async move {
             let (statuses, push_statuses) =
-                compute_statuses(&associations, &requested, &push_requested, false);
+                CheckoutsStore::compute_statuses(&associations, &requested, &push_requested, false);
             Ok::<_, Error>((statuses, push_statuses))
         });
 
@@ -519,190 +520,192 @@ impl CheckoutsStore {
     }
 }
 
-fn resolve_associations<'a>(
-    remembered: &[Remembered],
-    scanned: &[(PathBuf, Option<String>, Option<String>)],
-    announcements: impl IntoIterator<Item = &'a Announcement>,
-) -> HashMap<RepoAddr, Vec<PathBuf>> {
-    let announcements: Vec<&Announcement> = announcements.into_iter().collect();
-    let mut out: HashMap<RepoAddr, Vec<PathBuf>> = HashMap::new();
+impl CheckoutsStore {
+    fn resolve_associations<'a>(
+        remembered: &[Remembered],
+        scanned: &[(PathBuf, Option<String>, Option<String>)],
+        announcements: impl IntoIterator<Item = &'a Announcement>,
+    ) -> HashMap<RepoAddr, Vec<PathBuf>> {
+        let announcements: Vec<&Announcement> = announcements.into_iter().collect();
+        let mut out: HashMap<RepoAddr, Vec<PathBuf>> = HashMap::new();
 
-    let mut sorted: Vec<&Remembered> = remembered.iter().collect();
-    sorted.sort_by_key(|record| std::cmp::Reverse(record.last_used));
-    for record in sorted {
-        let paths = out.entry(record.addr.clone()).or_default();
-        if !paths.contains(&record.path) {
-            paths.push(record.path.clone());
+        let mut sorted: Vec<&Remembered> = remembered.iter().collect();
+        sorted.sort_by_key(|record| std::cmp::Reverse(record.last_used));
+        for record in sorted {
+            let paths = out.entry(record.addr.clone()).or_default();
+            if !paths.contains(&record.path) {
+                paths.push(record.path.clone());
+            }
         }
-    }
 
-    for (path, origin, root) in scanned {
-        for announcement in &announcements {
-            let url_match = origin.as_deref().is_some_and(|origin| {
-                announcement
-                    .clone
-                    .iter()
-                    .any(|url| same_repo_url(origin, url.as_str()))
-            });
+        for (path, origin, root) in scanned {
+            for announcement in &announcements {
+                let url_match = origin.as_deref().is_some_and(|origin| {
+                    announcement
+                        .clone
+                        .iter()
+                        .any(|url| same_repo_url(origin, url.as_str()))
+                });
 
-            let euc_match = root
-                .as_deref()
-                .is_some_and(|root| announcement.euc.as_deref() == Some(root));
+                let euc_match = root
+                    .as_deref()
+                    .is_some_and(|root| announcement.euc.as_deref() == Some(root));
 
-            if url_match || euc_match {
-                let paths = out.entry(announcement.addr()).or_default();
-                if !paths.contains(path) {
-                    paths.push(path.clone());
+                if url_match || euc_match {
+                    let paths = out.entry(announcement.addr()).or_default();
+                    if !paths.contains(path) {
+                        paths.push(path.clone());
+                    }
                 }
             }
         }
+
+        out
     }
 
-    out
-}
+    fn checkout_status(path: &Path, announced_head: Option<&str>) -> Option<CheckoutStatus> {
+        let repo = Repo::try_open(path)?;
+        let branches = repo.branches().ok()?;
 
-fn checkout_status(path: &Path, announced_head: Option<&str>) -> Option<CheckoutStatus> {
-    let repo = Repo::try_open(path)?;
-    let branches = repo.branches().ok()?;
+        if branches.is_empty() || repo.is_dirty() {
+            return None;
+        }
 
-    if branches.is_empty() || repo.is_dirty() {
-        return None;
+        let branch = repo.current_branch()?;
+        let head = repo.head()?;
+        let base = announced_head
+            .filter(|name| branches.iter().any(|b| b == name))
+            .map(str::to_owned)
+            .or_else(|| branches.iter().find(|b| *b == "main").cloned())
+            .or_else(|| branches.first().cloned())?;
+
+        if base == branch {
+            return None;
+        }
+
+        let ahead = repo.commits_ahead(&base, &branch);
+        (ahead > 0).then_some(CheckoutStatus {
+            path: path.to_path_buf(),
+            branch,
+            head,
+            base,
+            ahead,
+        })
     }
 
-    let branch = repo.current_branch()?;
-    let head = repo.head()?;
-    let base = announced_head
-        .filter(|name| branches.iter().any(|b| b == name))
-        .map(str::to_owned)
-        .or_else(|| branches.iter().find(|b| *b == "main").cloned())
-        .or_else(|| branches.first().cloned())?;
+    /// The `ready to push` status of one checkout of the user's own repository.
+    fn checkout_push_status(path: &Path, fetch: bool) -> Option<CheckoutStatus> {
+        let repo = Repo::try_open(path)?;
+        if repo.is_dirty() {
+            return None;
+        }
 
-    if base == branch {
-        return None;
-    }
+        let branch = repo.current_branch()?;
+        let head = repo.head()?;
+        let origin = repo.origin_url().ok().flatten()?;
 
-    let ahead = repo.commits_ahead(&base, &branch);
-    (ahead > 0).then_some(CheckoutStatus {
-        path: path.to_path_buf(),
-        branch,
-        head,
-        base,
-        ahead,
-    })
-}
+        if fetch {
+            repo.fetch_refs(&[origin], "+refs/heads/*:refs/remotes/origin/*")
+                .ok();
+        }
 
-/// The `ready to push` status of one checkout of the user's own repository.
-fn checkout_push_status(path: &Path, fetch: bool) -> Option<CheckoutStatus> {
-    let repo = Repo::try_open(path)?;
-    if repo.is_dirty() {
-        return None;
-    }
+        let remote = format!("refs/remotes/origin/{branch}");
 
-    let branch = repo.current_branch()?;
-    let head = repo.head()?;
-    let origin = repo.origin_url().ok().flatten()?;
-
-    if fetch {
-        repo.fetch_refs(&[origin], "+refs/heads/*:refs/remotes/origin/*")
-            .ok();
-    }
-
-    let remote = format!("refs/remotes/origin/{branch}");
-
-    // A branch never fetched or pushed yet compares against the remote HEAD.
-    // The remote HEAD is the fork point in practice.
-    let base = if repo.ref_exists(&remote) {
-        remote
-    } else if repo.ref_exists("refs/remotes/origin/HEAD") {
-        "refs/remotes/origin/HEAD".to_owned()
-    } else {
-        return None;
-    };
-
-    let ahead = repo.commits_ahead(&base, &branch);
-
-    (ahead > 0).then_some(CheckoutStatus {
-        path: path.to_path_buf(),
-        branch,
-        head,
-        base,
-        ahead,
-    })
-}
-
-/// Compute the requested statuses against the checkout paths of `associations`.
-fn compute_statuses(
-    associations: &HashMap<RepoAddr, Vec<PathBuf>>,
-    requested: &[(RepoAddr, Option<String>)],
-    push_requested: &[RepoAddr],
-    fetch: bool,
-) -> (
-    HashMap<RepoAddr, Vec<CheckoutStatus>>,
-    HashMap<RepoAddr, Vec<CheckoutStatus>>,
-) {
-    let mut statuses: HashMap<RepoAddr, Vec<CheckoutStatus>> = HashMap::new();
-    for (addr, announced_head) in requested {
-        let Some(paths) = associations.get(addr) else {
-            continue;
+        // A branch never fetched or pushed yet compares against the remote HEAD.
+        // The remote HEAD is the fork point in practice.
+        let base = if repo.ref_exists(&remote) {
+            remote
+        } else if repo.ref_exists("refs/remotes/origin/HEAD") {
+            "refs/remotes/origin/HEAD".to_owned()
+        } else {
+            return None;
         };
 
-        let list: Vec<CheckoutStatus> = paths
-            .iter()
-            .take(MAX_STATUS_CHECKOUTS)
-            .filter_map(|path| checkout_status(path, announced_head.as_deref()))
-            .collect();
+        let ahead = repo.commits_ahead(&base, &branch);
 
-        if !list.is_empty() {
-            statuses.insert(addr.clone(), list);
+        (ahead > 0).then_some(CheckoutStatus {
+            path: path.to_path_buf(),
+            branch,
+            head,
+            base,
+            ahead,
+        })
+    }
+
+    /// Compute the requested statuses against the checkout paths of `associations`.
+    fn compute_statuses(
+        associations: &HashMap<RepoAddr, Vec<PathBuf>>,
+        requested: &[(RepoAddr, Option<String>)],
+        push_requested: &[RepoAddr],
+        fetch: bool,
+    ) -> (
+        HashMap<RepoAddr, Vec<CheckoutStatus>>,
+        HashMap<RepoAddr, Vec<CheckoutStatus>>,
+    ) {
+        let mut statuses: HashMap<RepoAddr, Vec<CheckoutStatus>> = HashMap::new();
+        for (addr, announced_head) in requested {
+            let Some(paths) = associations.get(addr) else {
+                continue;
+            };
+
+            let list: Vec<CheckoutStatus> = paths
+                .iter()
+                .take(MAX_STATUS_CHECKOUTS)
+                .filter_map(|path| Self::checkout_status(path, announced_head.as_deref()))
+                .collect();
+
+            if !list.is_empty() {
+                statuses.insert(addr.clone(), list);
+            }
         }
-    }
 
-    let mut push_statuses: HashMap<RepoAddr, Vec<CheckoutStatus>> = HashMap::new();
-    for addr in push_requested {
-        let Some(paths) = associations.get(addr) else {
-            continue;
-        };
+        let mut push_statuses: HashMap<RepoAddr, Vec<CheckoutStatus>> = HashMap::new();
+        for addr in push_requested {
+            let Some(paths) = associations.get(addr) else {
+                continue;
+            };
 
-        let list: Vec<CheckoutStatus> = paths
-            .iter()
-            .take(MAX_STATUS_CHECKOUTS)
-            .filter_map(|path| checkout_push_status(path, fetch))
-            .collect();
+            let list: Vec<CheckoutStatus> = paths
+                .iter()
+                .take(MAX_STATUS_CHECKOUTS)
+                .filter_map(|path| Self::checkout_push_status(path, fetch))
+                .collect();
 
-        if !list.is_empty() {
-            push_statuses.insert(addr.clone(), list);
+            if !list.is_empty() {
+                push_statuses.insert(addr.clone(), list);
+            }
         }
+
+        (statuses, push_statuses)
     }
 
-    (statuses, push_statuses)
-}
+    pub fn pr_proposes_checkout(
+        pr: &Event,
+        open: bool,
+        user: PublicKey,
+        checkout: &CheckoutStatus,
+    ) -> bool {
+        if pr.kind != Kind::GitPullRequest || !open || pr.pubkey != user {
+            return false;
+        }
 
-pub fn pr_proposes_checkout(
-    pr: &Event,
-    open: bool,
-    user: PublicKey,
-    checkout: &CheckoutStatus,
-) -> bool {
-    if pr.kind != Kind::GitPullRequest || !open || pr.pubkey != user {
-        return false;
+        let branch_matches = pr
+            .tags
+            .iter()
+            .find(|t| t.kind() == "branch-name")
+            .and_then(|t| t.content())
+            .is_some_and(|name| name == checkout.branch);
+
+        // A renamed branch falls back to the proposed tip commit.
+        let tip_matches = pr
+            .tags
+            .iter()
+            .find(|t| t.kind() == "c")
+            .and_then(|t| t.content())
+            .is_some_and(|tip| tip == checkout.head);
+
+        branch_matches || tip_matches
     }
-
-    let branch_matches = pr
-        .tags
-        .iter()
-        .find(|t| t.kind() == "branch-name")
-        .and_then(|t| t.content())
-        .is_some_and(|name| name == checkout.branch);
-
-    // A renamed branch falls back to the proposed tip commit.
-    let tip_matches = pr
-        .tags
-        .iter()
-        .find(|t| t.kind() == "c")
-        .and_then(|t| t.content())
-        .is_some_and(|tip| tip == checkout.head);
-
-    branch_matches || tip_matches
 }
 
 #[cfg(test)]
@@ -763,7 +766,7 @@ mod tests {
         run(&["checkout", "-b", "feature"]);
         std::fs::write(path.join("feature.txt"), "x\n").expect("write");
         commit("feature work");
-        let status = checkout_status(&path, Some("main")).expect("status");
+        let status = CheckoutsStore::checkout_status(&path, Some("main")).expect("status");
         assert_eq!(status.branch, "feature");
         assert_eq!(status.base, "main");
         assert_eq!(status.ahead, 1);
@@ -771,12 +774,12 @@ mod tests {
 
         // Dirty worktrees are never suggested.
         std::fs::write(path.join("uncommitted.txt"), "y\n").expect("write");
-        assert!(checkout_status(&path, Some("main")).is_none());
+        assert!(CheckoutsStore::checkout_status(&path, Some("main")).is_none());
         run(&["checkout", "--", "."]);
 
         // Even on main, nothing to propose.
         run(&["checkout", "main"]);
-        assert_eq!(checkout_status(&path, Some("main")), None);
+        assert_eq!(CheckoutsStore::checkout_status(&path, Some("main")), None);
     }
 
     #[test]
@@ -822,13 +825,13 @@ mod tests {
         };
 
         // A fresh clone has nothing to push.
-        assert_eq!(checkout_push_status(&checkout, true), None);
+        assert_eq!(CheckoutsStore::checkout_push_status(&checkout, true), None);
 
         // One local commit, ready to push, counted against the remote.
         std::fs::write(checkout.join("work.txt"), "x\n").expect("write");
         run(&["add", "-A"]);
         run(&["commit", "-m", "local work"]);
-        let status = checkout_push_status(&checkout, true).expect("status");
+        let status = CheckoutsStore::checkout_push_status(&checkout, true).expect("status");
         assert_eq!(status.branch, "main");
         assert_eq!(status.base, "refs/remotes/origin/main");
         assert_eq!(status.ahead, 1);
@@ -836,12 +839,12 @@ mod tests {
 
         // The local-only pass reads the tracking refs, no fetch needed:
         // a commit lands locally long before the remote is reconciled.
-        let local = checkout_push_status(&checkout, false).expect("local status");
+        let local = CheckoutsStore::checkout_push_status(&checkout, false).expect("local status");
         assert_eq!(local.ahead, 1);
 
         // After the push the same commit is on the remote, idle again.
         run(&["push", "origin", "main"]);
-        assert_eq!(checkout_push_status(&checkout, true), None);
+        assert_eq!(CheckoutsStore::checkout_push_status(&checkout, true), None);
 
         // A commit made by someone else on the remote must not count as local work.
         // It is behind, not ahead.
@@ -860,6 +863,6 @@ mod tests {
         std::fs::write(remote.join("other.txt"), "y\n").expect("write");
         remote_run(&["add", "-A"]);
         remote_run(&["commit", "-m", "remote work"]);
-        assert_eq!(checkout_push_status(&checkout, true), None);
+        assert_eq!(CheckoutsStore::checkout_push_status(&checkout, true), None);
     }
 }