|
| 1 | +use std::borrow::Cow; |
| 2 | + |
| 3 | +/// Returned by [function::apply()]. |
| 4 | +pub struct Outcome<'graph> { |
| 5 | + /// The newly created graph, if owned, useful to project a workspace and see how the workspace looks like with the branch applied. |
| 6 | + /// If borrowed, the graph already contains the desired branch and nothing had to be applied. |
| 7 | + pub graph: Cow<'graph, but_graph::Graph>, |
| 8 | + /// `true` if we created the given workspace ref as it didn't exist yet. |
| 9 | + pub workspace_ref_created: bool, |
| 10 | +} |
| 11 | + |
| 12 | +impl Outcome<'_> { |
| 13 | + /// Return `true` if a new graph traversal was performed, which always is a sign for an operation which changed the workspace. |
| 14 | + /// This is `false` if the to be applied branch was already contained in the current workspace. |
| 15 | + pub fn workspace_changed(&self) -> bool { |
| 16 | + matches!(self.graph, Cow::Owned(_)) |
| 17 | + } |
| 18 | +} |
| 19 | + |
| 20 | +impl std::fmt::Debug for Outcome<'_> { |
| 21 | + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { |
| 22 | + f.debug_struct("Outcome") |
| 23 | + .field("workspace_changed", &self.workspace_changed()) |
| 24 | + .field("workspace_ref_created", &self.workspace_ref_created) |
| 25 | + .finish() |
| 26 | + } |
| 27 | +} |
| 28 | + |
| 29 | +/// How the newly applied branch should be integrated into the workspace. |
| 30 | +#[derive(Default, Debug, Copy, Clone)] |
| 31 | +pub enum IntegrationMode { |
| 32 | + /// Do nothing but to merge it into the workspace commit. |
| 33 | + #[default] |
| 34 | + Merge, |
| 35 | +} |
| 36 | + |
| 37 | +/// What to do if the applied branch conflicts? |
| 38 | +#[derive(Default, Debug, Copy, Clone)] |
| 39 | +pub enum OnWorkspaceConflict { |
| 40 | + /// Provide additional information about the stack that conflicted and the files involved in it, |
| 41 | + /// and don't perform the operation. |
| 42 | + #[default] |
| 43 | + AbortAndReportConflictingStack, |
| 44 | +} |
| 45 | + |
| 46 | +/// Decide how a newly created workspace reference should be named. |
| 47 | +#[derive(Default, Debug, Clone)] |
| 48 | +pub enum WorkspaceReferenceNaming { |
| 49 | + /// Create a default workspace branch |
| 50 | + #[default] |
| 51 | + Default, |
| 52 | + /// Create a workspace with the given name instead. |
| 53 | + Given(gix::refs::FullName), |
| 54 | +} |
| 55 | + |
| 56 | +/// Options for [function::apply()]. |
| 57 | +#[derive(Default, Debug, Clone)] |
| 58 | +pub struct Options { |
| 59 | + /// how the branch should be brought into the workspace. |
| 60 | + pub integration_mode: IntegrationMode, |
| 61 | + /// Decide how to deal with conflicts. |
| 62 | + pub on_workspace_conflict: OnWorkspaceConflict, |
| 63 | + /// How the workspace reference should be named should it be created. |
| 64 | + /// The creation is always needed if there are more than one branch applied. |
| 65 | + pub workspace_reference_naming: WorkspaceReferenceNaming, |
| 66 | +} |
| 67 | + |
| 68 | +pub(crate) mod function { |
| 69 | + use super::{Options, Outcome, WorkspaceReferenceNaming}; |
| 70 | + use crate::ref_info::WorkspaceExt; |
| 71 | + use anyhow::{Context, bail}; |
| 72 | + use but_core::RefMetadata; |
| 73 | + use but_graph::init::Overlay; |
| 74 | + use but_graph::projection::WorkspaceKind; |
| 75 | + use std::borrow::Cow; |
| 76 | + |
| 77 | + /// Apply `branch` to the given `workspace`, and possibly create the workspace reference in `repo` |
| 78 | + /// along with its `meta`-data if it doesn't exist yet. |
| 79 | + /// Otherwise, add it to the existing `workspace`, and update its metadata accordingly. |
| 80 | + /// **This means that the contents of `branch` is observable from the new state of `repo`**. |
| 81 | + /// |
| 82 | + /// Note that `workspace` is expected to match the state in `repo` as it's used instead of querying `repo` directly |
| 83 | + /// where possible. |
| 84 | + /// |
| 85 | + /// Also note that we will create a managed workspace reference as needed if necessary, and a workspace commit if there is more than |
| 86 | + /// one reference in the workspace afterward. |
| 87 | + /// |
| 88 | + /// On `error`, neither `repo` nor `meta` will have been changed, but `repo` may contain in-memory objects. |
| 89 | + /// Otherwise, objects will have been persisted, and references and metadata will have been updated. |
| 90 | + pub fn apply<'graph, T: RefMetadata>( |
| 91 | + branch: &gix::refs::FullNameRef, |
| 92 | + workspace: &but_graph::projection::Workspace<'graph>, |
| 93 | + repo: &mut gix::Repository, |
| 94 | + meta: &mut T, |
| 95 | + Options { |
| 96 | + integration_mode: _, |
| 97 | + on_workspace_conflict: _, |
| 98 | + workspace_reference_naming, |
| 99 | + }: Options, |
| 100 | + ) -> anyhow::Result<Outcome<'graph>> { |
| 101 | + if workspace.refname_is_segment(branch) { |
| 102 | + return Ok(Outcome { |
| 103 | + graph: Cow::Borrowed(workspace.graph), |
| 104 | + workspace_ref_created: false, |
| 105 | + }); |
| 106 | + } |
| 107 | + |
| 108 | + if let Some(ws_ref_name) = workspace.ref_name() { |
| 109 | + if repo.try_find_reference(ws_ref_name)?.is_none() { |
| 110 | + // The workspace is the probably ad-hoc, and doesn't exist, *assume* unborn. |
| 111 | + bail!( |
| 112 | + "Cannot create reference on unborn branch '{}'", |
| 113 | + ws_ref_name.shorten() |
| 114 | + ); |
| 115 | + } |
| 116 | + } |
| 117 | + |
| 118 | + if workspace.has_workspace_commit_in_ancestry(repo) { |
| 119 | + bail!("Refusing to work on workspace whose workspace commit isn't at the top"); |
| 120 | + } |
| 121 | + let (workspace_ref_name, must_create_ws_ref) = match &workspace.kind { |
| 122 | + WorkspaceKind::Managed { ref_name } |
| 123 | + | WorkspaceKind::ManagedMissingWorkspaceCommit { ref_name } => { |
| 124 | + (ref_name.clone(), false) |
| 125 | + } |
| 126 | + WorkspaceKind::AdHoc => { |
| 127 | + // We need to switch over to a possibly existing workspace. |
| 128 | + let next_ws_ref_name = match workspace_reference_naming { |
| 129 | + WorkspaceReferenceNaming::Default => { |
| 130 | + gix::refs::FullName::try_from("refs/heads/gitbutler/workspace") |
| 131 | + .expect("known statically") |
| 132 | + } |
| 133 | + WorkspaceReferenceNaming::Given(name) => name, |
| 134 | + }; |
| 135 | + let ws_ref_id = match repo.try_find_reference(next_ws_ref_name.as_ref())? { |
| 136 | + None => { |
| 137 | + // Create a workspace reference later at the current AdHoc workspace id |
| 138 | + workspace |
| 139 | + .stacks |
| 140 | + .first() |
| 141 | + .and_then(|s| s.segments.first()) |
| 142 | + .and_then(|s| s.commits.first().map(|c| c.id)) |
| 143 | + .context("BUG: how can an empty ad-hoc workspace exist? Should have at least one stack-segment with commit")? |
| 144 | + } |
| 145 | + Some(mut existing_workspace_reference) => { |
| 146 | + let id = existing_workspace_reference.peel_to_id_in_place()?; |
| 147 | + id.detach() |
| 148 | + } |
| 149 | + }; |
| 150 | + |
| 151 | + let graph = workspace.graph.redo_traversal_with_overlay( |
| 152 | + repo, |
| 153 | + meta, |
| 154 | + Overlay::default().with_entrypoint(ws_ref_id, Some(next_ws_ref_name)), |
| 155 | + )?; |
| 156 | + todo!("put current ad-hoc stack into ") |
| 157 | + } |
| 158 | + }; |
| 159 | + |
| 160 | + // Everything worked? Assure the ref exists now that (nearly nothing) can go wrong anymore. |
| 161 | + if must_create_ws_ref { |
| 162 | + todo!("create ref") |
| 163 | + } |
| 164 | + todo!("assure workspace commit is present (always for now), and set everything up"); |
| 165 | + } |
| 166 | +} |
0 commit comments