wip

Author: Caleb-T-Owens

crates/gitbutler-core/src/git/branch_ext.rs

@@ -0,0 +1,15 @@
+use anyhow::{Context, Result};
+
+use crate::types::ReferenceName;
+
+pub trait BranchExt {
+    fn reference_name(&self) -> Result<ReferenceName>;
+}
+
+impl<'repo> BranchExt for git2::Branch<'repo> {
+    fn reference_name(&self) -> Result<ReferenceName> {
+        let name = self.get().name().context("Failed to get branch name")?;
+
+        Ok(name.into())
+    }
+}

crates/gitbutler-core/src/git/mod.rs

@@ -18,3 +18,6 @@ pub use commit_ext::*;
 
 mod commit_buffer;
 pub use commit_buffer::*;
+
+mod branch_ext;
+pub use branch_ext::*;

crates/gitbutler-core/src/types/mod.rs

@@ -8,3 +8,6 @@ pub mod default_true;
 pub struct Sensitive<T>(pub T);
 
 mod sensitive;
+
+mod tagged_string;
+pub use tagged_string::*;

crates/gitbutler-core/src/types/tagged_string.rs

@@ -0,0 +1,60 @@
+use std::{fmt, marker::PhantomData, ops::Deref};
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+/// Tagged string is designed to clarify the purpose of strings when used as a return type
+pub struct TaggedString<T>(String, PhantomData<T>);
+
+impl<T> From<String> for TaggedString<T> {
+    fn from(value: String) -> Self {
+        TaggedString(value, PhantomData)
+    }
+}
+
+impl<T> From<&str> for TaggedString<T> {
+    fn from(value: &str) -> Self {
+        TaggedString(value.to_string(), PhantomData)
+    }
+}
+
+impl<T> Deref for TaggedString<T> {
+    type Target = String;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<'de, T> Deserialize<'de> for TaggedString<T> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        String::deserialize(deserializer).map(Into::into)
+    }
+}
+
+impl<T> Serialize for TaggedString<T> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
+impl<T> fmt::Display for TaggedString<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<T> fmt::Debug for TaggedString<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+pub struct _ReferenceName;
+/// The name of a reference ie. `refs/heads/master`
+pub type ReferenceName = TaggedString<_ReferenceName>;

crates/gitbutler-core/src/virtual_branches/base.rs

@@ -5,13 +5,15 @@ use git2::Index;
 use serde::Serialize;
 
 use super::{
-    branch,
+    branch, convert_to_real_branch,
     integration::{
         get_workspace_head, update_gitbutler_integration, GITBUTLER_INTEGRATION_REFERENCE,
     },
     target, BranchId, RemoteCommit, VirtualBranchHunk, VirtualBranchesHandle,
 };
