tagver 0.1.2

Core library for minimalistic versioning using Git tags
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Git test helpers for creating and manipulating test repositories

use std::path::Path;
use std::process::Command;
use tempfile::TempDir;

/// Result type for test operations
pub type TestResult<T = ()> = Result<T, Box<dyn std::error::Error>>;

/// Run a git command and check for success
pub fn run_git_command(args: &[&str], cwd: &Path) -> TestResult {
    let output = Command::new("git")
        .args(args)
        .current_dir(cwd)
        .output()
        .map_err(|e| format!("Failed to run git command: {}", e))?;

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        return Err(format!("Git command failed: {}", stderr).into());
    }

    Ok(())
}

/// Create an empty git repository and make an initial commit
#[allow(dead_code)]
pub async fn ensure_empty_repository_and_commit(path: &Path) -> TestResult {
    ensure_empty_repository(path).await?;
    commit(path).await
}

/// Create an empty git repository
pub async fn ensure_empty_repository(path: &Path) -> TestResult {
    // Create directory
    std::fs::create_dir_all(path).map_err(|e| format!("Failed to create directory: {}", e))?;

    // Initialize repository
    run_git_command(&["init", "--initial-branch=main"], path)?;

    // Configure git user
    run_git_command(&["config", "user.email", "test@example.com"], path)?;
    run_git_command(&["config", "user.name", "Test User"], path)?;
    // Disable GPG signing
    run_git_command(&["config", "commit.gpgsign", "false"], path)?;

    Ok(())
}

/// Create a commit
#[allow(dead_code)]
pub async fn commit(path: &Path) -> TestResult {
    run_git_command(&["commit", "--allow-empty", "-m", "."], path)
}

/// Create a tag
#[allow(dead_code)]
pub async fn tag(path: &Path, tag_name: &str) -> TestResult {
    run_git_command(&["tag", tag_name], path)
}

/// Create an annotated tag
#[allow(dead_code)]
pub async fn annotated_tag(path: &Path, tag_name: &str, message: &str) -> TestResult {
    run_git_command(&["tag", "-a", tag_name, "-m", message], path)
}

/// Checkout a specific commit or branch
#[allow(dead_code)]
pub async fn checkout(path: &Path, ref_name: &str) -> TestResult {
    run_git_command(&["checkout", ref_name], path)
}

/// Get all commit SHAs in the repository
#[allow(dead_code)]
pub async fn get_commit_shas(path: &Path) -> TestResult<Vec<String>> {
    let output = Command::new("git")
        .args(["log", "--pretty=format:%H"])
        .current_dir(path)
        .output()
        .map_err(|e| format!("Failed to run git log: {}", e))?;

    let stdout = String::from_utf8_lossy(&output.stdout);
    let shas: Vec<String> = stdout
        .lines()
        .filter(|line| !line.is_empty())
        .map(|line| line.to_string())
        .collect();

    Ok(shas)
}

/// Get the git graph as a string
#[allow(dead_code)]
pub async fn get_graph(path: &Path) -> TestResult<String> {
    let output = Command::new("git")
        .args(["log", "--graph", "--pretty=format:'%d'"])
        .current_dir(path)
        .output()
        .map_err(|e| format!("Failed to run git log: {}", e))?;

    let stdout = String::from_utf8_lossy(&output.stdout);
    Ok(stdout.to_string())
}

/// Create a temporary test directory with a specific name
#[allow(dead_code)]
pub fn get_test_directory(_test_name: &str) -> TempDir {
    let _run_id = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_nanos();

    tempfile::tempdir().expect("Failed to create temp directory")
}