add champions to metadata and add new CSV command (#369)

* parse metadata for champions

The intent is that we will use this to create CSV

* add a CSV command to generate a champion table

Author: nikomatsakis

crates/rust-project-goals-cli/src/csv_reports.rs

@@ -0,0 +1,114 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::PathBuf;
+
+use rust_project_goals::{
+    gh::issue_id::Repository,
+    goal,
+    spanned::{Result, Spanned},
+    team::TeamName,
+};
+
+use crate::CSVReports;
+
+pub fn csv(repository: &Repository, cmd: &CSVReports) -> Result<()> {
+    match cmd {
+        CSVReports::Champions { milestone } => champions(repository, milestone)?,
+    }
+    Ok(())
+}
+
+struct ChampionRow {
+    title: String,
+    url: String,
+    pocs: String,
+    champions: BTreeMap<&'static TeamName, Spanned<String>>,
+    teams_with_asks: BTreeSet<&'static TeamName>,
+}
+
+fn champions(repository: &Repository, milestone: &str) -> Result<()> {
+    let mut milestone_path = PathBuf::from("src");
+    milestone_path.push(milestone);
+
+    let goal_documents = goal::goals_in_dir(&milestone_path)?;
+
+    let all_teams: BTreeSet<&TeamName> = goal_documents
+        .iter()
+        .flat_map(|d| d.teams_with_asks())
+        .collect();
+
+    let rows: Vec<ChampionRow> = goal_documents
+        .iter()
+        .map(|doc| ChampionRow {
+            title: doc.metadata.title.clone(),
+            url: format!(
+                "https://github.com/{org}/{repo}/blob/main/{path}",
+                org = repository.org,
+                repo = repository.repo,
+                path = doc.path.display()
+            ),
+            pocs: doc.metadata.pocs.clone(),
+            champions: doc.metadata.champions.clone(),
+            teams_with_asks: doc.teams_with_asks(),
+        })
+        .collect();
+
+    // Write header row
+    write_csv_row(|cell| {
+        cell.write_cell("Title");
+        cell.write_cell("POC(s)");
+        for team in &all_teams {
+            cell.write_cell(&format!("{team}"));
+        }
+        cell.write_cell("URL");
+    });
+
+    // Write data rows
+    for row in &rows {
+        write_csv_row(|cell| {
+            cell.write_cell(&row.title);
+            cell.write_cell(&row.pocs);
+
+            for team in &all_teams {
+                if row.teams_with_asks.contains(team) {
+                    // Team has an ask - check if there's a champion
+                    if let Some(champion) = row.champions.get(team) {
+                        cell.write_cell(champion);
+                    } else {
+                        cell.write_cell("!");
+                    }
+                } else {
+                    // Team has no ask for this goal
+                    cell.write_cell("-");
+                }
+            }
+
+            cell.write_cell(&row.url);
+        });
+    }
+
+    Ok(())
+}
+
+trait WriteCell {
+    fn write_cell(&mut self, s: &str);
+}
+
+impl WriteCell for String {
+    fn write_cell(&mut self, s: &str) {
+        let mut s = s.replace(r#"""#, r#"\""#);
+        s = s.replace("\n", "\\n");
+
+        if !self.is_empty() {
+            self.push(',');
+        }
+        self.push('"');
+        self.push_str(&s);
+        self.push('"');
+    }
+}
+
+fn write_csv_row(op: impl FnOnce(&mut dyn WriteCell)) {
+    let mut s = String::new();
+    op(&mut s);
+    println!("{s}");
+}

crates/rust-project-goals-cli/src/main.rs

@@ -8,6 +8,7 @@ use std::path::PathBuf;
 use walkdir::WalkDir;
 
 mod cfp;
+mod csv_reports;
 mod generate_json;
 mod rfc;
 mod team_repo;
@@ -109,6 +110,21 @@ enum Command {
         /// If not given, no end date.
         end_date: Option<chrono::NaiveDate>,
     },
+
+    /// Generate various CSV reports
+    CSV {
+        #[command(subcommand)]
+        cmd: CSVReports,
+    },
+}
+
+#[derive(clap::Subcommand, Debug)]
+#[allow(dead_code)]
+enum CSVReports {
+    Champions {
+        /// Milestone for which we generate tracking issue data (e.g., `2024h2`).
+        milestone: String,
+    },
 }
 
 fn main() -> Result<()> {
@@ -160,6 +176,7 @@ fn main() -> Result<()> {
         } => {
             generate_json::generate_json(&opt.repository, &milestone, json_path)?;
         }
+
         Command::Updates {
             milestone,
             vscode,
@@ -174,6 +191,8 @@ fn main() -> Result<()> {
             end_date,
             *vscode,
         )?,
+
+        Command::CSV { cmd } => csv_reports::csv(&opt.repository, cmd)?,
     }
 
     Ok(())

crates/rust-project-goals/src/goal.rs

@@ -1,3 +1,4 @@
+use std::collections::BTreeMap;
 use std::path::Path;
 use std::sync::Arc;
 use std::{collections::BTreeSet, path::PathBuf};
@@ -8,7 +9,7 @@ use spanned::{Error, Result, Spanned};
 use crate::config::{Configuration, TeamAskDetails};
 use crate::gh::issue_id::{IssueId, Repository};
 use crate::markwaydown::{self, Section, Table};
-use crate::re::{self, TASK_OWNERS_STR, TEAMS_WITH_ASKS_STR};
+use crate::re::{self, CHAMPION_METADATA, TASK_OWNERS_STR, TEAMS_WITH_ASKS_STR};
 use crate::team::{self, TeamName};
 use crate::util::{self, commas, markdown_files};
 
@@ -48,6 +49,9 @@ pub struct Metadata {
     pub status: Spanned<Status>,
     pub tracking_issue: Option<IssueId>,
     pub table: Spanned<Table>,
+
+    /// For each table entry like `[T-lang] champion`, we create an entry in this map
+    pub champions: BTreeMap<&'static TeamName, Spanned<String>>,
 }
 
 pub const TRACKING_ISSUE_ROW: &str = "Tracking issue";
@@ -440,6 +444,39 @@ fn extract_metadata(sections: &[Section]) -> Result<Option<Metadata>> {
     verify_row(&first_table.rows, "Teams", TEAMS_WITH_ASKS_STR)?;
     verify_row(&first_table.rows, "Task owners", TASK_OWNERS_STR)?;
 
+    let mut champions = BTreeMap::default();
+    for row in &first_table.rows {
+        let row_name = &row[0];
+        let row_value = &row[1];
+
+        if !row_name.to_lowercase().contains("champion") {
+            continue;
+        }
+
+        if let Some(m) = CHAMPION_METADATA.captures(row_name) {
+            let team_name = m.name("team").unwrap().as_str().to_string();
+
+            let Some(team) = team::get_team_name(&team_name)? else {
+                spanned::bail!(row_name, "team `{team_name}` is not recognized")
+            };
+
+            if champions.contains_key(team) {
+                spanned::bail!(
+                    row_name,
+                    "multiple rows naming champions for team `{team_name}`"
+                )
+            } else {
+                champions.insert(team, row_value.clone());
+            }
+        } else {
+            spanned::bail!(
+                row_name,
+                "metadata row `{}` talks about champions but is not of the form `[team-name] champion`",
+                &**row_name
+            )
+        }
+    }
+
     Ok(Some(Metadata {
         title: title.to_string(),
         short_title: if let Some(row) = short_title_row {
@@ -451,6 +488,7 @@ fn extract_metadata(sections: &[Section]) -> Result<Option<Metadata>> {
         status,
         tracking_issue: issue,
         table: first_table.clone(),
+        champions,
     }))
 }
 

crates/rust-project-goals/src/re.rs

@@ -110,3 +110,10 @@ lazy_static! {
 
 /// If a comment begins with this text, it will be considered a summary.
 pub const TLDR: &str = "TL;DR:";
+
+lazy_static! {
+    /// Metadata table rows like `[lang] champion` indicate the champion for the lang team
+    pub static ref CHAMPION_METADATA: Regex =
+        Regex::new(r"^\s*(?P<team>\[.*\]) champion)\s*$")
+            .unwrap();
+}

src/admin/commands.md

@@ -29,3 +29,39 @@ Note that after running this command, you'll still need to manually:
 2. Send an email to the `[email protected]` mailing list
 
 For more details, see the [Call for proposals](./cfp.md) documentation.
+
+### `cargo rpg csv`
+
+Generates CSV reports for analysis and tracking purposes. Currently supports generating champion tracking reports.
+
+```bash
+# Generate champions report for a milestone
+cargo rpg csv champions <milestone>
+```
+
+Example:
+```bash
+cargo rpg csv champions 2025h2
+```
+
+#### `champions` subcommand
+
+The `champions` subcommand generates a CSV report showing the champion assignments for each goal in a milestone. The output includes:
+
+- **Title**: The goal title
+- **POC(s)**: Point of contact for the goal
+- **Team columns**: One column per team that has asks across all goals in the milestone
+  - Shows champion name if assigned
+  - Shows `!` if team has an ask but no champion assigned
+  - Shows `-` if team has no ask for this goal
+- **URL**: Link to the goal document on GitHub
+
+This report is useful for:
+- Tracking champion coverage across teams
+- Identifying goals that need champion assignments
+- Understanding team involvement across the milestone
+
+The CSV output can be redirected to a file or piped to other tools for further analysis:
+```bash
+cargo rpg csv champions 2025h2 > champions.csv
+```