gitr 0.4.0

Async typed git CLI wrapper for agents and automation.
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
116
117
118
119
120
121
122
123
124
125
126

use criterion::{criterion_group, criterion_main, Criterion};
use gitr::Repository;
use std::process::Command;
use tempfile::TempDir;

fn setup_repo() -> TempDir {
    let tmp = tempfile::tempdir().unwrap();
    let dir = tmp.path();
    Command::new("git")
        .args(["init"])
        .current_dir(dir)
        .status()
        .unwrap();
    Command::new("git")
        .args(["config", "user.email", "bench@test.com"])
        .current_dir(dir)
        .status()
        .unwrap();
    Command::new("git")
        .args(["config", "user.name", "Bench"])
        .current_dir(dir)
        .status()
        .unwrap();
    std::fs::write(dir.join("file.txt"), "hello").unwrap();
    Command::new("git")
        .args(["add", "."])
        .current_dir(dir)
        .status()
        .unwrap();
    Command::new("git")
        .args(["commit", "-m", "init"])
        .current_dir(dir)
        .status()
        .unwrap();
    tmp
}

fn bench_status(c: &mut Criterion) {
    let tmp = setup_repo();
    let dir = tmp.path().to_str().unwrap();

    let rt = tokio::runtime::Runtime::new().unwrap();
    let repo = rt.block_on(async { Repository::open(dir).await.unwrap() });

    let mut group = c.benchmark_group("status");
    group.bench_function("gitr", |b| {
        b.to_async(&rt)
            .iter(|| async { repo.status().await.unwrap() })
    });
    group.bench_function("subprocess", |b| {
        b.iter(|| {
            Command::new("git")
                .args(["status", "--porcelain"])
                .current_dir(dir)
                .output()
                .unwrap()
        })
    });
    group.finish();
}

fn bench_current_branch(c: &mut Criterion) {
    let tmp = setup_repo();
    let dir = tmp.path().to_str().unwrap();

    let rt = tokio::runtime::Runtime::new().unwrap();
    let repo = rt.block_on(async { Repository::open(dir).await.unwrap() });

    let mut group = c.benchmark_group("current_branch");
    group.bench_function("gitr", |b| {
        b.to_async(&rt)
            .iter(|| async { repo.current_branch().await.unwrap() })
    });
    group.bench_function("subprocess", |b| {
        b.iter(|| {
            Command::new("git")
                .args(["rev-parse", "--abbrev-ref", "HEAD"])
                .current_dir(dir)
                .output()
                .unwrap()
        })
    });
    group.finish();
}

fn bench_log(c: &mut Criterion) {
    let tmp = setup_repo();
    let dir = tmp.path().to_str().unwrap();

    // create 50 commits
    for i in 0..50 {
        std::fs::write(tmp.path().join("file.txt"), format!("hello {i}")).unwrap();
        Command::new("git")
            .args(["add", "."])
            .current_dir(dir)
            .status()
            .unwrap();
        Command::new("git")
            .args(["commit", "-m", &format!("commit {i}")])
            .current_dir(dir)
            .status()
            .unwrap();
    }

    let rt = tokio::runtime::Runtime::new().unwrap();
    let repo = rt.block_on(async { Repository::open(dir).await.unwrap() });

    let mut group = c.benchmark_group("log_50_commits");
    group.bench_function("gitr", |b| {
        b.to_async(&rt)
            .iter(|| async { repo.log(Some(50)).await.unwrap() })
    });
    group.bench_function("subprocess", |b| {
        b.iter(|| {
            Command::new("git")
                .args(["log", "-n", "50", "--format=%H|%s|%an|%at"])
                .current_dir(dir)
                .output()
                .unwrap()
        })
    });
    group.finish();
}

criterion_group!(benches, bench_status, bench_current_branch, bench_log);
criterion_main!(benches);