Log sections: ::group:: folds a job's output on the run page d9b3b84605a4

            // Sections (oxygenflow#31): ::group::TITLE opens one, ::endgroup::

            // (or the next ::group::) closes it; the open one takes the lines.

            var open = log.querySelector("details[data-open-group]");

            var secs = function (ms) { return Math.floor(ms / 1000) + "." + Math.floor(ms % 1000 / 100) + "s"; };

            var close = function (t) {

              if (!open) return;

              open.removeAttribute("data-open-group"); open.open = false;

              var took = document.createElement("span"); took.className = "took"; took.textContent = " " + secs(t - Number(open.getAttribute("data-from")));

              open.querySelector("summary").appendChild(took); open = null;

            };

              var tt = document.createElement("span"); tt.className = "t"; tt.textContent = secs(l.t);

              if (l.text.indexOf("::group::") === 0) {

                close(l.t);

                open = document.createElement("details"); open.className = "log-group"; open.open = true;

                open.setAttribute("data-open-group", ""); open.setAttribute("data-from", l.t);

                var sum = document.createElement("summary"); sum.className = "ln";

                sum.appendChild(tt); sum.appendChild(document.createTextNode(l.text.slice(9).trim()));

                open.appendChild(sum); log.appendChild(open);

              } else if (l.text.trim() === "::endgroup::") {

                close(l.t);

              } else {

                var ln = document.createElement("span"); ln.className = "ln s-" + l.stream;

                ln.appendChild(tt); ln.appendChild(document.createTextNode(l.text));

                var into = open || log;

                into.appendChild(ln); into.appendChild(document.createTextNode("\n"));

              }

/// A stretch of a job's log as the run page shows it: a line, or a

/// section the job marked with `::group::TITLE` … `::endgroup::`

/// (oxygenflow#31), shown folded with how long it took.

pub enum Segment {

    Line(fdb::LogLine),

    Group(Section),

}

pub struct Section {

    pub title: String,

    /// When it began, and ended (`None` while it is still going).

    pub from_t: i64,

    pub to_t: Option<i64>,

    pub lines: Vec<fdb::LogLine>,

}

/// A log's lines in sections. A section left open is still going; a new

/// `::group::` ends the one before (sections do not nest).

pub fn sections(lines: &[fdb::LogLine]) -> Vec<Segment> {

    let mut out: Vec<Segment> = Vec::new();

    let mut open: Option<Section> = None;

    for l in lines {

        if let Some(title) = l.text.strip_prefix("::group::") {

            if let Some(g) = open.take() {

                out.push(Segment::Group(Section { to_t: Some(l.t), ..g }));

            }

            open = Some(Section { title: title.trim().to_string(), from_t: l.t, to_t: None, lines: Vec::new() });

        } else if l.text.trim() == "::endgroup::" {

            if let Some(g) = open.take() {

                out.push(Segment::Group(Section { to_t: Some(l.t), ..g }));

            }

        } else {

            match open.as_mut() {

                Some(g) => g.lines.push(l.clone()),

                None => out.push(Segment::Line(l.clone())),

            }

        }

    }

    if let Some(g) = open {

        out.push(Segment::Group(g));

    }

    out

}

/// Milliseconds as the log shows them: `12.3s`.

pub fn secs(ms: impl std::borrow::Borrow<i64>) -> String {

    let ms = *ms.borrow();

    format!("{}.{}s", ms / 1000, ms % 1000 / 100)

}

    /// The lines in sections (oxygenflow#31).

    pub segments: Vec<Segment>,

        let segments = sections(&lines);

        logs.push(JobLog {

            duration: crate::flow::duration(j),

            j: j.clone(),

            artifacts,

            lines,

            segments,

            last_seq,

            coverage,

            tests,

            failures,

        });

}

#[cfg(test)]

mod section_tests {

    use super::*;

    fn line(seq: i64, t: i64, text: &str) -> fdb::LogLine {

        fdb::LogLine { seq, t, stream: "out".into(), text: text.into() }

    }

    #[test]

