HTTP API: commit

Kde se jedna cesta nachází mezi indexem a pracovním stromem.

use majordomus_cli::commit::ChangeStage;
// ordered so that what would be in the next commit sorts first
assert!(ChangeStage::Staged < ChangeStage::Unstaged);
assert!(ChangeStage::Unstaged < ChangeStage::Untracked);

Proč commit nebyl posouzen.

use majordomus_cli::commit::{judge, CommitExemption, CommitPolicy, CommitSubject};
let v = judge(&CommitSubject::of("Merge pull request #1 from a/b"), &CommitPolicy::default());
assert_eq!(v.exempt, Some(CommitExemption::GitAuthored));

Jeden commit, který plán navrhuje. Jeden commit, který plán navrhuje: jeho zpráva, jeho cesty a proč jsou ty cesty jeden commit.

use majordomus_cli::commit::{plan::group, CommitGroup, ScopeVocabulary};
let mut v = ScopeVocabulary::default();
v.learn("commit", "src/commit", 40);
let g: Vec<CommitGroup> = group(&["src/commit/a.rs".into()], &v, &[]);
// the subject is empty on purpose: what a change did is the one thing no evidence in
// the tree can state
assert_eq!(g[0].message.header.subject, "");
assert_eq!(g[0].message.header.scope.as_deref(), Some("commit"));
assert!(g[0].rationale.contains("40 prior commit"), "{}", g[0].rationale);

Hlavička zprávy commitu: její první řádek, rozebraný na části.

word je typ tak, jak jej autor napsal, a kind je to, co dané slovo jmenuje; liší se přesně tehdy, když slovo není jedno z jedenácti, která konvence definuje, a držení obou umožňuje čtenáři vidět wip(site): halfway through tak, jak je autor napsal, zatímco posuzovatel stále hlásí, že wip není typ.

use majordomus_cli::commit::CommitHeader;
use majordomus_cli::release::ChangeKind;
let h = CommitHeader::parse("fix(plan): the fingerprint names what moved");
assert_eq!(h.word, "fix");
assert_eq!(h.kind, ChangeKind::Fix);
assert_eq!(h.scope.as_deref(), Some("plan"));
assert!(!h.breaking);
assert_eq!(h.subject, "the fingerprint names what moved");

Rozebraná zpráva commitu: hlavička, tělo, trailery.

use majordomus_cli::commit::CommitMessage;
let m = CommitMessage::parse("feat(a): a thing\n\nThe body.\n\nRefs: I1305\n");
assert_eq!(m.header.subject, "a thing");
assert_eq!(m.body, "The body.");
assert_eq!(m.trailers.len(), 1);

Plán nad pracovním stromem.

use majordomus_cli::commit::{CommitPlan, PlanFingerprint, WorkingTreeState};
let plan = CommitPlan {
    fingerprint: PlanFingerprint::of("/r/.git", "/r", &WorkingTreeState::default()),
    tree: WorkingTreeState::default(),
    groups: Vec::new(),
    diagnostics: Vec::new(),
};
assert!(plan.groups.is_empty(), "a clean tree proposes nothing");

Jeden řádek Key: value v bloku trailerů na konci zprávy commitu.

use majordomus_cli::commit::CommitMessage;
use majordomus_cli::commit::CommitTrailer;
let m = CommitMessage::parse("fix(x): a thing\n\nWhy.\n\nRefs: I1305\n");
let t: &CommitTrailer = &m.trailers[0];
assert_eq!(t.key, "Refs");
assert_eq!(t.value, "I1305");

K čemu soudce dospěl: zpráva tak, jak byla zpracována, zda byl nalezen nějaký problém úrovně error, výjimka, když předmět složil git a ne člověk, a každý nález v pořadí CommitRule::ALL — což je pořadí, v jakém se důkazy pro ně ve zprávě objevují, takže je člověk čte v pořadí, v jakém je opraví.

use majordomus_cli::commit::{judge, CommitPolicy, CommitSubject, CommitVerdict};
let v: CommitVerdict = judge(&CommitSubject::of("update stuff"), &CommitPolicy::default());
assert!(!v.passed);
assert_eq!(v.findings[0].code, "commit.not_conventional");
assert_eq!(v.message.header.subject, "update stuff", "what was judged, not what was typed");

Rozsah historie, posouzený. Rozsah historie, posouzený jedním průchodem.

use majordomus_cli::commit::verdict::HistoryReport;
let r = HistoryReport {
    range: "HEAD".into(),
    total: 1755,
    exempt: 561,
    failing: 54,
    commits: Vec::new(),
};
// a commit with nothing to say is counted and not listed: a report of a thousand
// passing commits is a report nobody reads
assert!(r.commits.is_empty());
assert_eq!(r.total - r.exempt, 1194);

Jeden commit historie, posouzený.

use majordomus_cli::commit::verdict::JudgedCommit;
// what a history report lists: only the commits that have something to say
let row = JudgedCommit {
    commit: "a1b2c3d4e".into(),
    subject: "update stuff".into(),
    passed: false,
    exempt: None,
    findings: Vec::new(),
};
assert!(!row.passed);

Jedna cesta a kde stojí.

use majordomus_cli::commit::ChangeStage;
use majordomus_cli::commit::plan::PathChange;
// staged and modified again since: the commit would carry the staged half only
let c = PathChange {
    path: "src/a.rs".into(), stage: ChangeStage::Staged, status: "MM".into(), partial: true,
};
assert!(c.partial);

Z čeho byl plán odvozen.

Porovnáván, nikdy nevěřen: plán, jehož otisk se liší od stromu před ním, popisuje strom, který už neexistuje.

use majordomus_cli::commit::{PlanFingerprint, WorkingTreeState};
let f = PlanFingerprint::of("/repo/.git", "/repo", &WorkingTreeState::default());
assert_eq!(f.head, "unborn", "a repository with no commits says so");

Do jakého rozsahu patří sada cest a důkazy o tom.

use majordomus_cli::commit::{ScopeSuggestion, ScopeVocabulary};
let mut v = ScopeVocabulary::default();
// two scopes with equal claim to one directory: reported, never broken silently
v.learn("a", "src", 7);
v.learn("b", "src", 7);
let s: ScopeSuggestion = v.suggest(&["src/x.rs".into()]).expect("a tie");
assert!(s.ambiguous);

Jeden rozsah, který historie používá, a kolik.

use majordomus_cli::commit::scopes::ScopeUse;
let u = ScopeUse { scope: "commit".into(), commits: 40, directories: vec!["src/commit".into()] };
assert_eq!(u.commits, 40);

Slovník tak, jak byl pozorován, s tím, co bylo pozorováno.

use majordomus_cli::commit::ScopeVocabulary;
// an empty vocabulary knows nothing and says so, rather than guessing
let v = ScopeVocabulary::default();
assert!(!v.knows("anything"));
assert!(v.words().is_empty());

Slovník s politikou, která ho čte.

use majordomus_cli::capability::builtin::commit::ScopesReport;
use majordomus_cli::commit::ScopeVocabulary;
let r = ScopesReport { vocabulary: ScopeVocabulary::default(), sample: 1500 };
assert_eq!(r.sample, majordomus_cli::commit::scopes::SAMPLE);

Co git právě teď říká o pracovním stromu.

use majordomus_cli::commit::WorkingTreeState;
let clean = WorkingTreeState::default();
assert!(clean.is_clean());
assert!(clean.staged().is_empty());