788 lines
35 KiB
Rust
788 lines
35 KiB
Rust
#![forbid(unsafe_code)]
|
|
|
|
use std::path::Path;
|
|
use std::process;
|
|
|
|
mod cmd;
|
|
|
|
use grm::auth;
|
|
use grm::config;
|
|
use grm::find_in_tree;
|
|
use grm::output::*;
|
|
use grm::path;
|
|
use grm::provider;
|
|
use grm::provider::Provider;
|
|
use grm::repo;
|
|
use grm::table;
|
|
use grm::tree;
|
|
use grm::worktree;
|
|
|
|
fn main() {
|
|
let opts = cmd::parse();
|
|
|
|
match opts.subcmd {
|
|
cmd::SubCommand::Repos(repos) => match repos.action {
|
|
cmd::ReposAction::Sync(sync) => match sync {
|
|
cmd::SyncAction::Config(args) => {
|
|
let config = match config::read_config(&args.config) {
|
|
Ok(config) => config,
|
|
Err(error) => {
|
|
print_error(&error);
|
|
process::exit(1);
|
|
}
|
|
};
|
|
match tree::sync_trees(config, args.init_worktree == "true") {
|
|
Ok(success) => {
|
|
if !success {
|
|
process::exit(1)
|
|
}
|
|
}
|
|
Err(error) => {
|
|
print_error(&format!("Error syncing trees: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
cmd::SyncAction::Remote(args) => {
|
|
let token = match auth::get_token_from_command(&args.token_command) {
|
|
Ok(token) => token,
|
|
Err(error) => {
|
|
print_error(&format!("Getting token from command failed: {}", error));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
|
|
let filter =
|
|
provider::Filter::new(args.users, args.groups, args.owner, args.access);
|
|
|
|
let worktree = args.worktree == "true";
|
|
|
|
let repos = match args.provider {
|
|
cmd::RemoteProvider::Github => {
|
|
match provider::Github::new(filter, token, args.api_url) {
|
|
Ok(provider) => provider,
|
|
Err(error) => {
|
|
print_error(&format!("Error: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
.get_repos(
|
|
worktree,
|
|
args.force_ssh,
|
|
args.remote_name,
|
|
)
|
|
}
|
|
cmd::RemoteProvider::Gitlab => {
|
|
match provider::Gitlab::new(filter, token, args.api_url) {
|
|
Ok(provider) => provider,
|
|
Err(error) => {
|
|
print_error(&format!("Error: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
.get_repos(
|
|
worktree,
|
|
args.force_ssh,
|
|
args.remote_name,
|
|
)
|
|
}
|
|
};
|
|
|
|
match repos {
|
|
Ok(repos) => {
|
|
let mut trees: Vec<config::ConfigTree> = vec![];
|
|
|
|
for (namespace, repolist) in repos {
|
|
let root = if let Some(namespace) = namespace {
|
|
path::path_as_string(&Path::new(&args.root).join(namespace))
|
|
} else {
|
|
path::path_as_string(Path::new(&args.root))
|
|
};
|
|
|
|
let tree = config::ConfigTree::from_repos(root, repolist);
|
|
trees.push(tree);
|
|
}
|
|
|
|
let config = config::Config::from_trees(trees);
|
|
|
|
match tree::sync_trees(config, args.init_worktree == "true") {
|
|
Ok(success) => {
|
|
if !success {
|
|
process::exit(1)
|
|
}
|
|
}
|
|
Err(error) => {
|
|
print_error(&format!("Error syncing trees: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
Err(error) => {
|
|
print_error(&format!("Error: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
cmd::ReposAction::Status(args) => match &args.config {
|
|
Some(config_path) => {
|
|
let config = match config::read_config(config_path) {
|
|
Ok(config) => config,
|
|
Err(error) => {
|
|
print_error(&error);
|
|
process::exit(1);
|
|
}
|
|
};
|
|
match table::get_status_table(config) {
|
|
Ok((tables, errors)) => {
|
|
for table in tables {
|
|
println!("{}", table);
|
|
}
|
|
for error in errors {
|
|
print_error(&format!("Error: {}", error));
|
|
}
|
|
}
|
|
Err(error) => {
|
|
print_error(&format!("Error getting status: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
None => {
|
|
let dir = match std::env::current_dir() {
|
|
Ok(dir) => dir,
|
|
Err(error) => {
|
|
print_error(&format!("Could not open current directory: {}", error));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
|
|
match table::show_single_repo_status(&dir) {
|
|
Ok((table, warnings)) => {
|
|
println!("{}", table);
|
|
for warning in warnings {
|
|
print_warning(&warning);
|
|
}
|
|
}
|
|
Err(error) => {
|
|
print_error(&format!("Error getting status: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
cmd::ReposAction::Find(find) => match find {
|
|
cmd::FindAction::Local(args) => {
|
|
let path = Path::new(&args.path);
|
|
if !path.exists() {
|
|
print_error(&format!("Path \"{}\" does not exist", path.display()));
|
|
process::exit(1);
|
|
}
|
|
if !path.is_dir() {
|
|
print_error(&format!("Path \"{}\" is not a directory", path.display()));
|
|
process::exit(1);
|
|
}
|
|
|
|
let path = match path.canonicalize() {
|
|
Ok(path) => path,
|
|
Err(error) => {
|
|
print_error(&format!(
|
|
"Failed to canonicalize path \"{}\". This is a bug. Error message: {}",
|
|
&path.display(),
|
|
error
|
|
));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
|
|
let (found_repos, warnings) = match find_in_tree(&path) {
|
|
Ok((repos, warnings)) => (repos, warnings),
|
|
Err(error) => {
|
|
print_error(&error);
|
|
process::exit(1);
|
|
}
|
|
};
|
|
|
|
let trees = config::ConfigTrees::from_trees(vec![found_repos]);
|
|
if trees.trees_ref().iter().all(|t| match &t.repos {
|
|
None => false,
|
|
Some(r) => r.is_empty(),
|
|
}) {
|
|
print_warning("No repositories found");
|
|
} else {
|
|
let mut config = trees.to_config();
|
|
|
|
config.normalize();
|
|
|
|
match args.format {
|
|
cmd::ConfigFormat::Toml => {
|
|
let toml = match config.as_toml() {
|
|
Ok(toml) => toml,
|
|
Err(error) => {
|
|
print_error(&format!(
|
|
"Failed converting config to TOML: {}",
|
|
&error
|
|
));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
print!("{}", toml);
|
|
}
|
|
cmd::ConfigFormat::Yaml => {
|
|
let yaml = match config.as_yaml() {
|
|
Ok(yaml) => yaml,
|
|
Err(error) => {
|
|
print_error(&format!(
|
|
"Failed converting config to YAML: {}",
|
|
&error
|
|
));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
print!("{}", yaml);
|
|
}
|
|
}
|
|
}
|
|
for warning in warnings {
|
|
print_warning(&warning);
|
|
}
|
|
}
|
|
cmd::FindAction::Config(args) => {
|
|
let config: config::ConfigProvider = match config::read_config(&args.config) {
|
|
Ok(config) => config,
|
|
Err(error) => {
|
|
print_error(&error);
|
|
process::exit(1);
|
|
}
|
|
};
|
|
|
|
let token = match auth::get_token_from_command(&config.token_command) {
|
|
Ok(token) => token,
|
|
Err(error) => {
|
|
print_error(&format!("Getting token from command failed: {}", error));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
|
|
let filters = config.filters.unwrap_or(config::ConfigProviderFilter {
|
|
access: Some(false),
|
|
owner: Some(false),
|
|
users: Some(vec![]),
|
|
groups: Some(vec![]),
|
|
});
|
|
|
|
let filter = provider::Filter::new(
|
|
filters.users.unwrap_or_default(),
|
|
filters.groups.unwrap_or_default(),
|
|
filters.owner.unwrap_or(false),
|
|
filters.access.unwrap_or(false),
|
|
);
|
|
|
|
let repos = match config.provider {
|
|
provider::RemoteProvider::Github => {
|
|
match match provider::Github::new(filter, token, config.api_url) {
|
|
Ok(provider) => provider,
|
|
Err(error) => {
|
|
print_error(&format!("Error: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
.get_repos(
|
|
config.worktree.unwrap_or(false),
|
|
config.force_ssh.unwrap_or(false),
|
|
config.remote_name,
|
|
) {
|
|
Ok(provider) => provider,
|
|
Err(error) => {
|
|
print_error(&format!("Error: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
provider::RemoteProvider::Gitlab => {
|
|
match match provider::Gitlab::new(filter, token, config.api_url) {
|
|
Ok(provider) => provider,
|
|
Err(error) => {
|
|
print_error(&format!("Error: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
.get_repos(
|
|
config.worktree.unwrap_or(false),
|
|
config.force_ssh.unwrap_or(false),
|
|
config.remote_name,
|
|
) {
|
|
Ok(provider) => provider,
|
|
Err(error) => {
|
|
print_error(&format!("Error: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
let mut trees = vec![];
|
|
|
|
for (namespace, namespace_repos) in repos {
|
|
let tree = config::ConfigTree {
|
|
root: if let Some(namespace) = namespace {
|
|
path::path_as_string(&Path::new(&config.root).join(namespace))
|
|
} else {
|
|
path::path_as_string(Path::new(&config.root))
|
|
},
|
|
repos: Some(
|
|
namespace_repos
|
|
.into_iter()
|
|
.map(config::RepoConfig::from_repo)
|
|
.collect(),
|
|
),
|
|
};
|
|
trees.push(tree);
|
|
}
|
|
|
|
let config = config::Config::from_trees(trees);
|
|
|
|
match args.format {
|
|
cmd::ConfigFormat::Toml => {
|
|
let toml = match config.as_toml() {
|
|
Ok(toml) => toml,
|
|
Err(error) => {
|
|
print_error(&format!(
|
|
"Failed converting config to TOML: {}",
|
|
&error
|
|
));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
print!("{}", toml);
|
|
}
|
|
cmd::ConfigFormat::Yaml => {
|
|
let yaml = match config.as_yaml() {
|
|
Ok(yaml) => yaml,
|
|
Err(error) => {
|
|
print_error(&format!(
|
|
"Failed converting config to YAML: {}",
|
|
&error
|
|
));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
print!("{}", yaml);
|
|
}
|
|
}
|
|
}
|
|
cmd::FindAction::Remote(args) => {
|
|
let token = match auth::get_token_from_command(&args.token_command) {
|
|
Ok(token) => token,
|
|
Err(error) => {
|
|
print_error(&format!("Getting token from command failed: {}", error));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
|
|
let filter =
|
|
provider::Filter::new(args.users, args.groups, args.owner, args.access);
|
|
|
|
let worktree = args.worktree == "true";
|
|
|
|
let repos = match args.provider {
|
|
cmd::RemoteProvider::Github => {
|
|
match provider::Github::new(filter, token, args.api_url) {
|
|
Ok(provider) => provider,
|
|
Err(error) => {
|
|
print_error(&format!("Error: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
.get_repos(
|
|
worktree,
|
|
args.force_ssh,
|
|
args.remote_name,
|
|
)
|
|
}
|
|
cmd::RemoteProvider::Gitlab => {
|
|
match provider::Gitlab::new(filter, token, args.api_url) {
|
|
Ok(provider) => provider,
|
|
Err(error) => {
|
|
print_error(&format!("Error: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
.get_repos(
|
|
worktree,
|
|
args.force_ssh,
|
|
args.remote_name,
|
|
)
|
|
}
|
|
};
|
|
|
|
let repos = repos.unwrap_or_else(|error| {
|
|
print_error(&format!("Error: {}", error));
|
|
process::exit(1);
|
|
});
|
|
|
|
let mut trees: Vec<config::ConfigTree> = vec![];
|
|
|
|
for (namespace, repolist) in repos {
|
|
let tree = config::ConfigTree {
|
|
root: if let Some(namespace) = namespace {
|
|
path::path_as_string(&Path::new(&args.root).join(namespace))
|
|
} else {
|
|
path::path_as_string(Path::new(&args.root))
|
|
},
|
|
repos: Some(
|
|
repolist
|
|
.into_iter()
|
|
.map(config::RepoConfig::from_repo)
|
|
.collect(),
|
|
),
|
|
};
|
|
trees.push(tree);
|
|
}
|
|
|
|
let mut config = config::Config::from_trees(trees);
|
|
|
|
config.normalize();
|
|
|
|
match args.format {
|
|
cmd::ConfigFormat::Toml => {
|
|
let toml = match config.as_toml() {
|
|
Ok(toml) => toml,
|
|
Err(error) => {
|
|
print_error(&format!(
|
|
"Failed converting config to TOML: {}",
|
|
&error
|
|
));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
print!("{}", toml);
|
|
}
|
|
cmd::ConfigFormat::Yaml => {
|
|
let yaml = match config.as_yaml() {
|
|
Ok(yaml) => yaml,
|
|
Err(error) => {
|
|
print_error(&format!(
|
|
"Failed converting config to YAML: {}",
|
|
&error
|
|
));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
print!("{}", yaml);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
},
|
|
cmd::SubCommand::Worktree(args) => {
|
|
let cwd = std::env::current_dir().unwrap_or_else(|error| {
|
|
print_error(&format!("Could not open current directory: {}", error));
|
|
process::exit(1);
|
|
});
|
|
|
|
match args.action {
|
|
cmd::WorktreeAction::Add(action_args) => {
|
|
if action_args.track.is_some() && action_args.no_track {
|
|
print_warning("You are using --track and --no-track at the same time. --track will be ignored");
|
|
}
|
|
let track = match &action_args.track {
|
|
Some(branch) => {
|
|
let split = branch.split_once('/');
|
|
|
|
if split.is_none()
|
|
|| split.unwrap().0.is_empty()
|
|
|| split.unwrap().1.is_empty()
|
|
{
|
|
print_error("Tracking branch needs to match the pattern <remote>/<branch_name>");
|
|
process::exit(1);
|
|
};
|
|
|
|
// unwrap() here is safe because we checked for
|
|
// is_none() explictily before
|
|
let (remote_name, remote_branch_name) = split.unwrap();
|
|
|
|
Some((remote_name, remote_branch_name))
|
|
}
|
|
None => None,
|
|
};
|
|
|
|
match worktree::add_worktree(
|
|
&cwd,
|
|
&action_args.name,
|
|
track,
|
|
action_args.no_track,
|
|
) {
|
|
Ok(warnings) => {
|
|
if let Some(warnings) = warnings {
|
|
for warning in warnings {
|
|
print_warning(&warning);
|
|
}
|
|
}
|
|
print_success(&format!("Worktree {} created", &action_args.name));
|
|
}
|
|
Err(error) => {
|
|
print_error(&format!("Error creating worktree: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
cmd::WorktreeAction::Delete(action_args) => {
|
|
let worktree_config = match repo::read_worktree_root_config(&cwd) {
|
|
Ok(config) => config,
|
|
Err(error) => {
|
|
print_error(&format!(
|
|
"Error getting worktree configuration: {}",
|
|
error
|
|
));
|
|
process::exit(1);
|
|
}
|
|
};
|
|
|
|
let repo = repo::RepoHandle::open(&cwd, true).unwrap_or_else(|error| {
|
|
print_error(&format!("Error opening repository: {}", error));
|
|
process::exit(1);
|
|
});
|
|
|
|
match repo.remove_worktree(
|
|
&cwd,
|
|
&action_args.name,
|
|
Path::new(&action_args.name),
|
|
action_args.force,
|
|
&worktree_config,
|
|
) {
|
|
Ok(_) => print_success(&format!("Worktree {} deleted", &action_args.name)),
|
|
Err(error) => {
|
|
match error {
|
|
repo::WorktreeRemoveFailureReason::Error(msg) => {
|
|
print_error(&msg);
|
|
process::exit(1);
|
|
}
|
|
repo::WorktreeRemoveFailureReason::Changes(changes) => {
|
|
print_warning(&format!(
|
|
"Changes in worktree: {}. Refusing to delete",
|
|
changes
|
|
));
|
|
}
|
|
repo::WorktreeRemoveFailureReason::NotMerged(message) => {
|
|
print_warning(&message);
|
|
}
|
|
}
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
cmd::WorktreeAction::Status(_args) => {
|
|
let repo = repo::RepoHandle::open(&cwd, true).unwrap_or_else(|error| {
|
|
print_error(&format!("Error opening repository: {}", error));
|
|
process::exit(1);
|
|
});
|
|
|
|
match table::get_worktree_status_table(&repo, &cwd) {
|
|
Ok((table, errors)) => {
|
|
println!("{}", table);
|
|
for error in errors {
|
|
print_error(&format!("Error: {}", error));
|
|
}
|
|
}
|
|
Err(error) => {
|
|
print_error(&format!("Error getting status: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
cmd::WorktreeAction::Convert(_args) => {
|
|
// Converting works like this:
|
|
// * Check whether there are uncommitted/unpushed changes
|
|
// * Move the contents of .git dir to the worktree directory
|
|
// * Remove all files
|
|
// * Set `core.bare` to `true`
|
|
|
|
let repo = repo::RepoHandle::open(&cwd, false).unwrap_or_else(|error| {
|
|
if error.kind == repo::RepoErrorKind::NotFound {
|
|
print_error("Directory does not contain a git repository");
|
|
} else {
|
|
print_error(&format!("Opening repository failed: {}", error));
|
|
}
|
|
process::exit(1);
|
|
});
|
|
|
|
match repo.convert_to_worktree(&cwd) {
|
|
Ok(_) => print_success("Conversion done"),
|
|
Err(reason) => {
|
|
match reason {
|
|
repo::WorktreeConversionFailureReason::Changes => {
|
|
print_error("Changes found in repository, refusing to convert");
|
|
}
|
|
repo::WorktreeConversionFailureReason::Ignored => {
|
|
print_error("Ignored files found in repository, refusing to convert. Run git clean -f -d -X to remove them manually.");
|
|
}
|
|
repo::WorktreeConversionFailureReason::Error(error) => {
|
|
print_error(&format!("Error during conversion: {}", error));
|
|
}
|
|
}
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
cmd::WorktreeAction::Clean(_args) => {
|
|
let repo = repo::RepoHandle::open(&cwd, true).unwrap_or_else(|error| {
|
|
if error.kind == repo::RepoErrorKind::NotFound {
|
|
print_error("Directory does not contain a git repository");
|
|
} else {
|
|
print_error(&format!("Opening repository failed: {}", error));
|
|
}
|
|
process::exit(1);
|
|
});
|
|
|
|
match repo.cleanup_worktrees(&cwd) {
|
|
Ok(warnings) => {
|
|
for warning in warnings {
|
|
print_warning(&warning);
|
|
}
|
|
}
|
|
Err(error) => {
|
|
print_error(&format!("Worktree cleanup failed: {}", error));
|
|
process::exit(1);
|
|
}
|
|
}
|
|
|
|
for unmanaged_worktree in
|
|
repo.find_unmanaged_worktrees(&cwd).unwrap_or_else(|error| {
|
|
print_error(&format!("Failed finding unmanaged worktrees: {}", error));
|
|
process::exit(1);
|
|
})
|
|
{
|
|
print_warning(&format!(
|
|
"Found {}, which is not a valid worktree directory!",
|
|
&unmanaged_worktree
|
|
));
|
|
}
|
|
}
|
|
cmd::WorktreeAction::Fetch(_args) => {
|
|
let repo = repo::RepoHandle::open(&cwd, true).unwrap_or_else(|error| {
|
|
if error.kind == repo::RepoErrorKind::NotFound {
|
|
print_error("Directory does not contain a git repository");
|
|
} else {
|
|
print_error(&format!("Opening repository failed: {}", error));
|
|
}
|
|
process::exit(1);
|
|
});
|
|
|
|
repo.fetchall().unwrap_or_else(|error| {
|
|
print_error(&format!("Error fetching remotes: {}", error));
|
|
process::exit(1);
|
|
});
|
|
print_success("Fetched from all remotes");
|
|
}
|
|
cmd::WorktreeAction::Pull(args) => {
|
|
let repo = repo::RepoHandle::open(&cwd, true).unwrap_or_else(|error| {
|
|
if error.kind == repo::RepoErrorKind::NotFound {
|
|
print_error("Directory does not contain a git repository");
|
|
} else {
|
|
print_error(&format!("Opening repository failed: {}", error));
|
|
}
|
|
process::exit(1);
|
|
});
|
|
|
|
repo.fetchall().unwrap_or_else(|error| {
|
|
print_error(&format!("Error fetching remotes: {}", error));
|
|
process::exit(1);
|
|
});
|
|
|
|
let mut failures = false;
|
|
for worktree in repo.get_worktrees().unwrap_or_else(|error| {
|
|
print_error(&format!("Error getting worktrees: {}", error));
|
|
process::exit(1);
|
|
}) {
|
|
if let Some(warning) = worktree
|
|
.forward_branch(args.rebase, args.stash)
|
|
.unwrap_or_else(|error| {
|
|
print_error(&format!("Error updating worktree branch: {}", error));
|
|
process::exit(1);
|
|
})
|
|
{
|
|
print_warning(&format!("{}: {}", worktree.name(), warning));
|
|
failures = true;
|
|
} else {
|
|
print_success(&format!("{}: Done", worktree.name()));
|
|
}
|
|
}
|
|
if failures {
|
|
process::exit(1);
|
|
}
|
|
}
|
|
cmd::WorktreeAction::Rebase(args) => {
|
|
if args.rebase && !args.pull {
|
|
print_error("There is no point in using --rebase without --pull");
|
|
process::exit(1);
|
|
}
|
|
let repo = repo::RepoHandle::open(&cwd, true).unwrap_or_else(|error| {
|
|
if error.kind == repo::RepoErrorKind::NotFound {
|
|
print_error("Directory does not contain a git repository");
|
|
} else {
|
|
print_error(&format!("Opening repository failed: {}", error));
|
|
}
|
|
process::exit(1);
|
|
});
|
|
|
|
if args.pull {
|
|
repo.fetchall().unwrap_or_else(|error| {
|
|
print_error(&format!("Error fetching remotes: {}", error));
|
|
process::exit(1);
|
|
});
|
|
}
|
|
|
|
let config = repo::read_worktree_root_config(&cwd).unwrap_or_else(|error| {
|
|
print_error(&format!("Failed to read worktree configuration: {}", error));
|
|
process::exit(1);
|
|
});
|
|
|
|
let worktrees = repo.get_worktrees().unwrap_or_else(|error| {
|
|
print_error(&format!("Error getting worktrees: {}", error));
|
|
process::exit(1);
|
|
});
|
|
|
|
let mut failures = false;
|
|
|
|
for worktree in &worktrees {
|
|
if args.pull {
|
|
if let Some(warning) = worktree
|
|
.forward_branch(args.rebase, args.stash)
|
|
.unwrap_or_else(|error| {
|
|
print_error(&format!(
|
|
"Error updating worktree branch: {}",
|
|
error
|
|
));
|
|
process::exit(1);
|
|
})
|
|
{
|
|
failures = true;
|
|
print_warning(&format!("{}: {}", worktree.name(), warning));
|
|
}
|
|
}
|
|
}
|
|
|
|
for worktree in &worktrees {
|
|
if let Some(warning) = worktree
|
|
.rebase_onto_default(&config, args.stash)
|
|
.unwrap_or_else(|error| {
|
|
print_error(&format!("Error rebasing worktree branch: {}", error));
|
|
process::exit(1);
|
|
})
|
|
{
|
|
failures = true;
|
|
print_warning(&format!("{}: {}", worktree.name(), warning));
|
|
} else {
|
|
print_success(&format!("{}: Done", worktree.name()));
|
|
}
|
|
}
|
|
if failures {
|
|
process::exit(1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|