781 lines
30 KiB
Rust
781 lines
30 KiB
Rust
//! This handles worktrees for repositories. Some considerations to take care
|
|
//! of:
|
|
//!
|
|
//! * Which branch to check out / create
|
|
//! * Which commit to check out
|
|
//! * Whether to track a remote branch, and which
|
|
//!
|
|
//! There are a general rules. The main goal is to do the least surprising thing
|
|
//! in each situation, and to never change existing setups (e.g. tracking,
|
|
//! branch states) except when explicitly told to. In 99% of all cases, the
|
|
//! workflow will be quite straightforward.
|
|
//!
|
|
//! * The name of the worktree (and therefore the path) is **always** the same
|
|
//! as the name of the branch.
|
|
//! * Never modify existing local branches
|
|
//! * Only modify tracking branches for existing local branches if explicitly
|
|
//! requested
|
|
//! * By default, do not do remote operations. This means that we do no do any
|
|
//! tracking setup (but of course, the local branch can already have a
|
|
//! tracking branch set up, which will just be left alone)
|
|
//! * Be quite lax with finding a remote tracking branch (as using an existing
|
|
//! branch is most likely preferred to creating a new branch)
|
|
//!
|
|
//! There are a few different options that can be given:
|
|
//!
|
|
//! * Explicit track (`--track`) and explicit no-track (`--no-track`)
|
|
//! * A configuration may specify to enable tracking a remote branch by default
|
|
//! * A configuration may specify a prefix for remote branches
|
|
//!
|
|
//! # How to handle the local branch?
|
|
//!
|
|
//! That one is easy: If a branch with the desired name already exists, all is
|
|
//! well. If not, we create a new one.
|
|
//!
|
|
//! # Which commit should be checked out?
|
|
//!
|
|
//! The most imporant rule: If the local branch already existed, just leave it
|
|
//! as it is. Only if a new branch is created do we need to answer the question
|
|
//! which commit to set it to. Generally, we set the branch to whatever the
|
|
//! "default" branch of the repository is (something like "main" or "master").
|
|
//! But there are a few cases where we can use remote branches to make the
|
|
//! result less surprising.
|
|
//!
|
|
//! First, if tracking is explicitly disabled, we still try to guess! But we
|
|
//! *do* ignore `--track`, as this is how it's done everywhere else.
|
|
//!
|
|
//! As an example: If `origin/foobar` exists and we run `grm worktree add foobar
|
|
//! --no-track`, we create a new worktree called `foobar` that's on the same
|
|
//! state as `origin/foobar` (but we will not set up tracking, see below).
|
|
//!
|
|
//! If tracking is explicitly requested to a certain state, we use that remote
|
|
//! branch. If it exists, easy. If not, no more guessing!
|
|
//!
|
|
//! Now, it's important to select the correct remote. In the easiest case, there
|
|
//! is only one remote, so we just use that one. If there is more than one
|
|
//! remote, we check whether there is a default remote configured via
|
|
//! `track.default_remote`. If yes, we use that one. If not, we have to do the
|
|
//! selection process below *for each of them*. If only one of them returns
|
|
//! some branch to track, we use that one. If more than one remote returns
|
|
//! information, we only use it if it's identical for each. Otherwise we bail,
|
|
//! as there is no point in guessing.
|
|
//!
|
|
//! The commit selection process looks like this:
|
|
//!
|
|
//! * If a prefix is specified in the configuration, we look for
|
|
//! `{remote}/{prefix}/{worktree_name}`
|
|
//!
|
|
//! * We look for `{remote}/{worktree_name}` (yes, this means that even when a
|
|
//! prefix is configured, we use a branch *without* a prefix if one with
|
|
//! prefix does not exist)
|
|
//!
|
|
//! Note that we may select different branches for different remotes when
|
|
//! prefixes is used. If remote1 has a branch with a prefix and remote2 only has
|
|
//! a branch *without* a prefix, we select them both when a prefix is used. This
|
|
//! could lead to the following situation:
|
|
//!
|
|
//! * There is `origin/prefix/foobar` and `remote2/foobar`, with different
|
|
//! states
|
|
//! * You set `track.default_prefix = "prefix"` (and no default remote!)
|
|
//! * You run `grm worktree add `prefix/foobar`
|
|
//! * Instead of just picking `origin/prefix/foobar`, grm will complain because
|
|
//! it also selected `remote2/foobar`.
|
|
//!
|
|
//! This is just emergent behavior of the logic above. Fixing it would require
|
|
//! additional logic for that edge case. I assume that it's just so rare to get
|
|
//! that behavior that it's acceptable for now.
|
|
//!
|
|
//! Now we either have a commit, we aborted, or we do not have commit. In the
|
|
//! last case, as stated above, we check out the "default" branch.
|
|
//!
|
|
//! # The remote tracking branch
|
|
//!
|
|
//! First, the only remote operations we do is branch creation! It's
|
|
//! unfortunately not possible to defer remote branch creation until the first
|
|
//! `git push`, which would be ideal. The remote tracking branch has to already
|
|
//! exist, so we have to do the equivalent of `git push --set-upstream` during
|
|
//! worktree creation.
|
|
//!
|
|
//! Whether (and which) remote branch to track works like this:
|
|
//!
|
|
//! * If `--no-track` is given, we never track a remote branch, except when
|
|
//! branch already has a tracking branch. So we'd be done already!
|
|
//!
|
|
//! * If `--track` is given, we always track this branch, regardless of anything
|
|
//! else. If the branch exists, cool, otherwise we create it.
|
|
//!
|
|
//! If neither is given, we only set up tracking if requested in the
|
|
//! configuration file (`track.default = true`)
|
|
//!
|
|
//! The rest of the process is similar to the commit selection above. The only
|
|
//! difference is the remote selection. If there is only one, we use it, as
|
|
//! before. Otherwise, we try to use `default_remote` from the configuration, if
|
|
//! available. If not, we do not set up a remote tracking branch. It works like
|
|
//! this:
|
|
//!
|
|
//! * If a prefix is specified in the configuration, we use
|
|
//! `{remote}/{prefix}/{worktree_name}`
|
|
//!
|
|
//! * If no prefix is specified in the configuration, we use
|
|
//! `{remote}/{worktree_name}`
|
|
//!
|
|
//! Now that we have a remote, we use the same process as above:
|
|
//!
|
|
//! * If a prefix is specified in the configuration, we use for
|
|
//! `{remote}/{prefix}/{worktree_name}`
|
|
//! * We use for `{remote}/{worktree_name}`
|
|
//!
|
|
//! ---
|
|
//!
|
|
//! All this means that in some weird situation, you may end up with the state
|
|
//! of a remote branch while not actually tracking that branch. This can only
|
|
//! happen in repositories with more than one remote. Imagine the following:
|
|
//!
|
|
//! The repository has two remotes (`remote1` and `remote2`) which have the
|
|
//! exact same remote state. But there is no `default_remote` in the
|
|
//! configuration (or no configuration at all). There is a remote branch
|
|
//! `foobar`. As both `remote1/foobar` and `remote2/foobar` as the same, the new
|
|
//! worktree will use that as the state of the new branch. But as `grm` cannot
|
|
//! tell which remote branch to track, it will not set up remote tracking. This
|
|
//! behavior may be a bit confusing, but first, there is no good way to resolve
|
|
//! this, and second, the situation should be really rare (when having multiple
|
|
//! remotes, you would generally have a `default_remote` configured).
|
|
//!
|
|
//! # Implementation
|
|
//!
|
|
//! To reduce the chance of bugs, the implementation uses the [typestate
|
|
//! pattern](http://cliffle.com/blog/rust-typestate/). Here are the states we
|
|
//! are moving through linearily:
|
|
//!
|
|
//! * Init
|
|
//! * A local branch name is set
|
|
//! * A local commit to set the new branch to is selected
|
|
//! * A remote tracking branch is selected
|
|
//! * The new branch is created with all the required settings
|
|
//!
|
|
//! Don't worry about the lifetime stuff: There is only one single lifetime, as
|
|
//! everything (branches, commits) is derived from the single repo::Repo
|
|
//! instance
|
|
//!
|
|
//! # Testing
|
|
//!
|
|
//! There are two types of input to the tests:
|
|
//!
|
|
//! 1) The parameters passed to `grm`, either via command line or via
|
|
//! configuration file
|
|
//! 2) The circumstances in the repository and remotes
|
|
//!
|
|
//! ## Parameters
|
|
//!
|
|
//! * The name of the worktree
|
|
//! * Whether it contains slashes or not
|
|
//! * Whether it is invalid
|
|
//! * `--track` and `--no-track`
|
|
//! * Whether there is a configuration file and what it contains
|
|
//! * Whether `track.default` is enabled or disabled
|
|
//! * Whether `track.default_remote_prefix` is there or missing
|
|
//! * Whether `track.default_remote` is there or missing
|
|
//! * Whether that remote exists or not
|
|
//!
|
|
//! ## Situations
|
|
//!
|
|
//! ### The local branch
|
|
//!
|
|
//! * Whether the branch already exists
|
|
//! * Whether the branch has a remote tracking branch and whether it differs
|
|
//! from the desired tracking branch (i.e. `--track` or config)
|
|
//!
|
|
//! ### Remotes
|
|
//!
|
|
//! * How many remotes there are, if any
|
|
//! * If more than two remotes exist, whether their desired tracking branch
|
|
//! differs
|
|
//!
|
|
//! ### The remote tracking branch branch
|
|
//!
|
|
//! * Whether a remote branch with the same name as the worktree exists
|
|
//! * Whether a remote branch with the same name as the worktree plus prefix
|
|
//! exists
|
|
//!
|
|
//! ## Outcomes
|
|
//!
|
|
//! We have to check the following afterwards:
|
|
//!
|
|
//! * Does the worktree exist in the correct location?
|
|
//! * Does the local branch have the same name as the worktree?
|
|
//! * Does the local branch have the correct commit?
|
|
//! * Does the local branch track the correct remote branch?
|
|
//! * Does that remote branch also exist?
|
|
use std::cell::RefCell;
|
|
use std::path::Path;
|
|
|
|
// use super::output::*;
|
|
use super::repo;
|
|
|
|
pub const GIT_MAIN_WORKTREE_DIRECTORY: &str = ".git-main-working-tree";
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn invalid_worktree_names() {
|
|
assert!(add_worktree(Path::new("/tmp/"), "/leadingslash", None, false).is_err());
|
|
assert!(add_worktree(Path::new("/tmp/"), "trailingslash/", None, false).is_err());
|
|
assert!(add_worktree(Path::new("/tmp/"), "//", None, false).is_err());
|
|
assert!(add_worktree(Path::new("/tmp/"), "test//test", None, false).is_err());
|
|
assert!(add_worktree(Path::new("/tmp/"), "test test", None, false).is_err());
|
|
assert!(add_worktree(Path::new("/tmp/"), "test\ttest", None, false).is_err());
|
|
}
|
|
}
|
|
|
|
struct Init;
|
|
|
|
struct WithLocalBranchName<'a> {
|
|
local_branch_name: String,
|
|
/// Outer option: Is there a computed value?
|
|
/// Inner option: Is there actually a branch?
|
|
///
|
|
/// None => No computed value yet
|
|
/// Some(None) => No branch
|
|
/// Some(Some(_)) => Branch
|
|
local_branch: RefCell<Option<Option<repo::Branch<'a>>>>,
|
|
}
|
|
|
|
struct WithLocalTargetSelected<'a> {
|
|
local_branch_name: String,
|
|
local_branch: Option<repo::Branch<'a>>,
|
|
target_commit: Option<Box<repo::Commit<'a>>>,
|
|
}
|
|
|
|
struct WithRemoteTrackingBranch<'a> {
|
|
local_branch_name: String,
|
|
local_branch: Option<repo::Branch<'a>>,
|
|
target_commit: Option<Box<repo::Commit<'a>>>,
|
|
remote_tracking_branch: Option<(String, String)>,
|
|
prefix: Option<String>,
|
|
}
|
|
|
|
struct Worktree<'a, S: WorktreeState> {
|
|
repo: &'a repo::RepoHandle,
|
|
extra: S,
|
|
}
|
|
|
|
impl<'a> WithLocalBranchName<'a> {
|
|
fn new(name: String) -> Self {
|
|
Self {
|
|
local_branch_name: name,
|
|
local_branch: RefCell::new(None),
|
|
}
|
|
}
|
|
}
|
|
|
|
trait WorktreeState {}
|
|
|
|
impl WorktreeState for Init {}
|
|
impl<'a> WorktreeState for WithLocalBranchName<'a> {}
|
|
impl<'a> WorktreeState for WithLocalTargetSelected<'a> {}
|
|
impl<'a> WorktreeState for WithRemoteTrackingBranch<'a> {}
|
|
|
|
impl<'a> Worktree<'a, Init> {
|
|
fn new(repo: &'a repo::RepoHandle) -> Self {
|
|
Self {
|
|
repo,
|
|
extra: Init {},
|
|
}
|
|
}
|
|
|
|
fn set_local_branch_name(self, name: &str) -> Worktree<'a, WithLocalBranchName<'a>> {
|
|
Worktree::<WithLocalBranchName> {
|
|
repo: self.repo,
|
|
extra: WithLocalBranchName::new(name.to_string()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a, 'b> Worktree<'a, WithLocalBranchName<'b>>
|
|
where
|
|
'a: 'b,
|
|
{
|
|
fn check_local_branch(&self) {
|
|
let mut branchref = self.extra.local_branch.borrow_mut();
|
|
if branchref.is_none() {
|
|
let branch = self.repo.find_local_branch(&self.extra.local_branch_name);
|
|
*branchref = Some(if let Ok(branch) = branch {
|
|
Some(branch)
|
|
} else {
|
|
None
|
|
});
|
|
}
|
|
}
|
|
|
|
fn local_branch_already_exists(&self) -> bool {
|
|
if let Some(branch) = &*self.extra.local_branch.borrow() {
|
|
return branch.is_some();
|
|
}
|
|
self.check_local_branch();
|
|
// As we just called `check_local_branch`, we can be sure that
|
|
// `self.extra.local_branch` is set to some `Some` value
|
|
(*self.extra.local_branch.borrow())
|
|
.as_ref()
|
|
.unwrap()
|
|
.is_some()
|
|
}
|
|
|
|
fn select_commit(
|
|
self,
|
|
commit: Option<Box<repo::Commit<'b>>>,
|
|
) -> Worktree<'a, WithLocalTargetSelected<'b>> {
|
|
self.check_local_branch();
|
|
|
|
Worktree::<'a, WithLocalTargetSelected> {
|
|
repo: self.repo,
|
|
extra: WithLocalTargetSelected::<'b> {
|
|
local_branch_name: self.extra.local_branch_name,
|
|
// As we just called `check_local_branch`, we can be sure that
|
|
// `self.extra.local_branch` is set to some `Some` value
|
|
local_branch: self.extra.local_branch.into_inner().unwrap(),
|
|
target_commit: commit,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> Worktree<'a, WithLocalTargetSelected<'a>> {
|
|
fn set_remote_tracking_branch(
|
|
self,
|
|
branch: Option<(&str, &str)>,
|
|
prefix: Option<&str>,
|
|
) -> Worktree<'a, WithRemoteTrackingBranch<'a>> {
|
|
Worktree::<WithRemoteTrackingBranch> {
|
|
repo: self.repo,
|
|
extra: WithRemoteTrackingBranch {
|
|
local_branch_name: self.extra.local_branch_name,
|
|
local_branch: self.extra.local_branch,
|
|
target_commit: self.extra.target_commit,
|
|
remote_tracking_branch: branch.map(|(s1, s2)| (s1.to_string(), s2.to_string())),
|
|
prefix: prefix.map(|prefix| prefix.to_string()),
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a> Worktree<'a, WithRemoteTrackingBranch<'a>> {
|
|
fn create(self, directory: &Path) -> Result<Option<Vec<String>>, String> {
|
|
let mut warnings: Vec<String> = vec![];
|
|
|
|
let mut branch = if let Some(branch) = self.extra.local_branch {
|
|
branch
|
|
} else {
|
|
self.repo.create_branch(
|
|
&self.extra.local_branch_name,
|
|
// TECHDEBT
|
|
// We must not call this with `Some()` without a valid target.
|
|
// I'm sure this can be improved, just not sure how.
|
|
&self.extra.target_commit.unwrap(),
|
|
)?
|
|
};
|
|
|
|
if let Some((remote_name, remote_branch_name)) = self.extra.remote_tracking_branch {
|
|
let remote_branch_with_prefix = if let Some(ref prefix) = self.extra.prefix {
|
|
if let Ok(remote_branch) = self
|
|
.repo
|
|
.find_remote_branch(&remote_name, &format!("{prefix}/{remote_branch_name}"))
|
|
{
|
|
Some(remote_branch)
|
|
} else {
|
|
None
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let remote_branch_without_prefix = if let Ok(remote_branch) = self
|
|
.repo
|
|
.find_remote_branch(&remote_name, &remote_branch_name)
|
|
{
|
|
Some(remote_branch)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
let remote_branch = if let Some(ref _prefix) = self.extra.prefix {
|
|
remote_branch_with_prefix
|
|
} else {
|
|
remote_branch_without_prefix
|
|
};
|
|
|
|
match remote_branch {
|
|
Some(remote_branch) => {
|
|
if branch.commit()?.id().hex_string()
|
|
!= remote_branch.commit()?.id().hex_string()
|
|
{
|
|
warnings.push(format!("The local branch \"{}\" and the remote branch \"{}/{}\" differ. Make sure to push/pull afterwards!", &self.extra.local_branch_name, &remote_name, &remote_branch_name));
|
|
}
|
|
|
|
branch.set_upstream(&remote_name, &remote_branch.basename()?)?;
|
|
}
|
|
None => {
|
|
let mut remote = match self.repo.find_remote(&remote_name)? {
|
|
Some(remote) => remote,
|
|
None => return Err(format!("Remote \"{remote_name}\" not found")),
|
|
};
|
|
|
|
if !remote.is_pushable()? {
|
|
return Err(format!(
|
|
"Cannot push to non-pushable remote \"{remote_name}\""
|
|
));
|
|
}
|
|
|
|
if let Some(prefix) = self.extra.prefix {
|
|
remote.push(
|
|
&self.extra.local_branch_name,
|
|
&format!("{}/{}", prefix, remote_branch_name),
|
|
self.repo,
|
|
)?;
|
|
|
|
branch.set_upstream(
|
|
&remote_name,
|
|
&format!("{}/{}", prefix, remote_branch_name),
|
|
)?;
|
|
} else {
|
|
remote.push(
|
|
&self.extra.local_branch_name,
|
|
&remote_branch_name,
|
|
self.repo,
|
|
)?;
|
|
|
|
branch.set_upstream(&remote_name, &remote_branch_name)?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// We have to create subdirectories first, otherwise adding the worktree
|
|
// will fail
|
|
if self.extra.local_branch_name.contains('/') {
|
|
let path = Path::new(&self.extra.local_branch_name);
|
|
if let Some(base) = path.parent() {
|
|
// This is a workaround of a bug in libgit2 (?)
|
|
//
|
|
// When *not* doing this, we will receive an error from the `Repository::worktree()`
|
|
// like this:
|
|
//
|
|
// > failed to make directory '/{repo}/.git-main-working-tree/worktrees/dir/test
|
|
//
|
|
// This is a discrepancy between the behavior of libgit2 and the
|
|
// git CLI when creating worktrees with slashes:
|
|
//
|
|
// The git CLI will create the worktree's configuration directory
|
|
// inside {git_dir}/worktrees/{last_path_component}. Look at this:
|
|
//
|
|
// ```
|
|
// $ git worktree add 1/2/3 -b 1/2/3
|
|
// $ ls .git/worktrees
|
|
// 3
|
|
// ```
|
|
//
|
|
// Interesting: When adding a worktree with a different name but the
|
|
// same final path component, git starts adding a counter suffix to
|
|
// the worktree directories:
|
|
//
|
|
// ```
|
|
// $ git worktree add 1/3/3 -b 1/3/3
|
|
// $ git worktree add 1/4/3 -b 1/4/3
|
|
// $ ls .git/worktrees
|
|
// 3
|
|
// 31
|
|
// 32
|
|
// ```
|
|
//
|
|
// I *guess* that the mapping back from the worktree directory under .git to the actual
|
|
// worktree directory is done via the `gitdir` file inside `.git/worktrees/{worktree}.
|
|
// This means that the actual directory would not matter. You can verify this by
|
|
// just renaming it:
|
|
//
|
|
// ```
|
|
// $ mv .git/worktrees/3 .git/worktrees/foobar
|
|
// $ git worktree list
|
|
// /tmp/ fcc8a2a7 [master]
|
|
// /tmp/1/2/3 fcc8a2a7 [1/2/3]
|
|
// /tmp/1/3/3 fcc8a2a7 [1/3/3]
|
|
// /tmp/1/4/3 fcc8a2a7 [1/4/3]
|
|
// ```
|
|
//
|
|
// => Still works
|
|
//
|
|
// Anyway, libgit2 does not do this: It tries to create the worktree
|
|
// directory inside .git with the exact name of the worktree, including
|
|
// any slashes. It should be this code:
|
|
//
|
|
// https://github.com/libgit2/libgit2/blob/f98dd5438f8d7bfd557b612fdf1605b1c3fb8eaf/src/libgit2/worktree.c#L346
|
|
//
|
|
// As a workaround, we can create the base directory manually for now.
|
|
//
|
|
// Tracking upstream issue: https://github.com/libgit2/libgit2/issues/6327
|
|
std::fs::create_dir_all(
|
|
directory
|
|
.join(GIT_MAIN_WORKTREE_DIRECTORY)
|
|
.join("worktrees")
|
|
.join(base),
|
|
)
|
|
.map_err(|error| error.to_string())?;
|
|
std::fs::create_dir_all(base).map_err(|error| error.to_string())?;
|
|
}
|
|
}
|
|
|
|
self.repo.new_worktree(
|
|
&self.extra.local_branch_name,
|
|
&directory.join(&self.extra.local_branch_name),
|
|
&branch,
|
|
)?;
|
|
|
|
Ok(if warnings.is_empty() {
|
|
None
|
|
} else {
|
|
Some(warnings)
|
|
})
|
|
}
|
|
}
|
|
|
|
/// A branch name must never start or end with a slash, and it cannot have two
|
|
/// consecutive slashes
|
|
fn validate_worktree_name(name: &str) -> Result<(), String> {
|
|
if name.starts_with('/') || name.ends_with('/') {
|
|
return Err(format!(
|
|
"Invalid worktree name: {}. It cannot start or end with a slash",
|
|
name
|
|
));
|
|
}
|
|
|
|
if name.contains("//") {
|
|
return Err(format!(
|
|
"Invalid worktree name: {}. It cannot contain two consecutive slashes",
|
|
name
|
|
));
|
|
}
|
|
|
|
if name.contains(char::is_whitespace) {
|
|
return Err(format!(
|
|
"Invalid worktree name: {}. It cannot contain whitespace",
|
|
name
|
|
));
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// TECHDEBT
|
|
//
|
|
// Instead of opening the repo & reading configuration inside the function, it
|
|
// should be done by the caller and given as a parameter
|
|
pub fn add_worktree(
|
|
directory: &Path,
|
|
name: &str,
|
|
track: Option<(&str, &str)>,
|
|
no_track: bool,
|
|
) -> Result<Option<Vec<String>>, String> {
|
|
let mut warnings: Vec<String> = vec![];
|
|
|
|
validate_worktree_name(name)?;
|
|
|
|
let repo = repo::RepoHandle::open(directory, true).map_err(|error| match error.kind {
|
|
repo::RepoErrorKind::NotFound => {
|
|
String::from("Current directory does not contain a worktree setup")
|
|
}
|
|
_ => format!("Error opening repo: {}", error),
|
|
})?;
|
|
|
|
let remotes = &repo.remotes()?;
|
|
|
|
let config = repo::read_worktree_root_config(directory)?;
|
|
|
|
if repo.find_worktree(name).is_ok() {
|
|
return Err(format!("Worktree {} already exists", &name));
|
|
}
|
|
|
|
let track_config = config.and_then(|config| config.track);
|
|
let prefix = track_config
|
|
.as_ref()
|
|
.and_then(|track| track.default_remote_prefix.as_ref());
|
|
let enable_tracking = track_config.as_ref().map_or(false, |track| track.default);
|
|
let default_remote = track_config
|
|
.as_ref()
|
|
.map(|track| track.default_remote.clone());
|
|
|
|
// Note that we have to define all variables that borrow from `repo`
|
|
// *first*, otherwise we'll receive "borrowed value does not live long
|
|
// enough" errors. This is due to the `repo` reference inside `Worktree` that is
|
|
// passed through each state type.
|
|
//
|
|
// The `commit` variable will be dropped at the end of the scope, together with all
|
|
// worktree variables. It will be done in the opposite direction of delcaration (FILO).
|
|
//
|
|
// So if we define `commit` *after* the respective worktrees, it will be dropped first while
|
|
// still being borrowed by `Worktree`.
|
|
let default_branch_head = repo.default_branch()?.commit_owned()?;
|
|
|
|
let worktree = Worktree::<Init>::new(&repo).set_local_branch_name(name);
|
|
|
|
let get_remote_head = |remote_name: &str,
|
|
remote_branch_name: &str|
|
|
-> Result<Option<Box<repo::Commit>>, String> {
|
|
if let Ok(remote_branch) = repo.find_remote_branch(remote_name, remote_branch_name) {
|
|
Ok(Some(Box::new(remote_branch.commit_owned()?)))
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
};
|
|
|
|
let worktree = if worktree.local_branch_already_exists() {
|
|
worktree.select_commit(None)
|
|
} else if let Some((remote_name, remote_branch_name)) = if no_track { None } else { track } {
|
|
if let Ok(remote_branch) = repo.find_remote_branch(remote_name, remote_branch_name) {
|
|
worktree.select_commit(Some(Box::new(remote_branch.commit_owned()?)))
|
|
} else {
|
|
worktree.select_commit(Some(Box::new(default_branch_head)))
|
|
}
|
|
} else {
|
|
match remotes.len() {
|
|
0 => worktree.select_commit(Some(Box::new(default_branch_head))),
|
|
1 => {
|
|
let remote_name = &remotes[0];
|
|
let commit: Option<Box<repo::Commit>> = ({
|
|
if let Some(prefix) = prefix {
|
|
get_remote_head(remote_name, &format!("{prefix}/{name}"))?
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.or(get_remote_head(remote_name, name)?)
|
|
.or_else(|| Some(Box::new(default_branch_head)));
|
|
|
|
worktree.select_commit(commit)
|
|
}
|
|
_ => {
|
|
let commit = if let Some(ref default_remote) = default_remote {
|
|
if let Some(ref prefix) = prefix {
|
|
if let Ok(remote_branch) = repo
|
|
.find_remote_branch(default_remote, &format!("{prefix}/{name}"))
|
|
{
|
|
Some(Box::new(remote_branch.commit_owned()?))
|
|
} else {
|
|
None
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
.or({
|
|
if let Ok(remote_branch) =
|
|
repo.find_remote_branch(default_remote, name)
|
|
{
|
|
Some(Box::new(remote_branch.commit_owned()?))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
} else {
|
|
None
|
|
}.or({
|
|
let mut commits = vec![];
|
|
for remote_name in remotes.iter() {
|
|
let remote_head: Option<Box<repo::Commit>> = ({
|
|
if let Some(ref prefix) = prefix {
|
|
if let Ok(remote_branch) = repo.find_remote_branch(
|
|
remote_name,
|
|
&format!("{prefix}/{name}"),
|
|
) {
|
|
Some(Box::new(remote_branch.commit_owned()?))
|
|
} else {
|
|
None
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.or({
|
|
if let Ok(remote_branch) =
|
|
repo.find_remote_branch(remote_name, name)
|
|
{
|
|
Some(Box::new(remote_branch.commit_owned()?))
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.or(None);
|
|
commits.push(remote_head);
|
|
}
|
|
|
|
let mut commits = commits
|
|
.into_iter()
|
|
.flatten()
|
|
// have to collect first because the `flatten()` return
|
|
// typedoes not implement `windows()`
|
|
.collect::<Vec<Box<repo::Commit>>>();
|
|
// `flatten()` takes care of `None` values here. If all
|
|
// remotes return None for the branch, we do *not* abort, we
|
|
// continue!
|
|
if commits.is_empty() {
|
|
Some(Box::new(default_branch_head))
|
|
} else if commits.len() == 1 {
|
|
Some(commits.swap_remove(0))
|
|
} else if commits.windows(2).any(|window| {
|
|
let c1 = &window[0];
|
|
let c2 = &window[1];
|
|
(*c1).id().hex_string() != (*c2).id().hex_string()
|
|
}) {
|
|
warnings.push(
|
|
// TODO this should also include the branch
|
|
// name. BUT: the branch name may be different
|
|
// between the remotes. Let's just leave it
|
|
// until I get around to fix that inconsistency
|
|
// (see module-level doc about), which might be
|
|
// never, as it's such a rare edge case.
|
|
"Branch exists on multiple remotes, but they deviate. Selecting default branch instead".to_string()
|
|
);
|
|
Some(Box::new(default_branch_head))
|
|
} else {
|
|
Some(commits.swap_remove(0))
|
|
}
|
|
});
|
|
worktree.select_commit(commit)
|
|
}
|
|
}
|
|
};
|
|
|
|
let worktree = if no_track {
|
|
worktree.set_remote_tracking_branch(None, prefix.map(|s| s.as_str()))
|
|
} else if let Some((remote_name, remote_branch_name)) = track {
|
|
worktree.set_remote_tracking_branch(
|
|
Some((remote_name, remote_branch_name)),
|
|
None, // Always disable prefixing when explicitly given --track
|
|
)
|
|
} else if !enable_tracking {
|
|
worktree.set_remote_tracking_branch(None, prefix.map(|s| s.as_str()))
|
|
} else {
|
|
match remotes.len() {
|
|
0 => worktree.set_remote_tracking_branch(None, prefix.map(|s| s.as_str())),
|
|
1 => worktree
|
|
.set_remote_tracking_branch(Some((&remotes[0], name)), prefix.map(|s| s.as_str())),
|
|
_ => {
|
|
if let Some(default_remote) = default_remote {
|
|
worktree.set_remote_tracking_branch(
|
|
Some((&default_remote, name)),
|
|
prefix.map(|s| s.as_str()),
|
|
)
|
|
} else {
|
|
worktree.set_remote_tracking_branch(None, prefix.map(|s| s.as_str()))
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
worktree.create(directory)?;
|
|
|
|
Ok(if warnings.is_empty() {
|
|
None
|
|
} else {
|
|
Some(warnings)
|
|
})
|
|
}
|