    fn marked_lines_fold_into_sections() {

        let lines = vec![

            line(1, 0, "booting"),

            line(2, 100, "::group::cargo build"),

            line(3, 200, "Compiling a"),

            line(4, 900, "Compiling b"),

            line(5, 4_300, "::endgroup::"),

            line(6, 4_400, "::group::cargo test"),

            line(7, 4_500, "test x ... ok"),

            line(8, 5_000, "::group::lint"),

            line(9, 5_100, "clean"),

        ];

        let segs = sections(&lines);

        assert_eq!(segs.len(), 4);

        assert!(matches!(&segs[0], Segment::Line(l) if l.text == "booting"));

        let Segment::Group(build) = &segs[1] else { panic!("a section") };

        assert_eq!((build.title.as_str(), build.from_t, build.to_t, build.lines.len()), ("cargo build", 100, Some(4_300), 2));

        let Segment::Group(test) = &segs[2] else { panic!("a section") };

        assert_eq!(test.to_t, Some(5_000), "a new section ends the one before");

        let Segment::Group(lint) = &segs[3] else { panic!("a section") };

        assert_eq!((lint.to_t, lint.lines.len()), (None, 1), "still going");

        assert_eq!(secs(4_200), "4.2s");

    }

        let log = serde_json::json!({ "records": [

            { "t": 1, "stream": "out", "text": format!("{name} ran") },

            { "t": 2, "stream": "out", "text": "::group::compile" },

            { "t": 5, "stream": "out", "text": "cc a.c" },

            { "t": 1502, "stream": "out", "text": "::endgroup::" },

        ]});

    // Marked lines fold into a section, with how long it took (#31).

    let (_, page) = call(&h.app, "GET", &format!("/andy/flaky/flow/{}", run.number), None, None).await;

    assert!(page.contains(r#"<details class="log-group" data-from="2">"#), "{page}");

    assert!(page.contains(r#"compile <span class="took">1.5s</span></summary>"#) && !page.contains("::endgroup::"), "{page}");

  Runs only ever take committed states already in the repository, never uncommitted work. A run writes no history: its receipts are signed statements about a state (Oxygen spec §14.6). Running a state again adds another statement. The environment hash shows whether it ran in the same environment, and a matching result is independent confirmation. The new run's checks replace the old ones for that state, and the run page says what started it (pushed by, started by, re-run of #N by). Each log line shows its time since the job began, and a job folds its own output into sections by printing `::group::TITLE` and later `::endgroup::` (as GitHub Actions does; a new `::group::` ends the one before): the run page shows each section closed with how long it took, the one still going open, live as lines arrive (oxygenflow#31).

  <pre class="flow-log" data-log data-seq="{{ l.last_seq }}">{% for seg in l.segments %}{% match seg %}{% when crate::web::flow::Segment::Line(line) %}<span class="ln s-{{ line.stream }}"><span class="t">{{ crate::web::flow::secs(line.t) }}</span>{{ line.text }}</span>

{% when crate::web::flow::Segment::Group(g) %}<details class="log-group" data-from="{{ g.from_t }}"{% if g.to_t.is_none() %} open data-open-group{% endif %}><summary class="ln"><span class="t">{{ crate::web::flow::secs(g.from_t) }}</span>{{ g.title }}{% if let Some(e) = g.to_t %} <span class="took">{{ crate::web::flow::secs(e - g.from_t) }}</span>{% endif %}</summary>{% for line in g.lines %}<span class="ln s-{{ line.stream }}"><span class="t">{{ crate::web::flow::secs(line.t) }}</span>{{ line.text }}</span>

{% endfor %}</details>{% endmatch %}{% endfor %}</pre>

pre.flow-log details.log-group > summary { cursor: pointer; font-weight: 600; list-style: none; }

pre.flow-log details.log-group > summary::before { content: "▸ "; color: var(--mute); }

pre.flow-log details.log-group[open] > summary::before { content: "▾ "; }

pre.flow-log details.log-group > summary .took { font-weight: 400; color: var(--mute); margin-left: 6px; }