bumpversion 0.0.9

Update all version strings in your project and optionally commit and tag the changes
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use crate::{command::run_command, vcs::VersionControlSystem};
use async_process::Command;
use color_eyre::eyre;
use std::path::Path;
use tempfile::TempDir;

fn random_string_of_length(length: usize) -> String {
    use rand::{Rng, distr::Alphanumeric};
    rand::rng()
        .sample_iter(&Alphanumeric)
        .take(length)
        .map(char::from)
        .collect()
}

/// An ephemeral repository that wraps a VCS.
///
/// Used for testing purposes.
pub(crate) struct EphemeralRepository<VCS> {
    inner: VCS,
    dir: TempDir,
}

impl<VCS> EphemeralRepository<VCS> {
    pub(crate) fn path(&self) -> &Path {
        self.dir.path()
    }
}

impl<VCS> EphemeralRepository<VCS>
where
    VCS: VersionControlSystem,
{
    pub(crate) async fn new() -> eyre::Result<Self> {
        Self::with_name(&random_string_of_length(10)).await
    }

    pub(crate) async fn with_name(name: &str) -> eyre::Result<Self> {
        let dir = TempDir::with_prefix(name)?;
        Self::init(dir.path()).await?;
        let inner = VCS::open(dir.path())?;
        Ok(Self { inner, dir })
    }

    async fn init(path: &Path) -> eyre::Result<()> {
        tokio::fs::create_dir_all(path).await?;
        let mut cmd = Command::new("git");
        cmd.args(["init"]);
        cmd.current_dir(path);
        let _ = run_command(&mut cmd).await?;
        Ok(())
    }

    // async fn add(&self, files: &[impl AsRef<Path>]) -> eyre::Result<()> {
    //     let files = files
    //         .iter()
    //         .map(|f| f.as_ref().to_string_lossy().to_string());
    //     let mut cmd = Command::new("git");
    //     cmd.arg("add");
    //     cmd.args(files);
    //     cmd.current_dir(self.path());
    //     let _ = run_command(&mut cmd).await?;
    //     Ok(())
    // }
}

impl<VCS> std::ops::Deref for EphemeralRepository<VCS> {
    type Target = VCS;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}