girt 0.18.0

An incremental, idiomatic Rust implementation of Git
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

//! Compare explicit tree IDs: `cargo run --example compare_trees -- REPO OLD NEW`.
//! Use `-` for either empty side. Without arguments, compare two disposable sample trees.
use std::path::PathBuf;
use std::str::FromStr;

use clap::Parser;
use girt::display::quote_path;
use girt::{EntryMode, InitKind, ObjectId, Repository, Tree, TreeEntry, TreeValue};

/// One side of a comparison: a tree ID, or `-` for an empty side.
#[derive(Clone, Copy, Debug)]
struct Side(Option<ObjectId>);

impl FromStr for Side {
    type Err = girt::ParseObjectIdError;

    fn from_str(text: &str) -> Result<Self, Self::Err> {
        if text == "-" {
            return Ok(Self(None));
        }
        let id = text.parse()?;
        Ok(Self(Some(id)))
    }
}

#[derive(Parser)]
#[command(about, long_about = None)]
struct Args {
    /// Repository to open. Omit all arguments to compare two disposable sample trees.
    #[arg(requires = "old", requires = "new")]
    repo: Option<PathBuf>,
    /// Old tree ID, or `-` for an empty side.
    old: Option<Side>,
    /// New tree ID, or `-` for an empty side.
    new: Option<Side>,
}

fn main() -> girt::Result<()> {
    let args = Args::parse();
    let temporary;
    let (repo, old, new) =
        if let (Some(path), Some(old), Some(new)) = (args.repo, args.old, args.new) {
            (Repository::open(path)?, old.0, new.0)
        } else {
            temporary = tempfile::tempdir()?;
            let repo = Repository::init(
                girt::ObjectFormat::Sha1,
                temporary.path().join("sample"),
                InitKind::Bare,
            )?;

            let store = repo.loose_objects();
            let old_blob = store.write_blob(b"hello\n")?;
            let new_blob = store.write_blob(b"hello, trees\n")?;

            let old = store.write_tree(&Tree::new(
                girt::ObjectFormat::Sha1,
                vec![TreeEntry {
                    name: b"hello.txt".to_vec(),
                    mode: EntryMode::Blob,
                    id: old_blob,
                }],
            )?)?;
            let new = store.write_tree(&Tree::new(
                girt::ObjectFormat::Sha1,
                vec![TreeEntry {
                    name: b"hello.txt".to_vec(),
                    mode: EntryMode::Executable,
                    id: new_blob,
                }],
            )?)?;

            (repo, Some(old), Some(new))
        };

    let objects = repo.objects()?;
    let changes = objects.compare_trees(old, new)?;

    for change in changes {
        // Git's quoting keeps non-UTF-8 names and control bytes distinguishable on a terminal.
        println!(
            "{} {}: {} -> {}",
            change.status().letter(),
            quote_path(&change.path),
            describe(change.old),
            describe(change.new)
        );
    }

    Ok(())
}

fn describe(value: Option<TreeValue>) -> String {
    match value {
        Some(value) => format!("{} {}", value.mode.octal(), value.id),
        None => "absent".into(),
    }
}