govctl 0.18.0

Project governance CLI for RFC, ADR, and Work Item management
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

use crate::config::Config;
use crate::diagnostic::{Diagnostic, DiagnosticResult};
use crate::write::{WriteOp, read_clause, write_clause};
use std::path::{Path, PathBuf};

pub(super) fn rfc_update_paths(config: &Config, rfc_path: &Path) -> DiagnosticResult<Vec<PathBuf>> {
    let mut paths = vec![rfc_path.to_path_buf()];
    for path in clause_toml_paths(config, rfc_path)? {
        if read_clause(config, &path)?.since.is_none() {
            paths.push(path);
        }
    }
    paths.sort();
    Ok(paths)
}

pub(super) fn pending_clause_ids(
    config: &Config,
    rfc_path: &Path,
) -> DiagnosticResult<Vec<String>> {
    let mut clause_ids = Vec::new();
    for path in clause_toml_paths(config, rfc_path)? {
        let clause = read_clause(config, &path)?;
        if clause.since.is_none() {
            clause_ids.push(clause.clause_id);
        }
    }
    clause_ids.sort();
    Ok(clause_ids)
}

fn clause_toml_paths(config: &Config, rfc_path: &Path) -> DiagnosticResult<Vec<PathBuf>> {
    let mut paths = crate::load::load_rfc(config, rfc_path)
        .map_err(Diagnostic::from)?
        .clauses
        .into_iter()
        .map(|clause| clause.path)
        .collect::<Vec<_>>();
    paths.sort();
    Ok(paths)
}

/// Update pending clauses (since: null) with the given version.
///
/// Pending clauses are filled in when the RFC is bumped or finalized.
pub(super) fn fill_pending_clause_versions(
    config: &Config,
    rfc_path: &Path,
    version: &str,
    op: WriteOp,
) -> DiagnosticResult<Vec<String>> {
    let mut pending_clauses = Vec::new();
    for path in clause_toml_paths(config, rfc_path)? {
        let clause = read_clause(config, &path)?;
        if clause.since.is_none() {
            pending_clauses.push((path, clause));
        }
    }

    // Sort by clause_id for deterministic output order.
    pending_clauses.sort_by_key(|(_, c)| c.clause_id.clone());

    let mut updated_clause_ids = Vec::with_capacity(pending_clauses.len());
    for (path, mut clause) in pending_clauses {
        clause.since = Some(version.to_string());
        write_clause(
            config,
            &path,
            &clause,
            op,
            Some(&config.display_path(&path)),
        )?;
        updated_clause_ids.push(clause.clause_id);
    }

    Ok(updated_clause_ids)
}