From 32b530be8d99a9d08bc3d22c1e22843aa0eec2bd Mon Sep 17 00:00:00 2001
From: Pietro Albini <pietro@pietroalbini.org>
Date: Tue, 27 Nov 2018 11:35:25 +0100
Subject: some more changes

---
 src/schema.rs   | 55 ++++++++++++++++++++++++++++++++++++++++++++++++-------
 src/validate.rs | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 80 insertions(+), 7 deletions(-)

(limited to 'src')

diff --git a/src/schema.rs b/src/schema.rs
index 5e08a26..ac5b243 100644
--- a/src/schema.rs
+++ b/src/schema.rs
@@ -3,6 +3,7 @@ use failure::{err_msg, Error};
 use std::collections::HashSet;
 
 #[derive(serde_derive::Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
 pub(crate) struct Person {
     name: String,
     github: String,
@@ -35,11 +36,15 @@ impl Person {
 }
 
 #[derive(serde_derive::Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
 pub(crate) struct Team {
     name: String,
+    #[serde(default = "default_false")]
+    wg: bool,
     #[serde(default)]
     children: Vec<String>,
     people: TeamPeople,
+    website: Option<WebsiteData>,
     #[serde(default)]
     lists: Vec<TeamList>,
 }
@@ -49,6 +54,10 @@ impl Team {
         &self.name
     }
 
+    pub(crate) fn is_wg(&self) -> bool {
+        self.wg
+    }
+
     pub(crate) fn leads(&self) -> HashSet<&str> {
         self.people.leads.iter().map(|s| s.as_str()).collect()
     }
@@ -63,9 +72,24 @@ impl Team {
                 members.insert(person);
             }
         }
+        if self.people.include_team_leads || self.people.include_wg_leads {
+            for team in data.teams() {
+                let include_wg = team.is_wg() && self.people.include_wg_leads;
+                let include_team = !team.is_wg() && self.people.include_team_leads;
+                if include_wg || include_team {
+                    for lead in team.leads() {
+                        members.insert(lead);
+                    }
+                }
+            }
+        }
         Ok(members)
     }
 
+    pub(crate) fn raw_lists(&self) -> &[TeamList] {
+        &self.lists
+    }
+
     pub(crate) fn lists(&self, data: &Data) -> Result<Vec<List>, Error> {
         let mut lists = Vec::new();
         for raw_list in &self.lists {
@@ -110,24 +134,37 @@ impl Team {
 }
 
 #[derive(serde_derive::Deserialize, Debug)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
 struct TeamPeople {
     leads: Vec<String>,
     members: Vec<String>,
+    #[serde(default = "default_false")]
+    include_team_leads: bool,
+    #[serde(default = "default_false")]
+    include_wg_leads: bool,
 }
 
 #[derive(serde_derive::Deserialize, Debug)]
-#[serde(rename_all = "kebab-case")]
+#[serde(deny_unknown_fields)]
+pub(crate) struct WebsiteData {
+    name: String,
+    description: String,
+    email: Option<String>,
+}
+
+#[derive(serde_derive::Deserialize, Debug)]
+#[serde(rename_all = "kebab-case", deny_unknown_fields)]
 pub(crate) struct TeamList {
-    address: String,
-    access_level: ListAccessLevel,
+    pub(crate) address: String,
+    pub(crate) access_level: ListAccessLevel,
     #[serde(default = "default_true")]
-    include_team_members: bool,
+    pub(crate) include_team_members: bool,
     #[serde(default)]
-    extra_people: Vec<String>,
+    pub(crate) extra_people: Vec<String>,
     #[serde(default)]
-    extra_emails: Vec<String>,
+    pub(crate) extra_emails: Vec<String>,
     #[serde(default)]
-    extra_teams: Vec<String>,
+    pub(crate) extra_teams: Vec<String>,
 }
 
 #[derive(serde_derive::Deserialize, Debug, Copy, Clone)]
@@ -159,3 +196,7 @@ impl List {
 fn default_true() -> bool {
     true
 }
+
+fn default_false() -> bool {
+    false
+}
diff --git a/src/validate.rs b/src/validate.rs
index 250f172..b96c477 100644
--- a/src/validate.rs
+++ b/src/validate.rs
@@ -9,6 +9,8 @@ pub(crate) fn validate(data: &Data) -> Result<(), Error> {
     validate_team_members(data, &mut errors);
     validate_inactive_members(data, &mut errors);
     validate_list_email_addresses(data, &mut errors);
+    validate_list_extra_people(data, &mut errors);
+    validate_list_extra_teams(data, &mut errors);
 
     if !errors.is_empty() {
         for err in &errors {
@@ -82,6 +84,36 @@ fn validate_list_email_addresses(data: &Data, errors: &mut Vec<String>) {
     });
 }
 
+/// Ensure members of extra-people in a list are real people
+fn validate_list_extra_people(data: &Data, errors: &mut Vec<String>) {
+    wrapper(data.teams(), errors, |team, errors| {
+        wrapper(team.raw_lists().iter(), errors, |list, _| {
+            for person in &list.extra_people {
+                if data.person(person).is_none() {
+                    bail!("person `{}` does not exist (in list `{}`)", person, list.address);
+                }
+            }
+            Ok(())
+        });
+        Ok(())
+    });
+}
+
+/// Ensure members of extra-people in a list are real people
+fn validate_list_extra_teams(data: &Data, errors: &mut Vec<String>) {
+    wrapper(data.teams(), errors, |team, errors| {
+        wrapper(team.raw_lists().iter(), errors, |list, _| {
+            for list_team in &list.extra_teams {
+                if data.team(list_team).is_none() {
+                    bail!("team `{}` does not exist (in list `{}`)", list_team, list.address);
+                }
+            }
+            Ok(())
+        });
+        Ok(())
+    });
+}
+
 fn wrapper<T, I, F>(iter: I, errors: &mut Vec<String>, mut func: F)
 where
     I: Iterator<Item = T>,
-- 
cgit v1.2.3