-use crate::{git::RepositoryExt, virtual_branches::errors::Marker};
+use crate::{
+    git::BranchExt, git::RepositoryExt, types::ReferenceName, virtual_branches::errors::Marker,
+};
 use crate::{
     git::{self, diff},
     project_repository::{self, LogUntil},
@@ -326,10 +328,10 @@ fn _print_tree(repo: &git2::Repository, tree: &git2::Tree) -> Result<()> {
 // determine if what the target branch is now pointing to is mergeable with our current working directory
 // merge the target branch into our current working directory
 // update the target sha
-pub fn update_base_branch(
-    project_repository: &project_repository::Repository,
+pub fn update_base_branch<'repo>(
+    project_repository: &'repo project_repository::Repository,
     user: Option<&users::User>,
-) -> anyhow::Result<Vec<branch::Branch>> {
+) -> anyhow::Result<Vec<git2::Branch<'repo>>> {
     project_repository.assure_resolved()?;
 
     // look up the target and see if there is a new oid
@@ -345,10 +347,10 @@ pub fn update_base_branch(
         .peel_to_commit()
         .context(format!("failed to peel branch {} to commit", target.branch))?;
 
-    let mut unapplied_branches: Vec<branch::Branch> = Vec::new();
+    let mut unapplied_branch_names: Vec<git2::Branch> = Vec::new();
 
     if new_target_commit.id() == target.sha {
-        return Ok(unapplied_branches);
+        return Ok(unapplied_branch_names);
     }
 
     let new_target_tree = new_target_commit
@@ -422,11 +424,13 @@ pub fn update_base_branch(
 
                     if branch_tree_merge_index.has_conflicts() {
                         // branch tree conflicts with new target, unapply branch for now. we'll handle it later, when user applies it back.
-                        if branch.applied {
-                            unapplied_branches.push(branch.clone());
-                        }
-                        branch.applied = false;
-                        vb_state.set_branch(branch.clone())?;
+                        let unapplied_real_branch = convert_to_real_branch(
+                            project_repository,
+                            branch.id,
+                            Default::default(),
+                        )?;
+                        unapplied_branch_names.push(unapplied_real_branch);
+
                         return Ok(Some(branch));
                     }
 
@@ -455,11 +459,13 @@ pub fn update_base_branch(
                     if branch_head_merge_index.has_conflicts() {
                         // branch commits conflict with new target, make sure the branch is
                         // unapplied. conflicts witll be dealt with when applying it back.
-                        if branch.applied {
-                            unapplied_branches.push(branch.clone());
-                        }
-                        branch.applied = false;
-                        vb_state.set_branch(branch.clone())?;
+                        let unapplied_real_branch = convert_to_real_branch(
+                            project_repository,
+                            branch.id,
+                            Default::default(),
+                        )?;
+                        unapplied_branch_names.push(unapplied_real_branch);
+
                         return Ok(Some(branch));
                     }
 
@@ -566,7 +572,7 @@ pub fn update_base_branch(
 
     // Rewriting the integration commit is necessary after changing target sha.
     super::integration::update_gitbutler_integration(&vb_state, project_repository)?;
-    Ok(unapplied_branches)
+    Ok(unapplied_branch_names)
 }
 
 pub fn target_to_base_branch(

crates/gitbutler-core/src/virtual_branches/controller.rs

@@ -1,4 +1,8 @@
-use crate::ops::entry::{OperationKind, SnapshotDetails};
+use crate::{
+    git::BranchExt,
+    ops::entry::{OperationKind, SnapshotDetails},
+    types::ReferenceName,
+};
 use anyhow::Result;
 use std::{collections::HashMap, path::Path, sync::Arc};
 
@@ -7,7 +11,7 @@ use tokio::{sync::Semaphore, task::JoinHandle};
 
 use super::{
     branch::{BranchId, BranchOwnershipClaims},
-    target, target_to_base_branch, BaseBranch, Branch, NameConflitResolution, RemoteBranchFile,
+    target, target_to_base_branch, BaseBranch, NameConflitResolution, RemoteBranchFile,
     VirtualBranchesHandle,
 };
 use crate::{
@@ -152,7 +156,7 @@ impl Controller {
             .await
     }
 
-    pub async fn update_base_branch(&self, project_id: ProjectId) -> Result<Vec<Branch>> {
+    pub async fn update_base_branch(&self, project_id: ProjectId) -> Result<Vec<ReferenceName>> {
         self.inner(project_id)
             .await
             .update_base_branch(project_id)
@@ -551,14 +555,21 @@ impl ControllerInner {
         })
     }
 
-    pub async fn update_base_branch(&self, project_id: ProjectId) -> Result<Vec<Branch>> {
+    pub async fn update_base_branch(&self, project_id: ProjectId) -> Result<Vec<ReferenceName>> {
         let _permit = self.semaphore.acquire().await;
 
         self.with_verify_branch(project_id, |project_repository, user| {
             let _ = project_repository
                 .project()
                 .create_snapshot(SnapshotDetails::new(OperationKind::UpdateWorkspaceBase));
-            super::update_base_branch(project_repository, user).map_err(Into::into)
+            super::update_base_branch(project_repository, user)
+                .map(|unapplied_branches| {
+                    unapplied_branches
+                        .iter()
+                        .filter_map(|unapplied_branch| unapplied_branch.reference_name().ok())
+                        .collect()
+                })
+                .map_err(Into::into)
         })
     }
 

crates/gitbutler-core/tests/suite/virtual_branches/update_base_branch.rs

@@ -795,6 +795,15 @@ mod applied_branch {
         )
         .unwrap();
 
+        let branch_count = controller
+            .list_virtual_branches(*project_id)
+            .await
+            .unwrap()
+            .0
+            .len();
+
+        println!("branch count: {}", branch_count);
+
         {
             // merge branch remotely
             let branch = controller
@@ -809,7 +818,7 @@ mod applied_branch {
         repository.fetch();
 
         {
-            controller.update_base_branch(*project_id).await.unwrap();
+            dbg!(controller.update_base_branch(*project_id).await.unwrap());
 
             // removes integrated commit, leaves non commited work as is
 

crates/gitbutler-core/tests/virtual_branches/mod.rs

@@ -15,13 +15,13 @@ use std::{
 use anyhow::{Context, Result};
 use git2::TreeEntry;
 use gitbutler_core::{
-    git::{self, diff, CommitExt, RepositoryExt},
+    git::{self, CommitExt, RepositoryExt},
     virtual_branches::{
         self,
         branch::{BranchCreateRequest, BranchOwnershipClaims},
         commit, create_virtual_branch, create_virtual_branch_from_branch,
         integrate_upstream_commits,
-        integration::{update_gitbutler_integration, verify_branch},
+        integration::verify_branch,
         is_remote_branch_mergeable, list_remote_branches, list_virtual_branches, unapply_ownership,
         update_branch,
     },

crates/gitbutler-tauri/src/virtual_branches.rs

@@ -6,6 +6,7 @@ pub mod commands {
         error::Code,
         git,
         projects::{self, ProjectId},
+        types::ReferenceName,
         virtual_branches::{
             branch::{self, BranchId, BranchOwnershipClaims},
             controller::Controller,
@@ -154,7 +155,7 @@ pub mod commands {
     pub async fn update_base_branch(
         handle: AppHandle,
         project_id: ProjectId,
-    ) -> Result<Vec<branch::Branch>, Error> {
+    ) -> Result<Vec<ReferenceName>, Error> {
         let unapplied_branches = handle
             .state::<Controller>()
             .update_base_branch(project_id)