Migrate Project::path to be git_dir.

Author: Byron

Cargo.lock

@@ -16,6 +16,7 @@ export type Project = {
 	title: string;
 	description?: string;
 	path: string;
+	git_dir?: string,
 	api?: CloudProject & {
 		sync: boolean;
 		sync_code: boolean | undefined;

apps/desktop/src/lib/project/project.ts

@@ -10,7 +10,6 @@ doctest = false
 
 [dependencies]
 anyhow.workspace = true
-but-db.workspace = true
 but-workspace.workspace = true
 but-graph.workspace = true
 but-status.workspace = true
@@ -24,7 +23,6 @@ gitbutler-oxidize.workspace = true
 gitbutler-workspace.workspace = true
 gitbutler-branch-actions.workspace = true
 serde.workspace = true
-serde_json.workspace = true
 uuid.workspace = true
 bstr.workspace = true
 tracing.workspace = true

crates/but-worktrees/Cargo.toml

@@ -31,7 +31,6 @@ rmcp.workspace = true
 command-group = { version = "5.0.1", features = ["with-tokio"] }
 sysinfo = "0.37.1"
 gitbutler-project.workspace = true
-gitbutler-repo.workspace = true
 gix.workspace = true
 but-core.workspace = true
 but-api.workspace = true

crates/but/Cargo.toml

@@ -274,11 +274,11 @@ fn get_or_init_project(
 ) -> anyhow::Result<gitbutler_project::Project> {
     let repo = gix::discover(current_dir)?;
     if let Some(path) = repo.workdir() {
-        let project = match gitbutler_project::Project::find_by_path(path) {
+        let project = match gitbutler_project::Project::find_by_worktree_dir(path) {
             Ok(p) => Ok(p),
             Err(_e) => {
                 crate::init::repo(path, false, false)?;
-                gitbutler_project::Project::find_by_path(path)
+                gitbutler_project::Project::find_by_worktree_dir(path)
             }
         }?;
         Ok(project)

crates/but/src/main.rs

@@ -265,7 +265,7 @@ fn get_all_files_in_display_order(ctx: &mut CommandContext) -> anyhow::Result<Ve
     use bstr::BString;
     use but_hunk_assignment::HunkAssignment;
 
-    let project = gitbutler_project::Project::find_by_path(&ctx.project().worktree_dir())?;
+    let project = gitbutler_project::Project::find_by_worktree_dir(&ctx.project().worktree_dir())?;
     let changes =
         but_core::diff::ui::worktree_changes_by_worktree_dir(project.worktree_dir())?.changes;
     let (assignments, _) =

crates/but/src/rub/mod.rs

@@ -5,6 +5,7 @@ edition = "2024"
 authors = ["GitButler <[email protected]>"]
 publish = false
 rust-version = "1.89"
+
 [dependencies]
 anyhow = "1.0.100"
 parking_lot = { workspace = true, features = ["arc_lock"] }
@@ -18,7 +19,6 @@ gitbutler-storage.workspace = true
 but-core.workspace = true
 git2.workspace = true
 gix = { workspace = true, features = ["dirwalk", "credentials", "parallel"] }
-uuid.workspace = true
 strum = { version = "0.27", features = ["derive"] }
 tracing.workspace = true
 resolve-path = "0.1.0"
@@ -29,4 +29,3 @@ fslock = "0.2.1"
 [dev-dependencies]
 gitbutler-testsupport.workspace = true
 tempfile.workspace = true
-tokio = { workspace = true, features = ["rt-multi-thread", "rt", "macros"] }

crates/gitbutler-project/Cargo.toml

@@ -60,34 +60,37 @@ impl Controller {
         }
     }
 
-    pub(crate) fn add<P: AsRef<Path>>(&self, path: P) -> Result<AddProjectOutcome> {
-        let path = path.as_ref();
+    pub(crate) fn add(&self, worktree_dir: impl AsRef<Path>) -> Result<AddProjectOutcome> {
+        let worktree_dir = worktree_dir.as_ref();
         let all_projects = self
             .projects_storage
             .list()
             .context("failed to list projects from storage")?;
         if let Some(existing_project) = all_projects
             .iter()
-            .find(|project| project.worktree_dir() == path)
+            .find(|project| project.worktree_dir() == worktree_dir)
         {
             return Ok(AddProjectOutcome::AlreadyExists(
                 existing_project.to_owned(),
             ));
         }
-        if !path.exists() {
+        if !worktree_dir.exists() {
             return Ok(AddProjectOutcome::PathNotFound);
         }
-        if !path.is_dir() {
+        if !worktree_dir.is_dir() {
             return Ok(AddProjectOutcome::NotADirectory);
         }
-        match gix::open_opts(path, gix::open::Options::isolated()) {
+        let resolved_path = gix::path::realpath(worktree_dir)?;
+        // Make sure the repo is opened from the resolved path - it must be absolute for persistence.
+        let repo = match gix::open_opts(&resolved_path, gix::open::Options::isolated()) {
             Ok(repo) if repo.is_bare() => {
                 return Ok(AddProjectOutcome::BareRepository);
             }
             Ok(repo) if repo.worktree().is_some_and(|wt| !wt.is_main()) => {
-                if path.join(".git").is_file() {
+                if worktree_dir.join(".git").is_file() {
                     return Ok(AddProjectOutcome::NonMainWorktree);
                 };
+                repo
             }
             Ok(repo) => match repo.workdir() {
                 None => {
@@ -97,25 +100,25 @@ impl Controller {
                     if !wd.join(".git").is_dir() {
                         return Ok(AddProjectOutcome::NoDotGitDirectory);
                     }
+                    repo
                 }
             },
             Err(err) => {
                 return Ok(AddProjectOutcome::NotAGitRepository(err.to_string()));
             }
-        }
+        };
 
         let id = ProjectId::generate();
 
         // Resolve the path first to get the actual directory name
-        let resolved_path = gix::path::realpath(path)?;
-        let title_is_not_normal_component = path
+        let title_is_not_normal_component = worktree_dir
             .components()
             .next_back()
             .is_none_or(|c| !matches!(c, Component::Normal(_)));
         let path_for_title = if title_is_not_normal_component {
             &resolved_path
         } else {
-            path
+            worktree_dir
         };
 
         let title = path_for_title.file_name().map_or_else(
@@ -126,8 +129,10 @@ impl Controller {
         let project = Project {
             id,
             title,
+            // TODO(1.0): make this always `None`, until the field can be removed for good.
             worktree_dir: resolved_path,
             api: None,
+            git_dir: repo.git_dir().to_owned(),
             ..Default::default()
         };
 
@@ -201,6 +206,7 @@ impl Controller {
     fn get_inner(&self, id: ProjectId, validate: bool) -> Result<Project> {
         #[cfg_attr(not(windows), allow(unused_mut))]
         let mut project = self.projects_storage.get(id)?;
+        // BACKWARD-COMPATIBLE MIGRATION
         if validate {
             let worktree_dir = project.worktree_dir();
             if gix::open_opts(&worktree_dir, gix::open::Options::isolated()).is_err() {
@@ -217,13 +223,14 @@ impl Controller {
             }
         }
 
+        project.migrate()?;
         if !project.gb_dir().exists()
             && let Err(error) = std::fs::create_dir_all(project.gb_dir())
         {
             tracing::error!(project_id = %project.id, ?error, "failed to create \"{}\" on project get", project.gb_dir().display());
         }
         // Clean up old virtual_branches.toml that was never used
-        let old_virtual_branches_path = project.git_dir()?.join("virtual_branches.toml");
+        let old_virtual_branches_path = project.git_dir().join("virtual_branches.toml");
         if old_virtual_branches_path.exists()
             && let Err(error) = std::fs::remove_file(old_virtual_branches_path)
         {

crates/gitbutler-project/src/controller.rs

@@ -1,5 +1,5 @@
 use std::{
-    path::{self, Path, PathBuf},
+    path::{Path, PathBuf},
     time,
 };
 
@@ -14,7 +14,7 @@ use crate::default_true::DefaultTrue;
 pub enum AuthKey {
     GitCredentialsHelper,
     Local {
-        private_key_path: path::PathBuf,
+        private_key_path: PathBuf,
     },
     // There used to be more auth option variants that we are deprecating and replacing with this
     #[serde(other)]
@@ -78,8 +78,20 @@ pub struct Project {
     pub title: String,
     pub description: Option<String>,
     /// The worktree directory of the project's repository.
+    // TODO: Make it optional for bare repo support!
+    // TODO: Do not actually store it, but obtain it on the fly by using a repository!
     #[serde(rename = "path")]
-    pub(crate) worktree_dir: path::PathBuf,
+    // TODO(1.0): enable the line below to clear the value from storage - we only want the git dir,
+    //       but need to remain compatible. The frontend shouldn't care, so we may need a specific type for that
+    //       which already exists, but… needs cleanup.
+    // #[serde(skip_serializing_if = "Option::is_none")]
+    pub(crate) worktree_dir: PathBuf,
+    /// The storage location of the Git repository itself.
+    /// This is the only value we need to access everything related to the Git repository.
+    ///
+    // TODO(1.0): remove the `default` which is just needed while there is project files without it.
+    #[serde(default)]
+    pub(crate) git_dir: PathBuf,
     #[serde(default)]
     pub preferred_key: AuthKey,
     /// if ok_with_force_push is true, we'll not try to avoid force pushing
@@ -117,6 +129,8 @@ impl Project {
             worktree_dir,
             ..Default::default()
         }
+        .migrated()
+        .unwrap()
     }
 
     /// A special constructor needed as `worktree_dir` isn't accessible anymore.
@@ -126,6 +140,28 @@ impl Project {
             preferred_key,
             ..Default::default()
         }
+        .migrated()
+        .unwrap()
+    }
+}
+
+impl Project {
+    pub(crate) fn migrated(mut self) -> anyhow::Result<Self> {
+        self.migrate()?;
+        Ok(self)
+    }
+
+    pub(crate) fn migrate(&mut self) -> anyhow::Result<()> {
+        if !self.git_dir.as_os_str().is_empty() {
+            return Ok(());
+        }
+        let repo = gix::open_opts(&self.worktree_dir, gix::open::Options::isolated())
+            .context("BUG: worktree is supposed to be valid here for migration")?;
+        self.git_dir = repo.git_dir().to_owned();
+        // NOTE: we set the worktree so the frontend is happier until this usage can be reviewed,
+        // probably for supporting bare repositories.
+        self.worktree_dir = repo.workdir().context("BUG: we currently only support non-bare repos, yet this one didn't have a worktree dir")?.to_owned();
+        Ok(())
     }
 }
 
@@ -143,7 +179,8 @@ impl Project {
         })
     }
     /// Finds an existing project by its path. Errors out if not found.
-    pub fn find_by_path(path: &Path) -> anyhow::Result<Project> {
+    // TODO: find by git-dir instead!
+    pub fn find_by_worktree_dir(worktree_dir: &Path) -> anyhow::Result<Project> {
         let mut projects = crate::list()?;
         // Sort projects by longest pathname to shortest.
         // We need to do this because users might have one gitbutler project
@@ -157,10 +194,12 @@ impl Project {
                 // longest first
                 .reverse()
         });
-        let resolved_path = if path.is_relative() {
-            path.canonicalize().context("Failed to canonicalize path")?
+        let resolved_path = if worktree_dir.is_relative() {
+            worktree_dir
+                .canonicalize()
+                .context("Failed to canonicalize path")?
         } else {
-            path.to_path_buf()
+            worktree_dir.to_path_buf()
         };
         let project = projects
             .into_iter()
@@ -176,6 +215,20 @@ impl Project {
     }
 }
 
+/// Repository helpers.
+impl Project {
+    /// Open an isolated repository, one that didn't read options beyond `.git/config` and
+    /// knows no environment variables.
+    ///
+    /// Use it for fastest-possible access, when incomplete configuration is acceptable.
+    pub fn open_isolated(&self) -> anyhow::Result<gix::Repository> {
+        Ok(gix::open_opts(
+            &self.git_dir,
+            gix::open::Options::isolated(),
+        )?)
+    }
+}
+
 impl Project {
     /// Determines if the project Operations log will be synched with the GitButHub
     pub fn oplog_sync_enabled(&self) -> bool {
@@ -207,34 +260,34 @@ impl Project {
     ///
     /// Normally this is `.git/gitbutler` in the project's repository.
     pub fn gb_dir(&self) -> PathBuf {
-        // TODO(ST): store the gitdir instead. This needs a migration to switch existing `worktree_dir` fields over.
-        self.worktree_dir.join(".git").join("gitbutler")
+        self.git_dir.join("gitbutler")
     }
 
     pub fn snapshot_lines_threshold(&self) -> usize {
         self.snapshot_lines_threshold.unwrap_or(20)
     }
 
-    // TODO(ST): for bare repo support, make this optional, but store the gitdir instead.
+    // TODO(ST): Actually remove this - people should use the `gix::Repository` for worktree handling (which makes it optional, too)
     pub fn worktree_dir(&self) -> PathBuf {
         self.worktree_dir.clone()
     }
 
     /// Set the worktree directory to `worktree_dir`.
-    pub fn set_worktree_dir(&mut self, worktree_dir: path::PathBuf) {
+    pub fn set_worktree_dir(&mut self, worktree_dir: PathBuf) -> anyhow::Result<()> {
+        let repo = gix::open_opts(&worktree_dir, gix::open::Options::isolated())?;
         self.worktree_dir = worktree_dir;
+        self.git_dir = repo.git_dir().to_owned();
+        Ok(())
     }
 
     /// Return the path to the directory that holds the repository data and that is associated with the current worktree.
-    // TODO(ST): store this directory in future, as everything else can be obtained from it: worktree_dir, common_dir.
-    pub fn git_dir(&self) -> anyhow::Result<path::PathBuf> {
-        let repo = gix::open_opts(&self.worktree_dir, gix::open::Options::isolated())?;
-        Ok(repo.git_dir().to_owned())
+    pub fn git_dir(&self) -> &Path {
+        &self.git_dir
     }
 
     /// Return the path to the Git directory of the 'prime' repository, the one that holds all worktrees.
-    pub fn common_git_dir(&self) -> anyhow::Result<path::PathBuf> {
-        let repo = gix::open_opts(&self.worktree_dir, gix::open::Options::isolated())?;
+    pub fn common_git_dir(&self) -> anyhow::Result<PathBuf> {
+        let repo = self.open_isolated()?;
         Ok(repo.common_dir().to_owned())
     }
 }

crates/gitbutler-project/src/project.rs

@@ -97,7 +97,7 @@ impl Storage {
         }
 
         if let Some(path) = &update_request.path {
-            project.set_worktree_dir(path.clone());
+            project.set_worktree_dir(path.clone())?;
         }
 
         if let Some(api) = &update_request.api {