speccoder-runtime 0.8.2

Application services of speccoder: the only crate that executes anything.
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
127
128
129
130
131
132
133
134

//! The one confirmation: bound to the digest of what the person was shown,
//! recorded with who, through what and on what basis, and turned into the
//! fix's pre-frozen acceptance set. A changed triad lapses it.

use std::path::Path;

use speccoder_core::acceptance::{Decided, PreFrozenAcceptance, Producer, VisibleTest};
use speccoder_core::actions::Via;
use speccoder_core::bug::{
    AcceptanceRef, Basis, BugReport, Confirmation, Outcome, PreFrozenRef, Reproduction, Stage,
};

use crate::integrity::sha256_hex;

/// Unix seconds now.
#[must_use]
pub fn now() -> u64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map_or(0, |d| d.as_secs())
}

/// `sha256:<hex>` over the reproductions shown: each statement, file,
/// content digest, test and the command that runs it, sorted.
#[must_use]
pub fn digest(reproductions: &[Reproduction]) -> String {
    let mut lines: Vec<String> = reproductions
        .iter()
        .map(|r| {
            format!(
                "{}\t{}\t{}\t{}\t{}",
                r.statement,
                r.file,
                r.digest,
                r.test,
                serde_json::to_string(&r.argv).unwrap_or_default()
            )
        })
        .collect();
    lines.sort();
    format!("sha256:{}", sha256_hex(lines.join("\n").as_bytes()))
}

/// Records the confirmation of `bug`'s reproductions and stores them as the
/// fix's pre-frozen set; returns the record and the files.
pub fn freeze(
    state: &Path,
    bug: &mut BugReport,
    by: &str,
    via: Via,
    basis: Basis,
) -> Result<(PreFrozenAcceptance, Vec<(String, String)>), String> {
    let digest = bug
        .confirm_digest
        .clone()
        .ok_or_else(|| "there are no reproductions to confirm".to_owned())?;
    let paths: Vec<String> = bug.reproductions.iter().map(|r| r.file.clone()).collect();
    let files = super::state::repro(state, &bug.unit, &bug.task, &paths);
    if files.len() != paths.len() {
        return Err("the reproductions' contents are missing from the state directory".to_owned());
    }
    let at = now();
    let record = PreFrozenAcceptance {
        unit: bug.unit.clone(),
        requirement: bug.requirement.clone(),
        wording_digest: bug.triad.digest.clone(),
        approval_digest: digest.clone(),
        visible: bug
            .reproductions
            .iter()
            .map(|r| VisibleTest {
                path: r.file.clone(),
                sha256: r.digest.clone(),
                cites: vec![r.statement.clone()],
            })
            .collect(),
        held_out_sealed: bug.held_out_sealed.clone(),
        producer: if basis == Basis::NamedTest {
            Producer::PersonTest
        } else {
            Producer::BugConfirmation
        },
        decided: Decided {
            by: by.to_owned(),
            via,
            at,
        },
    };
    crate::pre_frozen::store(state, &record, &files)?;
    bug.confirmation = Some(Confirmation {
        digest: digest.clone(),
        triad_digest: bug.triad.digest.clone(),
        by: by.to_owned(),
        via,
        basis,
        at,
    });
    bug.acceptance = Some(AcceptanceRef {
        source: record.producer.source(),
        pre_frozen: PreFrozenRef {
            manifest: crate::pre_frozen::manifest_digest(&record),
            approval: digest,
            wording: record.wording_digest.clone(),
        },
    });
    bug.stage = Stage::Fix;
    bug.outcome = Outcome::Recorded;
    bug.code = None;
    bug.handoff = None;
    super::state::save(state, bug)?;
    Ok((record, files))
}

/// Forgets a confirmation the triad no longer stands for: the bug goes
/// back to recorded, its reproductions to be written again.
pub fn lapse(
    state: &Path,
    bug: &mut BugReport,
    triad: speccoder_core::bug::Triad,
) -> Result<(), String> {
    crate::pre_frozen::remove(state, &bug.unit, &bug.requirement);
    bug.triad = triad;
    bug.confirmation = None;
    bug.confirm_digest = None;
    bug.acceptance = None;
    bug.reproductions
        .retain(|r| r.source == speccoder_core::bug::Source::Person);
    bug.held_out.clear();
    bug.held_out_sealed = None;
    bug.tries.clear();
    bug.stage = Stage::Reproduce;
    bug.outcome = Outcome::Recorded;
    super::state::save(state, bug)
}