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
|
use crate::data::Data;
use std::collections::HashSet;
use failure::{Error, bail};
pub(crate) fn validate(data: &Data) -> Result<(), Error> {
let mut errors = Vec::new();
validate_team_leads(data, &mut errors);
validate_team_members(data, &mut errors);
validate_inactive_members(data, &mut errors);
validate_list_email_addresses(data, &mut errors);
if !errors.is_empty() {
for err in &errors {
eprintln!("validation error: {}", err);
}
bail!("{} validation errors found", errors.len());
}
Ok(())
}
/// Ensure team leaders are part of the teams they lead
fn validate_team_leads(data: &Data, errors: &mut Vec<String>) {
wrapper(data.teams(), errors, |team, errors| {
let members = team.members(data)?;
wrapper(team.leads().iter(), errors, |lead, _| {
if !members.contains(lead) {
bail!("`{}` leads team `{}`, but is not a member of it", lead, team.name());
}
Ok(())
});
Ok(())
});
}
/// Ensure team members are people
fn validate_team_members(data: &Data, errors: &mut Vec<String>) {
wrapper(data.teams(), errors, |team, errors| {
wrapper(team.members(data)?.iter(), errors, |member, _| {
if data.person(member).is_none() {
bail!("person `{}` is member of team `{}` but doesn't exist", member, team.name());
}
Ok(())
});
Ok(())
});
}
/// Ensure every person is part of at least a team
fn validate_inactive_members(data: &Data, errors: &mut Vec<String>) {
let mut active_members = HashSet::new();
wrapper(data.teams(), errors, |team, _| {
let members = team.members(data)?;
for member in members {
active_members.insert(member);
}
Ok(())
});
let all_members = data.people().map(|p| p.github()).collect::<HashSet<_>>();
wrapper(all_members.difference(&active_members), errors, |person, _| {
bail!("person `{}` is not a member of any team", person);
});
}
/// Ensure every member of a team with a mailing list has an email address
fn validate_list_email_addresses(data: &Data, errors: &mut Vec<String>) {
wrapper(data.teams(), errors, |team, errors| {
if team.lists(data)?.is_empty() {
return Ok(());
}
wrapper(team.members(data)?.iter(), errors, |member, _| {
let member = data.person(member).unwrap();
if member.email().is_none() {
bail!("person `{}` is a member of a mailing list but has no email address", member.github());
}
Ok(())
});
Ok(())
});
}
fn wrapper<T, I, F>(iter: I, errors: &mut Vec<String>, mut func: F)
where
I: Iterator<Item = T>,
F: FnMut(T, &mut Vec<String>) -> Result<(), Error>,
{
for item in iter {
if let Err(err) = func(item, errors) {
errors.push(err.to_string());
}
}
}
|
