git-meta-cli 0.1.9

Command-line tool for structured Git metadata (get/set, serialize, materialize, push/pull). Installs the `git-meta` binary.
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

use anyhow::Result;
use git_meta_lib::serialize::{SerializeMode, SerializeProgress};

use crate::context::CommandContext;

pub fn run(_verbose: bool, force_full: bool) -> Result<()> {
    let ctx = CommandContext::open(None)?;
    let output = if force_full {
        ctx.session.serialize_full_with_progress(print_progress)?
    } else {
        ctx.session.serialize_with_progress(print_progress)?
    };

    if output.changes == 0 {
        println!("no metadata to serialize");
        return Ok(());
    }

    for ref_name in &output.refs_written {
        println!("serialized to {ref_name}");
    }

    if output.pruned > 0 {
        println!("auto-pruned {} entries", output.pruned);
    }

    Ok(())
}

fn print_progress(event: SerializeProgress) {
    match event {
        SerializeProgress::Reading { mode } => {
            let mode = match mode {
                SerializeMode::Incremental => "incremental",
                SerializeMode::Full => "full",
            };
            eprintln!("reading SQLite metadata ({mode})...");
        }
        SerializeProgress::Read {
            metadata,
            tombstones,
            set_tombstones,
            list_tombstones,
            changes,
        } => {
            eprintln!(
                "read {metadata} metadata rows, {tombstones} tombstones, {set_tombstones} set tombstones, {list_tombstones} list tombstones ({changes} changes)"
            );
        }
        SerializeProgress::Pruned { entries } => {
            eprintln!("filtered {entries} rows by prune settings");
        }
        SerializeProgress::Routed {
            destinations,
            records,
        } => {
            eprintln!("routed {records} records across {destinations} destination refs");
        }
        SerializeProgress::BuildingRef { ref_name, records } => {
            eprintln!("building {ref_name} ({records} records)...");
        }
        SerializeProgress::RefUnchanged { ref_name } => {
            eprintln!("{ref_name} unchanged");
        }
        SerializeProgress::RefWritten { ref_name } => {
            eprintln!("wrote {ref_name}");
        }
        SerializeProgress::AutoPruned {
            ref_name,
            keys_dropped,
            keys_retained,
        } => {
            eprintln!("auto-pruned {ref_name} ({keys_dropped} dropped, {keys_retained} retained)");
        }
    }
}