From fb5dc9c18891e2016823d19029e89dc82b8e8158 Mon Sep 17 00:00:00 2001 From: Ed Page Date: Fri, 8 Oct 2021 11:45:29 -0500 Subject: [PATCH] fix!: Rename `git-branch-backup` to `git-branch-stash` This framing helps clarify how someone is intended to use the command, which makes sense considering it was modeled after `git stash`. --- .../args.rs | 40 ++++++------- .../main.rs | 58 ++++++++++--------- src/bin/git-stack/stack.rs | 20 +++---- src/config.rs | 2 +- src/lib.rs | 2 +- src/{backup => stash}/mod.rs | 4 +- src/{backup/backup.rs => stash/snapshot.rs} | 4 +- src/{backup => stash}/stack.rs | 26 ++++----- 8 files changed, 80 insertions(+), 76 deletions(-) rename src/bin/{git-branch-backup => git-branch-stash}/args.rs (59%) rename src/bin/{git-branch-backup => git-branch-stash}/main.rs (81%) rename src/{backup => stash}/mod.rs (65%) rename src/{backup/backup.rs => stash/snapshot.rs} (99%) rename src/{backup => stash}/stack.rs (82%) diff --git a/src/bin/git-branch-backup/args.rs b/src/bin/git-branch-stash/args.rs similarity index 59% rename from src/bin/git-branch-backup/args.rs rename to src/bin/git-branch-stash/args.rs index 4c05ba4..d98fbf5 100644 --- a/src/bin/git-branch-backup/args.rs +++ b/src/bin/git-branch-stash/args.rs @@ -21,65 +21,65 @@ pub struct Args { #[derive(structopt::StructOpt)] pub enum Subcommand { - /// Backup all branches + /// Stash all branches Push(PushArgs), - /// List all backups + /// List all stashed snapshots List(ListArgs), - /// Clear all backups + /// Clear all snapshots Clear(ClearArgs), - /// Delete the last backup + /// Delete the last snapshot Drop(DropArgs), - /// Apply the last backup, deleting it + /// Apply the last snapshot, deleting it Pop(PopArgs), - /// Apply the last backup + /// Apply the last snapshot Apply(ApplyArgs), - /// List all backup stacks + /// List all snapshot stacks Stacks(StacksArgs), } #[derive(structopt::StructOpt)] pub struct PushArgs { - /// Specify which backup stack to use - #[structopt(default_value = git_stack::backup::Stack::DEFAULT_STACK)] + /// Specify which stash stack to use + #[structopt(default_value = git_stack::stash::Stack::DEFAULT_STACK)] pub stack: String, - /// Annotate the backup with the given message + /// Annotate the snapshot with the given message #[structopt(short, long)] pub message: Option, } #[derive(structopt::StructOpt)] pub struct ListArgs { - /// Specify which backup stack to use - #[structopt(default_value = git_stack::backup::Stack::DEFAULT_STACK)] + /// Specify which stash stack to use + #[structopt(default_value = git_stack::stash::Stack::DEFAULT_STACK)] pub stack: String, } #[derive(structopt::StructOpt)] pub struct ClearArgs { - /// Specify which backup stack to use - #[structopt(default_value = git_stack::backup::Stack::DEFAULT_STACK)] + /// Specify which stash stack to use + #[structopt(default_value = git_stack::stash::Stack::DEFAULT_STACK)] pub stack: String, } #[derive(structopt::StructOpt)] pub struct DropArgs { - /// Specify which backup stack to use - #[structopt(default_value = git_stack::backup::Stack::DEFAULT_STACK)] + /// Specify which stash stack to use + #[structopt(default_value = git_stack::stash::Stack::DEFAULT_STACK)] pub stack: String, } #[derive(structopt::StructOpt)] pub struct PopArgs { - /// Specify which backup stack to use - #[structopt(default_value = git_stack::backup::Stack::DEFAULT_STACK)] + /// Specify which stash stack to use + #[structopt(default_value = git_stack::stash::Stack::DEFAULT_STACK)] pub stack: String, } #[derive(structopt::StructOpt)] pub struct ApplyArgs { - /// Specify which backup stack to use - #[structopt(default_value = git_stack::backup::Stack::DEFAULT_STACK)] + /// Specify which stash stack to use + #[structopt(default_value = git_stack::stash::Stack::DEFAULT_STACK)] pub stack: String, } diff --git a/src/bin/git-branch-backup/main.rs b/src/bin/git-branch-stash/main.rs similarity index 81% rename from src/bin/git-branch-backup/main.rs rename to src/bin/git-branch-stash/main.rs index 32e0c59..6c27012 100644 --- a/src/bin/git-branch-backup/main.rs +++ b/src/bin/git-branch-stash/main.rs @@ -49,7 +49,7 @@ fn push(args: args::PushArgs) -> proc_exit::ExitResult { let cwd = std::env::current_dir().with_code(proc_exit::Code::USAGE_ERR)?; let repo = git2::Repository::discover(&cwd).with_code(proc_exit::Code::USAGE_ERR)?; let repo = git_stack::git::GitRepo::new(repo); - let mut stack = git_stack::backup::Stack::new(&args.stack, &repo); + let mut stack = git_stack::stash::Stack::new(&args.stack, &repo); let repo_config = git_stack::config::RepoConfig::from_all(repo.raw()) .with_code(proc_exit::Code::CONFIG_ERR)?; @@ -66,13 +66,13 @@ fn push(args: args::PushArgs) -> proc_exit::ExitResult { log::warn!("Working tree is dirty, only capturing committed changes"); } - let mut backup = - git_stack::backup::Backup::from_repo(&repo).with_code(proc_exit::Code::FAILURE)?; + let mut snapshot = + git_stack::stash::Snapshot::from_repo(&repo).with_code(proc_exit::Code::FAILURE)?; if let Some(message) = args.message.as_deref() { - backup.insert_message(message); + snapshot.insert_message(message); } - backup.insert_parent(&repo, &branches, &protected_branches); - stack.push(backup)?; + snapshot.insert_parent(&repo, &branches, &protected_branches); + stack.push(snapshot)?; Ok(()) } @@ -87,23 +87,27 @@ fn list(args: args::ListArgs, colored: bool) -> proc_exit::ExitResult { let cwd = std::env::current_dir().with_code(proc_exit::Code::USAGE_ERR)?; let repo = git2::Repository::discover(&cwd).with_code(proc_exit::Code::USAGE_ERR)?; let repo = git_stack::git::GitRepo::new(repo); - let stack = git_stack::backup::Stack::new(&args.stack, &repo); + let stack = git_stack::stash::Stack::new(&args.stack, &repo); - let backups: Vec<_> = stack.iter().collect(); - for (i, backup_path) in backups.iter().enumerate() { - let style = if i < backups.len() - 1 { + let snapshots: Vec<_> = stack.iter().collect(); + for (i, snapshot_path) in snapshots.iter().enumerate() { + let style = if i < snapshots.len() - 1 { palette.info } else { palette.good }; - let backup = match git_stack::backup::Backup::load(backup_path) { - Ok(backup) => backup, + let snapshot = match git_stack::stash::Snapshot::load(snapshot_path) { + Ok(snapshot) => snapshot, Err(err) => { - log::error!("Failed to load backup {}: {}", backup_path.display(), err); + log::error!( + "Failed to load snapshot {}: {}", + snapshot_path.display(), + err + ); continue; } }; - match backup.metadata.get("message") { + match snapshot.metadata.get("message") { Some(message) => { writeln!( std::io::stdout(), @@ -115,11 +119,11 @@ fn list(args: args::ListArgs, colored: bool) -> proc_exit::ExitResult { writeln!( std::io::stdout(), "{}", - style.paint(format_args!("Path: {}", backup_path.display())) + style.paint(format_args!("Path: {}", snapshot_path.display())) )?; } } - for branch in backup.branches.iter() { + for branch in snapshot.branches.iter() { let summary = if let Some(summary) = branch.metadata.get("summary") { summary.to_string() } else { @@ -177,7 +181,7 @@ fn clear(args: args::ClearArgs) -> proc_exit::ExitResult { let cwd = std::env::current_dir().with_code(proc_exit::Code::USAGE_ERR)?; let repo = git2::Repository::discover(&cwd).with_code(proc_exit::Code::USAGE_ERR)?; let repo = git_stack::git::GitRepo::new(repo); - let mut stack = git_stack::backup::Stack::new(&args.stack, &repo); + let mut stack = git_stack::stash::Stack::new(&args.stack, &repo); stack.clear(); @@ -188,7 +192,7 @@ fn drop(args: args::DropArgs) -> proc_exit::ExitResult { let cwd = std::env::current_dir().with_code(proc_exit::Code::USAGE_ERR)?; let repo = git2::Repository::discover(&cwd).with_code(proc_exit::Code::USAGE_ERR)?; let repo = git_stack::git::GitRepo::new(repo); - let mut stack = git_stack::backup::Stack::new(&args.stack, &repo); + let mut stack = git_stack::stash::Stack::new(&args.stack, &repo); stack.pop(); @@ -199,7 +203,7 @@ fn pop(args: args::PopArgs) -> proc_exit::ExitResult { let cwd = std::env::current_dir().with_code(proc_exit::Code::USAGE_ERR)?; let repo = git2::Repository::discover(&cwd).with_code(proc_exit::Code::USAGE_ERR)?; let mut repo = git_stack::git::GitRepo::new(repo); - let mut stack = git_stack::backup::Stack::new(&args.stack, &repo); + let mut stack = git_stack::stash::Stack::new(&args.stack, &repo); if repo.is_dirty() { return Err(proc_exit::Code::USAGE_ERR.with_message("Working tree is dirty, aborting")); @@ -207,9 +211,9 @@ fn pop(args: args::PopArgs) -> proc_exit::ExitResult { match stack.peek() { Some(last) => { - let backup = - git_stack::backup::Backup::load(&last).with_code(proc_exit::Code::FAILURE)?; - backup + let snapshot = + git_stack::stash::Snapshot::load(&last).with_code(proc_exit::Code::FAILURE)?; + snapshot .apply(&mut repo) .with_code(proc_exit::Code::FAILURE)?; let _ = std::fs::remove_file(&last); @@ -226,7 +230,7 @@ fn apply(args: args::ApplyArgs) -> proc_exit::ExitResult { let cwd = std::env::current_dir().with_code(proc_exit::Code::USAGE_ERR)?; let repo = git2::Repository::discover(&cwd).with_code(proc_exit::Code::USAGE_ERR)?; let mut repo = git_stack::git::GitRepo::new(repo); - let mut stack = git_stack::backup::Stack::new(&args.stack, &repo); + let mut stack = git_stack::stash::Stack::new(&args.stack, &repo); if repo.is_dirty() { return Err(proc_exit::Code::USAGE_ERR.with_message("Working tree is dirty, aborting")); @@ -234,9 +238,9 @@ fn apply(args: args::ApplyArgs) -> proc_exit::ExitResult { match stack.peek() { Some(last) => { - let backup = - git_stack::backup::Backup::load(&last).with_code(proc_exit::Code::FAILURE)?; - backup + let snapshot = + git_stack::stash::Snapshot::load(&last).with_code(proc_exit::Code::FAILURE)?; + snapshot .apply(&mut repo) .with_code(proc_exit::Code::FAILURE)?; } @@ -253,7 +257,7 @@ fn stacks(_args: args::StacksArgs) -> proc_exit::ExitResult { let repo = git2::Repository::discover(&cwd).with_code(proc_exit::Code::USAGE_ERR)?; let repo = git_stack::git::GitRepo::new(repo); - for stack in git_stack::backup::Stack::all(&repo) { + for stack in git_stack::stash::Stack::all(&repo) { writeln!(std::io::stdout(), "{}", stack.name)?; } diff --git a/src/bin/git-stack/stack.rs b/src/bin/git-stack/stack.rs index 4801494..a31d8b7 100644 --- a/src/bin/git-stack/stack.rs +++ b/src/bin/git-stack/stack.rs @@ -17,7 +17,7 @@ struct State { pull: bool, push: bool, dry_run: bool, - backup_capacity: Option, + snapshot_capacity: Option, show_format: git_stack::config::Format, show_stacked: bool, @@ -44,7 +44,7 @@ impl State { ) .with_code(proc_exit::Code::CONFIG_ERR)?; let dry_run = args.dry_run; - let backup_capacity = repo_config.capacity(); + let snapshot_capacity = repo_config.capacity(); let show_format = repo_config.show_format(); let show_stacked = repo_config.show_stacked(); @@ -156,7 +156,7 @@ impl State { pull, push, dry_run, - backup_capacity, + snapshot_capacity, show_format, show_stacked, @@ -272,7 +272,7 @@ pub fn stack(args: &crate::args::Args, colored_stdout: bool) -> proc_exit::ExitR } } - const BACKUP_NAME: &str = "git-stack"; + const STASH_STACK_NAME: &str = "git-stack"; let mut success = true; let mut backed_up = false; if state.rebase { @@ -280,13 +280,13 @@ pub fn stack(args: &crate::args::Args, colored_stdout: bool) -> proc_exit::ExitR return Err(proc_exit::Code::USAGE_ERR.with_message("Working tree is dirty, aborting")); } - let mut backups = git_stack::backup::Stack::new(BACKUP_NAME, &state.repo); - backups.capacity(state.backup_capacity); - let mut backup = git_stack::backup::Backup::from_repo(&state.repo) + let mut snapshots = git_stack::stash::Stack::new(STASH_STACK_NAME, &state.repo); + snapshots.capacity(state.snapshot_capacity); + let mut snapshot = git_stack::stash::Snapshot::from_repo(&state.repo) .with_code(proc_exit::Code::FAILURE)?; - backup.insert_parent(&state.repo, &state.branches, &state.protected_branches); + snapshot.insert_parent(&state.repo, &state.branches, &state.protected_branches); if !state.dry_run { - backups.push(backup)?; + snapshots.push(snapshot)?; backed_up = true; } @@ -328,7 +328,7 @@ pub fn stack(args: &crate::args::Args, colored_stdout: bool) -> proc_exit::ExitR show(&state, colored_stdout).with_code(proc_exit::Code::FAILURE)?; if backed_up { - log::info!("To undo, run `git branch-backup pop {}`", BACKUP_NAME); + log::info!("To undo, run `git branch-stash pop {}`", STASH_STACK_NAME); } if !success { diff --git a/src/config.rs b/src/config.rs index 9b6aeb7..94d885b 100644 --- a/src/config.rs +++ b/src/config.rs @@ -19,7 +19,7 @@ static PUSH_REMOTE_FIELD: &str = "stack.push-remote"; static PULL_REMOTE_FIELD: &str = "stack.pull-remote"; static FORMAT_FIELD: &str = "stack.show-format"; static STACKED_FIELD: &str = "stack.show-stacked"; -static BACKUP_CAPACITY_FIELD: &str = "branch-backup.capacity"; +static BACKUP_CAPACITY_FIELD: &str = "branch-stash.capacity"; static DEFAULT_PROTECTED_BRANCHES: [&str; 4] = ["main", "master", "dev", "stable"]; const DEFAULT_CAPACITY: usize = 30; diff --git a/src/lib.rs b/src/lib.rs index 7262174..cbfc191 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -3,8 +3,8 @@ #[macro_use] extern crate clap; -pub mod backup; pub mod config; pub mod git; pub mod graph; pub mod log; +pub mod stash; diff --git a/src/backup/mod.rs b/src/stash/mod.rs similarity index 65% rename from src/backup/mod.rs rename to src/stash/mod.rs index a036918..6e0c9e8 100644 --- a/src/backup/mod.rs +++ b/src/stash/mod.rs @@ -1,6 +1,6 @@ #[allow(clippy::module_inception)] -mod backup; +mod snapshot; mod stack; -pub use backup::*; +pub use snapshot::*; pub use stack::*; diff --git a/src/backup/backup.rs b/src/stash/snapshot.rs similarity index 99% rename from src/backup/backup.rs rename to src/stash/snapshot.rs index 052d56a..8cb003a 100644 --- a/src/backup/backup.rs +++ b/src/stash/snapshot.rs @@ -1,12 +1,12 @@ #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)] -pub struct Backup { +pub struct Snapshot { pub branches: Vec, #[serde(default)] #[serde(skip_serializing_if = "std::collections::BTreeMap::is_empty")] pub metadata: std::collections::BTreeMap, } -impl Backup { +impl Snapshot { pub fn load(path: &std::path::Path) -> Result { let file = std::fs::File::open(path)?; let reader = std::io::BufReader::new(file); diff --git a/src/backup/stack.rs b/src/stash/stack.rs similarity index 82% rename from src/backup/stack.rs rename to src/stash/stack.rs index 178b66b..7fa8b58 100644 --- a/src/backup/stack.rs +++ b/src/stash/stack.rs @@ -1,4 +1,4 @@ -pub use super::Backup; +pub use super::Snapshot; #[derive(Clone, Debug, PartialEq, Eq)] pub struct Stack { @@ -66,7 +66,7 @@ impl Stack { elements.into_iter().map(|(_, p)| p) } - pub fn push(&mut self, backup: Backup) -> Result { + pub fn push(&mut self, snapshot: Snapshot) -> Result { let elems: Vec<_> = self.iter().collect(); let last_path = elems.iter().last(); let next_index = match last_path { @@ -82,28 +82,28 @@ impl Stack { } None => 0, }; - let last = last_path.as_deref().and_then(|p| Backup::load(p).ok()); - if last.as_ref() == Some(&backup) { + let last = last_path.as_deref().and_then(|p| Snapshot::load(p).ok()); + if last.as_ref() == Some(&snapshot) { let last_path = last_path.unwrap().to_owned(); - log::trace!("Reusing backup {}", last_path.display()); + log::trace!("Reusing snapshot {}", last_path.display()); return Ok(last_path); } std::fs::create_dir_all(&self.root)?; let new_path = self.root.join(format!("{}.{}", next_index, Self::EXT)); - backup.save(&new_path)?; + snapshot.save(&new_path)?; log::trace!("Backed up as {}", new_path.display()); if let Some(capacity) = self.capacity { let len = elems.len(); if capacity < len { let remove = len - capacity; - log::warn!("Too many backups, clearing {} oldest", remove); - for backup_path in &elems[0..remove] { - if let Err(err) = std::fs::remove_file(&backup_path) { - log::trace!("Failed to remove {}: {}", backup_path.display(), err); + log::warn!("Too many snapshots, clearing {} oldest", remove); + for snapshot_path in &elems[0..remove] { + if let Err(err) = std::fs::remove_file(&snapshot_path) { + log::trace!("Failed to remove {}: {}", snapshot_path.display(), err); } else { - log::trace!("Removed {}", backup_path.display()); + log::trace!("Removed {}", snapshot_path.display()); } } } @@ -129,9 +129,9 @@ impl Stack { } fn stacks_root(repo: &std::path::Path) -> std::path::PathBuf { - repo.join("branch-backup") + repo.join("branch-stash") } fn stack_root(repo: &std::path::Path, stack: &str) -> std::path::PathBuf { - repo.join("branch-backup").join(stack) + repo.join("branch-stash").join(stack) }