Coverage / crates/hub/src/web/board_charts.rs 85.1%

fn day_of(ms: i64) -> String {

    let t = time::OffsetDateTime::from_unix_timestamp(ms.div_euclid(1000)).unwrap_or(time::OffsetDateTime::UNIX_EPOCH);

    format!("{:04}-{:02}-{:02}", t.year(), u8::from(t.month()), t.day())

}

fn esc(s: &str) -> String {

    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('"', "&quot;")

}

pub async fn compute(

    app: &Shared,

    account: Option<&db::accounts::Account>,

    project: &pdb::Project,

    q: &str,

    now: i64,

) -> sqlx::Result<Charts> {

    let (columns, _) = board_columns(app, account, &project.owner, project, false).await?;

    let ids: Vec<i64> = columns.iter().map(|c| c.column.id).collect();

    let done = pdb::done_column(&columns.iter().map(|c| c.column.clone()).collect::<Vec<_>>());

    let visible: std::collections::HashSet<i64> = {

        let (archived, _) = board_columns(app, account, &project.owner, project, true).await?;

        columns.iter().chain(archived.iter()).flat_map(|c| c.cards.iter().map(|v| v.card.id)).collect()

    let moves: Vec<Move> = pdb::moves(&app.db, project.id, 0)

        .await?

        .into_iter()

        .filter(|(card, _, _)| visible.contains(card))

        .map(|(card, column, at)| Move { card, column, at })

        .collect();

    let today = now - now.rem_euclid(DAY_MS);

    let flow_first = (today - (FLOW_DAYS as i64 - 1) * DAY_MS).max(project.created_ms - project.created_ms.rem_euclid(DAY_MS));

    let days = ((today - flow_first) / DAY_MS + 1) as usize;

    let flow = bs::cumulative_flow(&moves, &ids, flow_first, days);

    let (mut cycle_median_days, mut cycle_p85_days, mut cycle_finished) = (None, None, 0);

    let mut throughput = vec![0; HISTORY_WEEKS];

    if let (Some(first), Some(done)) = (ids.first().copied(), done) {

        let times = bs::cycle_times(&moves, first, done);

        cycle_finished = times.len();

        let days = |ms: i64| (ms as f64 / DAY_MS as f64 * 10.0).round() / 10.0;

        cycle_median_days = bs::percentile(&times, 50).map(days);

        cycle_p85_days = bs::percentile(&times, 85).map(days);

        throughput = bs::weekly_throughput(&moves, done, now, HISTORY_WEEKS);

    let weeks_old = ((now - project.created_ms) / WEEK_MS).max(1) as usize;

    let history: Vec<usize> = throughput[HISTORY_WEEKS.saturating_sub(weeks_old)..].to_vec();

    let iterations = pdb::iterations(&app.db, project.id).await?;

    let open = iterations.iter().find(|i| i.closed_ms.is_none());

    let burn = match (open, done) {

        _ => None,

    let filter = CardFilter::parse(q);

    let open_cards: Vec<&super::projects::CardView> = columns

        .iter()

        .filter(|c| Some(c.column.id) != done)

        .flat_map(|c| c.cards.iter())

        .filter(|c| !matches!(c.state.as_str(), "closed" | "landed"))

        .collect();

    let seed = (project.id as u64).wrapping_mul(0x9E37_79B9_7F4A_7C15) ^ (today / DAY_MS) as u64;

    let row = |scope: String, remaining: usize| {

        let f = bs::forecast(&history, remaining, TRIALS, seed);

        let date = |w: Option<usize>| w.map(|w| day_of(now + w as i64 * WEEK_MS));

        ForecastRow { scope, remaining, weeks_of_history: f.weeks_of_history, p50: date(f.p50_weeks), p85: date(f.p85_weeks) }

    };

    let mut forecasts = Vec::new();

    let mut timeline: Vec<TimelineRow> = iterations

        .iter()

        .take(6)

        .rev()

        .map(|it| TimelineRow {

        .collect();

    if !q.trim().is_empty() {

        forecasts.push(row(format!("Cards matching {}", q.trim()), open_cards.iter().filter(|c| filter.keeps(c, now)).count()));

    }

    let scope = match open {

        None => "Open cards on the board".to_string(),

    forecasts.push(row(scope, open_cards.len()));

    let mut milestones: Vec<String> = open_cards.iter().map(|c| c.milestone.clone()).filter(|m| !m.is_empty()).collect();

    milestones.sort();

    milestones.dedup();

    let mut due: std::collections::HashMap<String, i64> = Default::default();

    let mut repos: Vec<i64> = open_cards.iter().filter(|c| !c.milestone.is_empty()).filter_map(|c| c.card.repo_id).collect();

    repos.sort();

    repos.dedup();

    for rid in repos {

    for m in milestones {

        columns: columns.iter().map(|c| c.column.name.clone()).collect(),

        flow_first,

        flow,

        cycle_median_days,

        cycle_p85_days,

        cycle_finished,

        throughput,

        throughput_from: now - HISTORY_WEEKS as i64 * WEEK_MS,

        burn,

        forecasts,

        timeline,

}

pub fn timeline_svg(rows: &[TimelineRow], now: i64) -> String {

    let times: Vec<i64> = rows

        .iter()

        .flat_map(|r| [r.start, r.end, r.due, r.forecast.map(|f| f.0), r.forecast.map(|f| f.1)])

        .flatten()

        .chain([now - 14 * DAY_MS, now + 14 * DAY_MS])

        .collect();

    let (lo, hi) = (*times.iter().min().unwrap_or(&now), *times.iter().max().unwrap_or(&now));

    let span = (hi - lo).max(DAY_MS) as f64;

    let x = |t: i64| LABEL + (t - lo) as f64 / span * (W as f64 - LABEL - 4.0);

    let row_h = 22.0;

    let h = rows.len() as f64 * row_h + 22.0;

    let mut out = format!(

        rows.len(),

        day_of(lo),

        day_of(hi)

    for (i, r) in rows.iter().enumerate() {

        let y = i as f64 * row_h + 4.0;

        let _ = write!(out, r#"<text class="axis" x="0" y="{:.1}">{}</text>"#, y + 13.0, esc(&r.name.chars().take(22).collect::<String>()));

        if let (Some(a), Some(b)) = (r.start, r.end) {

            let class = if r.open { "s-main" } else { "s-mute" };

            let _ = write!(

                out,

                x(a),

                y + 3.0,

                (x(b) - x(a)).max(2.0),

                esc(&r.name),

                day_of(a),

                day_of(b - 1)

        }

        if let Some((a, b)) = r.forecast {

            let _ = write!(

                out,

                r#"<rect class="bar s-warn forecast" x="{:.1}" y="{:.1}" width="{:.1}" height="12"><title>{}: done 50% by {}, 85% by {}</title></rect>"#,

                x(a),

                y + 3.0,

                (x(b) - x(a)).max(3.0),

                esc(&r.name),

                day_of(a),

                day_of(b)

            );

        }

        if let Some(d) = r.due {

            let _ = write!(

                out,

                r#"<path class="line s-bad" d="M{0:.1},{1:.1} l5,7 l-5,7 l-5,-7 z"><title>{2} due {3}</title></path>"#,

                x(d),

                y + 2.0,

                esc(&r.name),

                day_of(d)

            );

        }

    let _ = write!(out, r#"<line class="grid today" x1="{0:.1}" x2="{0:.1}" y1="0" y2="{1:.0}"/>"#, x(now), h - 18.0);

    let _ = write!(out, r#"<text class="axis" x="{LABEL}" y="{:.0}">{}</text>"#, h - 4.0, day_of(lo));

    let _ = write!(out, r#"<text class="axis" x="{:.1}" y="{:.0}" text-anchor="middle">today</text>"#, x(now), h - 4.0);

    let _ = write!(out, r#"<text class="axis" x="{W}" y="{:.0}" text-anchor="end">{}</text></svg>"#, h - 4.0, day_of(hi));

    out

}

fn flow_svg(c: &Charts) -> String {

    let bands = bs::flow_bands(&c.flow, W, H);

    let mut out = format!(

        H + 18,

        c.flow.len()

    for (k, pts) in bands.iter().enumerate() {

        let class = if k + 1 == bands.len() { 5 } else { k % 5 };

        let _ = write!(out, r#"<polygon class="band cf-{class}" points="{pts}"><title>{}</title></polygon>"#, esc(&c.columns[k]));

    let _ = write!(out, r#"<text class="axis" x="0" y="{}">{}</text>"#, H + 14, day_of(c.flow_first));

    let _ = write!(out, r#"<text class="axis" x="{W}" y="{}" text-anchor="end">today</text></svg>"#, H + 14);

    out

}

fn bars_svg(values: &[usize], label: &str) -> String {

    let max = values.iter().copied().max().unwrap_or(0).max(1);

    let step = W as f64 / values.len().max(1) as f64;

    let mut out = format!(r#"<svg class="chart" viewBox="0 0 {W} {}" role="img" aria-label="{}">"#, H + 18, esc(label));

    for (i, v) in values.iter().enumerate() {

        let h = (*v as f64 / max as f64) * H as f64;

        let _ = write!(

            out,

            r#"<rect class="bar s-ok" x="{:.1}" y="{:.1}" width="{:.1}" height="{h:.1}"><title>{v} done</title></rect>"#,

            i as f64 * step + step * 0.15,

            H as f64 - h,

            step * 0.7

        );

    }

    let _ = write!(out, r#"<text class="axis" x="0" y="{}">{} weeks ago</text>"#, H + 14, values.len());

    let _ = write!(out, r#"<text class="axis" x="{W}" y="{}" text-anchor="end">this week</text></svg>"#, H + 14);

    out

}

pub async fn show(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, number)): Path<(String, i64)>,

    Query(query): Query<ChartsQuery>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/projects/{owner}/{number}/charts"), &viewer);

    let e = |e| Error::from_db(shell.clone(), e);

    let r = rights_of(&app, viewer.account(), &owner).await.map_err(e)?.ok_or_else(|| Error::not_found(shell.clone()))?;

    let project = pdb::get(&app.db, &owner, number)

        .await

        .map_err(e)?

        .filter(|p| p.public || r.member)

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    let now = db::now_ms();

    let q = query.q.unwrap_or_default();

    let c = compute(&app, viewer.account(), &project, &q, now).await.map_err(e)?;

    let flow_table = c

        .flow

        .iter()

        .enumerate()

        .skip(c.flow.len().saturating_sub(14))

        .map(|(d, row)| (day_of(c.flow_first + d as i64 * DAY_MS), row.clone()))

        .collect();

    let week_table = c.throughput.iter().enumerate().map(|(i, n)| (day_of(c.throughput_from + i as i64 * WEEK_MS), *n)).collect();

    let page = ChartsPage {

        flow_svg: flow_svg(&c),

        throughput_svg: bars_svg(&c.throughput, "Throughput: cards done each week"),

        burn_svg: c.burn.as_ref().map(|(_, _, d)| burn_svg(d)).unwrap_or_default(),

        timeline_svg: if c.timeline.is_empty() { String::new() } else { timeline_svg(&c.timeline, now) },

        views: pdb::views(&app.db, project.id).await.map_err(e)?,

        shell,

        project,

        c,

        flow_table,

        week_table,

        q,

    Ok(Page(page).into_response())

}

    fn the_timeline_draws_iterations_milestones_and_forecasts() {

        let now = 1_000 * DAY_MS;

        let rows = vec![

            TimelineRow {

                name: "Sprint 1".into(),

                milestone: false,

                start: Some(now - 20 * DAY_MS),

                end: Some(now - 6 * DAY_MS),

                due: None,

                forecast: None,

                open: false,

            },

            TimelineRow {

                name: "Sprint 2".into(),

                milestone: false,

                start: Some(now - 6 * DAY_MS),

                end: Some(now + 8 * DAY_MS),

                due: None,

                forecast: None,

                open: true,

            },

            TimelineRow {

                name: "Release <1>".into(),

                milestone: true,