Add validation for duplicate team entries

- Add explicit_leads() method to expose team leads
- Check leads, members, and alumni for duplicates
- Collect all errors for better developer experience

Author: vivekjami

src/schema.rs

@@ -516,6 +516,10 @@ impl Team {
     pub(crate) fn explicit_alumni(&self) -> &[TeamMember] {
         self.people.alumni.as_ref().map_or(&[], Vec::as_slice)
     }
+    
+    pub(crate) fn explicit_leads(&self) -> &[String] {
+        &self.people.leads
+    }
 
     pub(crate) fn contains_person(&self, data: &Data, person: &Person) -> Result<bool, Error> {
         let members = self.members(data)?;

src/validate.rs

@@ -237,31 +237,61 @@ fn validate_team_members(data: &Data, errors: &mut Vec<String>) {
     });
 }
 
-/// Ensure no duplicate entries in team members or alumni
+/// Helper for checking duplicates in a list
+fn check_duplicates<'a, I>(team_name: &str, label: &str, items: I) -> Result<(), Error>
+where
+    I: IntoIterator<Item = &'a str>,
+{
+    let mut seen = HashSet::new();
+    let mut duplicates = HashSet::new();
+
+    for item in items {
+        if !seen.insert(item) {
+            duplicates.insert(item);
+        }
+    }
+
+    if !duplicates.is_empty() {
+        let dup_list: Vec<&str> = duplicates.into_iter().collect();
+        bail!(
+            "team `{}` has duplicate {}: {}",
+            team_name,
+            label,
+            dup_list.join(", ")
+        );
+    }
+
+    Ok(())
+}
+
+/// Ensure no duplicate entries in team leads, members and alumni
 fn validate_duplicate_team_entries(data: &Data, errors: &mut Vec<String>) {
     wrapper(data.teams(), errors, |team, errors| {
-        // Check for duplicate members
-        let mut seen_members = HashSet::new();
-        for member in team.explicit_members() {
-            if !seen_members.insert(&member.github) {
-                errors.push(format!(
-                    "team `{}` has duplicate members: {}",
-                    team.name(),
-                    member.github
-                ));
-            }
+        // Check leads for duplicates
+        if let Err(e) = check_duplicates(
+            team.name(),
+            "leads",
+            team.explicit_leads().iter().map(|s| s.as_str()),
+        ) {
+            errors.push(e.to_string());
         }
 
-        // Check for duplicate alumni
-        let mut seen_alumni = HashSet::new();
-        for alum in team.explicit_alumni() {
-            if !seen_alumni.insert(&alum.github) {
-                errors.push(format!(
-                    "team `{}` has duplicate alumni: {}",
-                    team.name(),
-                    alum.github
-                ));
-            }
+        // Check members for duplicates
+        if let Err(e) = check_duplicates(
+            team.name(),
+            "members",
+            team.explicit_members().iter().map(|m| m.github.as_str()),
+        ) {
+            errors.push(e.to_string());
+        }
+
+        // Check alumni for duplicates
+        if let Err(e) = check_duplicates(
+            team.name(),
+            "alumni",
+            team.explicit_alumni().iter().map(|a| a.github.as_str()),
+        ) {
+            errors.push(e.to_string());
         }
 
         Ok(())