Avoid branch::create_reference types to be available from multiple locations.

Byron · Byron · commit 052b82e9a516 · 2025-09-02T14:40:56.000+02:00
diff --git a/crates/but-api/src/commands/stack.rs b/crates/but-api/src/commands/stack.rs
@@ -1,7 +1,6 @@
 use crate::commands::stack::create_reference::Anchor;
 use crate::{App, error::Error};
 use anyhow::{Context, anyhow};
-use but_settings::AppSettings;
 use but_workspace::branch::{ReferenceAnchor, ReferencePosition};
 use gitbutler_branch_actions::internal::PushResult;
 use gitbutler_branch_actions::stack::CreateSeriesRequest;
@@ -57,9 +56,9 @@ pub mod create_reference {
     }
 }
 
-pub fn create_reference(_app: &App, params: create_reference::Params) -> Result<(), Error> {
+pub fn create_reference(app: &App, params: create_reference::Params) -> Result<(), Error> {
     let project = gitbutler_project::get(params.project_id)?;
-    let ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+    let ctx = CommandContext::open(&project, app.app_settings.get()?.clone())?;
     let create_reference::Request { new_name, anchor } = params.request;
     let new_ref = Category::LocalBranch
         .to_full_name(new_name.as_str())
@@ -101,10 +100,10 @@ pub fn create_reference(_app: &App, params: create_reference::Params) -> Result<
     Ok(())
 }
 
-pub fn create_branch(_app: &App, params: CreateBranchParams) -> Result<(), Error> {
+pub fn create_branch(app: &App, params: CreateBranchParams) -> Result<(), Error> {
     let project = gitbutler_project::get(params.project_id)?;
-    let ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
-    if ctx.app_settings().feature_flags.ws3 {
+    let ctx = CommandContext::open(&project, app.app_settings.get()?.clone())?;
+    if app.app_settings.get()?.feature_flags.ws3 {
         use ReferencePosition::Above;
         let mut guard = project.exclusive_worktree_access();
         let (repo, mut meta, graph) = ctx.graph_and_meta_mut_and_repo(guard.write_permission())?;
@@ -165,11 +164,11 @@ pub struct RemoveBranchParams {
     pub branch_name: String,
 }
 
-pub fn remove_branch(_app: &App, params: RemoveBranchParams) -> Result<(), Error> {
+pub fn remove_branch(app: &App, params: RemoveBranchParams) -> Result<(), Error> {
     let project = gitbutler_project::get(params.project_id)?;
-    let ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+    let ctx = CommandContext::open(&project, app.app_settings.get()?.clone())?;
     let mut guard = project.exclusive_worktree_access();
-    if ctx.app_settings().feature_flags.ws3 {
+    if app.app_settings.get()?.feature_flags.ws3 {
         let (repo, mut meta, graph) = ctx.graph_and_meta_mut_and_repo(guard.write_permission())?;
         let ws = graph.to_workspace()?;
         let ref_name = Category::LocalBranch
@@ -205,9 +204,9 @@ pub struct UpdateBranchNameParams {
     pub new_name: String,
 }
 
-pub fn update_branch_name(_app: &App, params: UpdateBranchNameParams) -> Result<(), Error> {
+pub fn update_branch_name(app: &App, params: UpdateBranchNameParams) -> Result<(), Error> {
     let project = gitbutler_project::get(params.project_id)?;
-    let ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+    let ctx = CommandContext::open(&project, app.app_settings.get()?.clone())?;
     gitbutler_branch_actions::stack::update_branch_name(
         &ctx,
         params.stack_id,
@@ -227,11 +226,11 @@ pub struct UpdateBranchDescriptionParams {
 }
 
 pub fn update_branch_description(
-    _app: &App,
+    app: &App,
     params: UpdateBranchDescriptionParams,
 ) -> Result<(), Error> {
     let project = gitbutler_project::get(params.project_id)?;
-    let ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+    let ctx = CommandContext::open(&project, app.app_settings.get()?.clone())?;
     gitbutler_branch_actions::stack::update_branch_description(
         &ctx,
         params.stack_id,
@@ -250,12 +249,9 @@ pub struct UpdateBranchPrNumberParams {
     pub pr_number: Option<usize>,
 }
 
-pub fn update_branch_pr_number(
-    _app: &App,
-    params: UpdateBranchPrNumberParams,
-) -> Result<(), Error> {
+pub fn update_branch_pr_number(app: &App, params: UpdateBranchPrNumberParams) -> Result<(), Error> {
     let project = gitbutler_project::get(params.project_id)?;
-    let ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+    let ctx = CommandContext::open(&project, app.app_settings.get()?.clone())?;
     gitbutler_branch_actions::stack::update_branch_pr_number(
         &ctx,
         params.stack_id,
@@ -275,9 +271,9 @@ pub struct PushStackParams {
     pub branch: String,
 }
 
-pub fn push_stack(_app: &App, params: PushStackParams) -> Result<PushResult, Error> {
+pub fn push_stack(app: &App, params: PushStackParams) -> Result<PushResult, Error> {
     let project = gitbutler_project::get(params.project_id)?;
-    let ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+    let ctx = CommandContext::open(&project, app.app_settings.get()?.clone())?;
     gitbutler_branch_actions::stack::push_stack(
         &ctx,
         params.stack_id,
@@ -297,9 +293,9 @@ pub struct PushStackToReviewParams {
     pub user: User,
 }
 
-pub fn push_stack_to_review(_app: &App, params: PushStackToReviewParams) -> Result<String, Error> {
+pub fn push_stack_to_review(app: &App, params: PushStackToReviewParams) -> Result<String, Error> {
     let project = gitbutler_project::get(params.project_id)?;
-    let ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
+    let ctx = CommandContext::open(&project, app.app_settings.get()?.clone())?;
     let review_id = gitbutler_sync::stack_upload::push_stack_to_review(
         &ctx,
         &params.user,
diff --git a/crates/but-api/tests/api/commands/stack.rs b/crates/but-api/tests/api/commands/stack.rs
@@ -2,7 +2,7 @@ mod create_reference {
     use but_api::commands::stack::create_reference;
     use but_api::commands::stack::create_reference::{Params, Request};
     use but_api::hex_hash::HexHash;
-    use but_workspace::branch::ReferencePosition;
+    use but_workspace::branch::create_reference::Position;
     use gitbutler_project::ProjectId;
     use std::str::FromStr;
 
@@ -34,7 +34,7 @@ mod create_reference {
                         gix::ObjectId::from_str("5c69907b1244089142905dba380371728e2e8160")
                             .unwrap(),
                     ),
-                    position: ReferencePosition::Above,
+                    position: Position::Above,
                 }),
             },
         };
@@ -60,7 +60,7 @@ mod create_reference {
                 new_name: "new-branch".to_string(),
                 anchor: Some(create_reference::Anchor::AtReference {
                     short_name: "anchor-ref".into(),
-                    position: ReferencePosition::Above,
+                    position: Position::Above,
                 }),
             },
         };
diff --git a/crates/but-testing/src/command/mod.rs b/crates/but-testing/src/command/mod.rs
@@ -3,7 +3,7 @@ use but_core::UnifiedDiff;
 use but_db::poll::ItemKind;
 use but_graph::VirtualBranchesTomlMetadata;
 use but_settings::AppSettings;
-use but_workspace::branch::{ReferenceAnchor, ReferencePosition};
+use but_workspace::branch::create_reference::{Anchor, Position};
 use but_workspace::{DiffSpec, HunkHeader};
 use gitbutler_project::{Project, ProjectId};
 use gix::bstr::{BString, ByteSlice};
@@ -601,22 +601,21 @@ pub fn create_reference(
 ) -> anyhow::Result<()> {
     let (repo, project, graph, mut meta) =
         repo_and_maybe_project_and_graph(args, RepositoryOpenMode::General)?;
-    let resolve =
-        |spec: &str, position: ReferencePosition| -> anyhow::Result<ReferenceAnchor<'_>> {
-            Ok(match repo.try_find_reference(spec)? {
-                None => ReferenceAnchor::AtCommit {
-                    commit_id: repo.rev_parse_single(spec)?.detach(),
-                    position,
-                },
-                Some(rn) => ReferenceAnchor::AtSegment {
-                    ref_name: Cow::Owned(rn.inner.name),
-                    position,
-                },
-            })
-        };
+    let resolve = |spec: &str, position: Position| -> anyhow::Result<Anchor<'_>> {
+        Ok(match repo.try_find_reference(spec)? {
+            None => Anchor::AtCommit {
+                commit_id: repo.rev_parse_single(spec)?.detach(),
+                position,
+            },
+            Some(rn) => Anchor::AtSegment {
+                ref_name: Cow::Owned(rn.inner.name),
+                position,
+            },
+        })
+    };
     let anchor = above
-        .map(|spec| resolve(spec, ReferencePosition::Above))
-        .or_else(|| below.map(|spec| resolve(spec, ReferencePosition::Below)))
+        .map(|spec| resolve(spec, Position::Above))
+        .or_else(|| below.map(|spec| resolve(spec, Position::Below)))
         .transpose()?;
 
     let new_ref = Category::LocalBranch.to_full_name(short_name)?;
diff --git a/crates/but-workspace/src/branch/create_reference.rs b/crates/but-workspace/src/branch/create_reference.rs
@@ -1,9 +1,9 @@
 use anyhow::Context;
 use std::borrow::Cow;
 
-/// For use in [`ReferenceAnchor`].
+/// For use in [`Anchor`].
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
-pub enum ReferencePosition {
+pub enum Position {
     /// The new dependent branch will appear above its anchor.
     Above,
     /// The new dependent branch will appear below its anchor.
@@ -33,7 +33,7 @@ impl<'a> From<&'a but_graph::projection::StackCommit> for MinimalCommit<'a> {
     }
 }
 
-impl ReferencePosition {
+impl Position {
     fn resolve_commit(
         &self,
         commit: MinimalCommit<'_>,
@@ -43,15 +43,13 @@ impl ReferencePosition {
             return Ok(commit.id);
         }
         Ok(match self {
-            ReferencePosition::Above => commit.id,
-            ReferencePosition::Below => {
-                commit.parent_ids.iter().cloned().next().with_context(|| {
-                    format!(
-                        "Commit {id} is the first in history and no branch can point below it",
-                        id = commit.id
-                    )
-                })?
-            }
+            Position::Above => commit.id,
+            Position::Below => commit.parent_ids.iter().cloned().next().with_context(|| {
+                format!(
+                    "Commit {id} is the first in history and no branch can point below it",
+                    id = commit.id
+                )
+            })?,
         })
     }
 }
@@ -63,7 +61,7 @@ impl ReferencePosition {
 /// go just by commit. We must be specifying it in terms of above/below ref-name when possible,
 /// or else they will always go on top.
 #[derive(Debug, Clone)]
-pub enum ReferenceAnchor<'a> {
+pub enum Anchor<'a> {
     /// Use a commit as position, which means we always need unambiguous placement
     /// without a way to stack references on top of other references - only on top
     /// of commits their segments may own.
@@ -72,7 +70,7 @@ pub enum ReferenceAnchor<'a> {
         commit_id: gix::ObjectId,
         /// `Above` means the reference will point at `commit_id`, `Below` means it points at its
         /// parent if possible.
-        position: ReferencePosition,
+        position: Position,
     },
     /// Use a segment as reference for positioning the new reference.
     /// Without a workspace, this is the same as saying 'the commit that the segment points to'.
@@ -83,22 +81,22 @@ pub enum ReferenceAnchor<'a> {
         /// if it points to the same commit.
         /// `Below` means the reference will be right below the segment with `ref_name` even
         /// if it points to the same commit.
-        position: ReferencePosition,
+        position: Position,
     },
 }
 
-impl<'a> ReferenceAnchor<'a> {
+impl<'a> Anchor<'a> {
     /// Create a new instance with an object ID as anchor.
-    pub fn at_id(commit_id: impl Into<gix::ObjectId>, position: ReferencePosition) -> Self {
-        ReferenceAnchor::AtCommit {
+    pub fn at_id(commit_id: impl Into<gix::ObjectId>, position: Position) -> Self {
+        Anchor::AtCommit {
             commit_id: commit_id.into(),
             position,
         }
     }
 
     /// Create a new instance with a segment name as anchor.
-    pub fn at_segment(ref_name: &'a gix::refs::FullNameRef, position: ReferencePosition) -> Self {
-        ReferenceAnchor::AtSegment {
+    pub fn at_segment(ref_name: &'a gix::refs::FullNameRef, position: Position) -> Self {
+        Anchor::AtSegment {
             ref_name: Cow::Borrowed(ref_name),
             position,
         }
@@ -108,7 +106,7 @@ impl<'a> ReferenceAnchor<'a> {
 pub(super) mod function {
     #![expect(clippy::indexing_slicing)]
 
-    use crate::branch::{ReferenceAnchor, ReferencePosition};
+    use crate::branch::create_reference::{Anchor, Position};
     use anyhow::{Context, bail};
     use but_core::ref_metadata::{StackId, WorkspaceStack, WorkspaceStackBranch};
     use but_core::{RefMetadata, ref_metadata};
@@ -130,7 +128,7 @@ pub(super) mod function {
     /// Return a regenerated Graph that contains the new reference, and from which a new workspace can be derived.
     pub fn create_reference<'name, T: RefMetadata>(
         ref_name: impl Borrow<gix::refs::FullNameRef>,
-        anchor: impl Into<Option<ReferenceAnchor<'name>>>,
+        anchor: impl Into<Option<Anchor<'name>>>,
         repo: &gix::Repository,
         workspace: &but_graph::projection::Workspace<'_>,
         meta: &mut T,
@@ -172,7 +170,7 @@ pub(super) mod function {
                         Some(Instruction::Independent),
                     )
                 }
-                Some(ReferenceAnchor::AtCommit {
+                Some(Anchor::AtCommit {
                     commit_id,
                     position,
                 }) => {
@@ -200,7 +198,7 @@ pub(super) mod function {
 
                     (validate_id, ref_target_id, instruction)
                 }
-                Some(ReferenceAnchor::AtSegment { ref_name, position }) => {
+                Some(Anchor::AtSegment { ref_name, position }) => {
                     let mut validate_id = true;
                     let ref_target_id = if workspace.has_metadata() {
                         let (stack_idx, seg_idx) = workspace
@@ -396,8 +394,8 @@ pub(super) mod function {
                 let branches = &mut ws_meta.stacks[stack_idx].branches;
                 branches.insert(
                     match position {
-                        ReferencePosition::Above => branch_idx,
-                        ReferencePosition::Below => branch_idx + 1,
+                        Position::Above => branch_idx,
+                        Position::Below => branch_idx + 1,
                     },
                     WorkspaceStackBranch {
                         ref_name: new_ref.to_owned(),
@@ -417,7 +415,7 @@ pub(super) mod function {
         ws: &but_graph::projection::Workspace<'_>,
         anchor_id: gix::ObjectId,
     ) -> anyhow::Result<Instruction<'static>> {
-        use ReferencePosition::*;
+        use Position::*;
         let (anchor_stack_idx, anchor_seg_idx, _anchor_commit_idx) = ws
             .find_owner_indexes_by_commit_id(anchor_id)
             .with_context(|| {
@@ -468,7 +466,7 @@ pub(super) mod function {
         DependentInStack(StackId),
         Dependent {
             ref_name: Cow<'a, gix::refs::FullNameRef>,
-            position: ReferencePosition,
+            position: Position,
         },
     }
 }
diff --git a/crates/but-workspace/src/branch/mod.rs b/crates/but-workspace/src/branch/mod.rs
@@ -460,6 +460,6 @@ impl Stack {
 pub mod remove_reference;
 pub use remove_reference::function::remove_reference;
 
-mod create_reference;
+/// related types for creating a workspace reference.
+pub mod create_reference;
 pub use create_reference::function::create_reference;
-pub use create_reference::*;
diff --git a/crates/but-workspace/tests/workspace/branch/create_reference.rs b/crates/but-workspace/tests/workspace/branch/create_reference.rs
