command to synchronize team-repository

Author: nikomatsakis

mdbook-goals/src/main.rs

@@ -12,6 +12,7 @@ mod mdbook_preprocessor;
 mod re;
 mod rfc;
 mod team;
+mod team_repo;
 mod util;
 
 #[derive(StructOpt, Debug)]
@@ -51,6 +52,17 @@ enum Command {
         commit: bool,
     },
 
+    /// Generate the project-goal-owners team based on the owners found in `paths`.
+    TeamRepo {
+        /// Paths to the directories containing the goals (e.g., `src/2024h2`)
+        #[structopt(required = true, min_values = 1)]
+        path: Vec<PathBuf>,
+
+        /// Paths to the teams repository checkout
+        #[structopt(required = true, long = "team-repo")]
+        team_repo_path: PathBuf,
+    },
+
     /// Checks that the goal documents are well-formed, intended for use within CI
     Check {},
 }
@@ -83,6 +95,13 @@ fn main() -> anyhow::Result<()> {
             rfc::generate_issues(&opt.repository, path, *commit, *sleep)?;
         }
 
+        Some(Command::TeamRepo {
+            path,
+            team_repo_path,
+        }) => {
+            team_repo::generate_team_repo(&path, team_repo_path)?;
+        }
+
         None => {
             handle_preprocessing(&GoalPreprocessor)?;
         }

mdbook-goals/src/mdbook_preprocessor.rs

@@ -314,7 +314,7 @@ impl<'c> GoalPreprocessorWithContext<'c> {
         }
 
         let display_name = match team::get_person_data(username)? {
-            Some(person) => person.name.clone(),
+            Some(person) => person.data.name.clone(),
             None => match GithubUserInfo::load(username)
                 .with_context(|| format!("loading user info for {}", username))
             {

mdbook-goals/src/rfc.rs

@@ -1,4 +1,3 @@
-use core::time;
 use std::{
     collections::BTreeSet,
     fmt::Display,

mdbook-goals/src/team.rs

@@ -16,15 +16,31 @@ impl<T> Load<T> for OnceLock<anyhow::Result<T>> {
     }
 }
 
+pub struct PersonData {
+    /// NB: May be capitalized differently than what we get as input
+    pub github_username: String,
+
+    /// Data from the Rust team repo
+    pub data: v1::Person,
+}
+
 /// Given a username like `@foo` finds the corresponding person data (if any).
-pub fn get_person_data(username: &str) -> anyhow::Result<Option<&'static v1::Person>> {
-    static DATA: OnceLock<anyhow::Result<BTreeMap<String, v1::Person>>> = OnceLock::new();
+pub fn get_person_data(username: &str) -> anyhow::Result<Option<&'static PersonData>> {
+    static DATA: OnceLock<anyhow::Result<BTreeMap<String, PersonData>>> = OnceLock::new();
     let people = DATA.load(|| {
         let data: v1::People = fetch("people.json")?;
         Ok(data
             .people
             .into_iter()
-            .map(|(username, value)| (username.to_lowercase(), value))
+            .map(|(username, value)| {
+                (
+                    username.to_lowercase(),
+                    PersonData {
+                        github_username: username,
+                        data: value,
+                    },
+                )
+            })
             .collect())
     })?;
 

mdbook-goals/src/team_repo.rs

@@ -0,0 +1,107 @@
+use std::collections::BTreeSet;
+use std::fmt::Write;
+use std::process::Command;
+
+use anyhow::Context;
+
+use crate::{goal, team};
+
+pub(crate) fn generate_team_repo(
+    paths: &[std::path::PathBuf],
+    team_repo_path: &std::path::PathBuf,
+) -> anyhow::Result<()> {
+    if !team_repo_path.is_dir() {
+        anyhow::bail!(
+            "output path not a directory: `{}`",
+            team_repo_path.display()
+        );
+    }
+
+    let mut goal_documents = vec![];
+    for path in paths {
+        goal_documents.extend(goal::goals_in_dir(path)?);
+    }
+
+    let owners: BTreeSet<&str> = goal_documents
+        .iter()
+        .flat_map(|doc| doc.metadata.owner_usernames())
+        .collect();
+
+    progress_bar::init_progress_bar(owners.len() + 1);
+
+    progress_bar::set_progress_bar_action(
+        "Team file",
+        progress_bar::Color::Blue,
+        progress_bar::Style::Bold,
+    );
+    let team_file = team_file(&owners)?;
+    let team_toml_file = team_repo_path.join("teams").join("goal-owners.toml");
+    std::fs::write(&team_toml_file, team_file)
+        .with_context(|| format!("writing to `{}`", team_toml_file.display()))?;
+    progress_bar::inc_progress_bar();
+
+    // generate rudimentary people files if needed
+    progress_bar::set_progress_bar_action(
+        "People",
+        progress_bar::Color::Blue,
+        progress_bar::Style::Bold,
+    );
+    for owner in owners {
+        ensure_person_file(owner, team_repo_path)?;
+        progress_bar::inc_progress_bar();
+    }
+
+    progress_bar::finalize_progress_bar();
+
+    Ok(())
+}
+
+fn ensure_person_file(owner: &str, team_repo_path: &std::path::PathBuf) -> anyhow::Result<()> {
+    let person_toml_file = team_repo_path
+        .join("people")
+        .join(&owner[1..])
+        .with_extension("toml");
+
+    if person_toml_file.exists() {
+        return Ok(());
+    }
+
+    if team::get_person_data(owner)?.is_some() {
+        return Ok(()); // person already exists
+    }
+
+    let status = Command::new("cargo")
+        .arg("run")
+        .arg("-q")
+        .arg("--")
+        .arg("add-person")
+        .arg(&owner[1..])
+        .current_dir(team_repo_path)
+        .status()
+        .with_context(|| format!("running `cargo run add-person` for {owner}"))?;
+
+    if !status.success() {
+        anyhow::bail!("`cargo run add-person` failed for {owner}");
+    }
+
+    Ok(())
+}
+
+fn team_file(owners: &BTreeSet<&str>) -> anyhow::Result<String> {
+    let mut out = String::new();
+    writeln!(out, "name = \"goal-owners\"")?;
+    writeln!(out, "kind = \"marker-team\"")?;
+    writeln!(out, "")?;
+    writeln!(out, "[people]")?;
+    writeln!(out, "leads = []")?;
+    writeln!(out, "members = [")?;
+    for owner in owners {
+        match team::get_person_data(owner)? {
+            Some(p) => writeln!(out, "    \"{}\",", &p.github_username)?,
+            None => writeln!(out, "    \"{}\",", &owner[1..])?,
+        }
+    }
+    writeln!(out, "]")?;
+    writeln!(out, "included-teams = []")?;
+    Ok(out)
+}