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

Byron · Byron · commit 22e333030bee · 2025-08-22T10:30:19.000+02:00
diff --git a/crates/but-api/src/commands/stack.rs b/crates/but-api/src/commands/stack.rs
@@ -1,7 +1,7 @@
-use crate::commands::stack::create_reference::Anchor;
+use crate::commands::stack::create_reference::Anchor as AnchorAPI;
 use crate::{App, error::Error};
 use anyhow::{Context, anyhow};
-use but_workspace::branch::{ReferenceAnchor, ReferencePosition};
+use but_workspace::branch::create_reference::{Anchor, Position};
 use gitbutler_branch_actions::internal::PushResult;
 use gitbutler_branch_actions::stack::CreateSeriesRequest;
 use gitbutler_command_context::CommandContext;
@@ -40,11 +40,11 @@ pub mod create_reference {
     pub enum Anchor {
         AtCommit {
             commit_id: HexHash,
-            position: but_workspace::branch::ReferencePosition,
+            position: but_workspace::branch::create_reference::Position,
         },
         AtReference {
             short_name: String,
-            position: but_workspace::branch::ReferencePosition,
+            position: but_workspace::branch::create_reference::Position,
         },
     }
 
@@ -66,17 +66,17 @@ pub fn create_reference(app: &App, params: create_reference::Params) -> Result<(
     let anchor = anchor
         .map(|anchor| -> Result<_, Error> {
             Ok(match anchor {
-                Anchor::AtCommit {
+                AnchorAPI::AtCommit {
                     commit_id,
                     position,
-                } => but_workspace::branch::ReferenceAnchor::AtCommit {
+                } => but_workspace::branch::create_reference::Anchor::AtCommit {
                     commit_id: commit_id.into(),
                     position,
                 },
-                Anchor::AtReference {
+                AnchorAPI::AtReference {
                     short_name,
                     position,
-                } => but_workspace::branch::ReferenceAnchor::AtSegment {
+                } => but_workspace::branch::create_reference::Anchor::AtSegment {
                     ref_name: Cow::Owned(
                         Category::LocalBranch
                             .to_full_name(short_name.as_str())
@@ -104,7 +104,7 @@ pub fn create_branch(app: &App, params: CreateBranchParams) -> Result<(), Error>
     let project = gitbutler_project::get(params.project_id)?;
     let ctx = CommandContext::open(&project, app.app_settings.get()?.clone())?;
     if app.app_settings.get()?.feature_flags.ws3 {
-        use ReferencePosition::Above;
+        use Position::Above;
         let mut guard = project.exclusive_worktree_access();
         let (repo, mut meta, graph) = ctx.graph_and_meta_mut_and_repo(guard.write_permission())?;
         let ws = graph.to_workspace()?;
@@ -128,12 +128,12 @@ pub fn create_branch(app: &App, params: CreateBranchParams) -> Result<(), Error>
                 segment
                     .ref_name
                     .as_ref()
-                    .map(|rn| ReferenceAnchor::AtSegment {
+                    .map(|rn| Anchor::AtSegment {
                         ref_name: Cow::Borrowed(rn.as_ref()),
                         position: Above,
                     })
                     .or_else(|| {
-                        Some(ReferenceAnchor::AtCommit {
+                        Some(Anchor::AtCommit {
                             commit_id: graph.tip_skip_empty(segment.id)?.id,
                             position: Above,
                         })
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};
@@ -611,22 +611,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,
                 }) => {
@@ -193,7 +191,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
@@ -373,8 +371,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(),
@@ -394,7 +392,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(|| {
@@ -444,7 +442,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
