Live pages L3: the proposal page updates itself b5a0a69b3622

  // data-live may name several topics, separated by spaces.

  var topicsOf = function (el) { return el.getAttribute("data-live").split(/\s+/).filter(Boolean); };

  Array.prototype.forEach.call(marked, function (el) { topicsOf(el).forEach(function (t) { topics[t] = true; }); });

      if (topicsOf(el).indexOf(d.topic) >= 0) refresh(el);

    /// The assistants answering on a proposal now (lower-case names, sorted).

    pub fn answering(&self, proposal_id: i64) -> Vec<String> {

        let mut v: Vec<String> = self.busy.iter().filter(|(p, _)| *p == proposal_id).map(|(_, n)| n.clone()).collect();

        v.sort();

        v

    }

    app.events.live.publish(&crate::events::topic::proposal(row.id, p.number), "assistant");

                app.events.live.publish(&crate::events::topic::proposal(row.id, p.number), "assistant");

    app.events.live.publish(&crate::events::topic::proposal(row.id, p.number), "assistant");

                app.events.live.publish(&crate::events::topic::proposal(row.id, p.number), "comment");

                app.events.live.publish(&crate::events::topic::proposal(row.id, p.number), "assistant");

/// The part of a rendered page between `<!--frag:NAME-->` and

/// `<!--/frag:NAME-->` (live pages, docs/live.md): what a page fetches again

/// when its topic changes. `None` when the page has no such part.

pub fn fragment(html: &str, name: &str) -> Option<String> {

    if !name.bytes().all(|b| b.is_ascii_lowercase() || b == b'-') || name.is_empty() {

        return None;

    }

    let open = format!("<!--frag:{name}-->");

    let close = format!("<!--/frag:{name}-->");

    let start = html.find(&open)? + open.len();

    let end = start + html[start..].find(&close)?;

    Some(html[start..end].to_string())

}

#[cfg(test)]

mod fragment_tests {

    #[test]

    fn a_fragment_is_cut_from_the_page_by_its_markers() {

        let page = "<p>a</p><div data-fragment=\"x\"><!--frag:x--><b>inside</b><!--/frag:x--></div>";

        assert_eq!(super::fragment(page, "x").as_deref(), Some("<b>inside</b>"));

        assert_eq!(super::fragment(page, "y"), None);

        assert_eq!(super::fragment(page, "x--><b"), None, "names are plain");

    }

}

    /// Live topics (oxygenhub#205): the proposal's and its repository's

    /// (checks arrive on the latter).

    live_topic: String,

    repo_topic: String,

    /// Assistants answering now: shown as pending until they do.

    pending: Vec<String>,

    /// Only this part of the page (live pages, oxygenhub#205).

    #[serde(default)]

    fragment: Option<String>,

    let p_id = p.id;

    let pending = app.assistant_gate.lock().unwrap_or_else(|e| e.into_inner()).answering(p_id);

        live_topic: crate::events::topic::proposal(row.id, number),

        repo_topic: crate::events::topic::repo(row.id),

        pending,

) -> Result<Response, Error> {

    }

    // A live page asks for one part again (oxygenhub#205): rendered by the

    // same route, so the same access, and cut from the whole.

    if let Some(name) = q.fragment.as_deref() {

        let html = page.0.render().map_err(|e| Error::bad(page.0.shell.clone(), e.to_string()))?;

        return Ok(match super::fragment(&html, name) {

            Some(part) => ([(axum::http::header::CACHE_CONTROL, "no-store")], axum::response::Html(part)).into_response(),

            None => (axum::http::StatusCode::NOT_FOUND, "no such fragment").into_response(),

        });

    Ok(page.into_response())

    app.events.live.publish(&crate::events::topic::proposal(row.id, number), "comment");

    // Live (oxygenhub#205): the page marks what updates itself; a comment

    // is heard on the proposal's topic; each part can be fetched alone.

    let demo = db::repos::get(&app.db, "andy", "demo").await.unwrap().unwrap();

    let topic = oxygenhub::events::topic::proposal(demo.id, 1);

    let page = get(app, "/andy/demo/proposal/1", Some(&bob)).await.body;

    assert!(page.contains(&format!("data-live=\"{topic}\" data-fragment=\"timeline\"")), "the timeline is live");

    assert!(page.contains(&format!("data-live=\"{topic} repo:{}\" data-fragment=\"landing\"", demo.id)), "landing hears checks too");

    let csrf_c = csrf_of(&page);

    act(app, "/andy/demo/proposal/1/comment", Some(&bob), &format!("_csrf={csrf_c}&body=heard+live")).await;

    let heard = match app.events.live.since(0, std::slice::from_ref(&topic)) {

        oxygenhub::events::Replay::Events(e) => e.into_iter().map(|e| e.kind).collect::<Vec<_>>(),

        oxygenhub::events::Replay::Reload => vec![],

    };

    assert!(heard.contains(&"comment".to_string()), "{heard:?}");

    let part = get(app, "/andy/demo/proposal/1?fragment=timeline", Some(&bob)).await;

    assert_eq!(part.status, StatusCode::OK);

    assert!(

        part.body.contains("heard live") && !part.body.contains("<html") && !part.body.contains("Review this proposal"),

        "{}",

        part.body

    );

    let landing = get(app, "/andy/demo/proposal/1?fragment=landing", Some(&bob)).await;

    assert!(landing.body.contains("<h3>Landing</h3>") && !landing.body.contains("heard live"), "{}", landing.body);

    assert_eq!(get(app, "/andy/demo/proposal/1?fragment=nope", Some(&bob)).await.status, StatusCode::NOT_FOUND);

- **L3 (done, #205):** the proposal page updates itself. Its timeline

  (comments, reviews, assistant answers, events, the landed or closed

  outcome, and a "… is answering" placeholder while an assistant works)

  listens on `repo:<id>/proposal:<n>`, and its Landing section on that and

  `repo:<id>` (check results). `?fragment=timeline|landing` renders the page

  through the same route and returns the part between

  `<!--frag:NAME-->` markers (`web::fragment`), so the update is the page.

  A comment, an assistant asked, answering or not answering, reviews, state

  changes and landings publish on the proposal's topic.

  <div class="tl-live" data-live="{{ live_topic }}" data-fragment="timeline"><!--frag:timeline-->

  {% for a in pending %}<p class="tl-event tl-pending" role="status"><span class="tl-dot"></span><img class="tl-mini" src="/avatar/agent/{{ a }}" alt="" width="18" height="18"> <strong>{{ a }}</strong> is answering… <span class="mute small">this updates by itself</span></p>{% endfor %}

  <!--/frag:timeline--></div>

  <section class="side-sec" data-live="{{ live_topic }} {{ repo_topic }}" data-fragment="landing"><!--frag:landing-->

  <!--/frag:landing--></section>