thirdpass 0.3.2

A multi-ecosystem package code review system.
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

use anyhow::Result;

pub mod active;
pub mod comment;
mod common;
pub mod fs;
pub mod remote;
pub mod tool;
pub mod workspace;

pub use crate::review::common::{
    Priority, Review, ReviewScope, ReviewTarget, ReviewerDetails, SecuritySummary,
};

pub fn overall_security_summary(review: &Review) -> Result<SecuritySummary> {
    Ok(review
        .targets
        .iter()
        .map(|target| {
            target
                .security_summary
                .clone()
                .unwrap_or_else(|| security_summary_for_comments(&target.comments))
        })
        .fold(SecuritySummary::None, highest_security_summary))
}

pub fn security_summary_for_comments<'a>(
    comments: impl IntoIterator<Item = &'a comment::Comment>,
) -> SecuritySummary {
    let mut summary = SecuritySummary::Low;
    let mut saw_comment = false;
    for comment in comments {
        saw_comment = true;
        match comment.security {
            Priority::Critical => return SecuritySummary::Critical,
            Priority::Medium => summary = SecuritySummary::Medium,
            Priority::Low => {}
        }
    }
    if !saw_comment {
        return SecuritySummary::None;
    }
    summary
}

fn highest_security_summary(left: SecuritySummary, right: SecuritySummary) -> SecuritySummary {
    if security_summary_rank(&right) > security_summary_rank(&left) {
        right
    } else {
        left
    }
}

fn security_summary_rank(summary: &SecuritySummary) -> u8 {
    match summary {
        SecuritySummary::Critical => 3,
        SecuritySummary::Medium => 2,
        SecuritySummary::Low => 1,
        SecuritySummary::None => 0,
    }
}

pub fn store_pending(review: &Review) -> Result<std::path::PathBuf> {
    fs::add(&review, fs::ReviewStorageStatus::Pending)
}

pub fn store_submitted(review: &Review) -> Result<std::path::PathBuf> {
    fs::add(&review, fs::ReviewStorageStatus::Submitted)
}

pub fn promote_pending(
    review: &Review,
    pending_path: &std::path::PathBuf,
) -> Result<std::path::PathBuf> {
    fs::promote(&review, pending_path)
}