Merge pull request #192 from nikomatsakis/task-subsections

Subgoals via subsections

Author: nikomatsakis

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

@@ -18,7 +18,7 @@ use rust_project_goals::{
         },
         labels::GhLabel,
     },
-    goal::{self, GoalDocument, ParsedOwners, PlanItem, Status},
+    goal::{self, GoalDocument, GoalPlan, ParsedOwners, Status},
     team::{get_person_data, TeamName},
 };
 
@@ -324,8 +324,8 @@ fn issue<'doc>(timeframe: &str, document: &'doc GoalDocument) -> anyhow::Result<
 
 fn issue_text(timeframe: &str, document: &GoalDocument) -> anyhow::Result<String> {
     let mut tasks = vec![];
-    for plan_item in &document.plan_items {
-        tasks.extend(task_items(plan_item)?);
+    for goal_plan in &document.goal_plans {
+        tasks.extend(task_items(goal_plan)?);
     }
 
     let teams = document
@@ -361,35 +361,38 @@ fn issue_text(timeframe: &str, document: &GoalDocument) -> anyhow::Result<String
     ))
 }
 
-fn task_items(plan_item: &PlanItem) -> anyhow::Result<Vec<String>> {
+fn task_items(goal_plan: &GoalPlan) -> anyhow::Result<Vec<String>> {
     use std::fmt::Write;
 
+
     let mut tasks = vec![];
 
-    let mut description = format!(
-        "* {box} {text}",
-        box = if plan_item.is_complete() { "[x]" } else { "[ ]" },
-        text = plan_item.text
-    );
+    if let Some(title) = &goal_plan.subgoal {
+        tasks.push(format!("### {title}"));
+    }
 
-    if let Some(parsed_owners) = plan_item.parse_owners()? {
-        match parsed_owners {
-            ParsedOwners::TeamAsks(asks) => {
-                let teams: Vec<String> = asks.iter().map(|ask| ask.name_and_link()).collect();
+    for plan_item in &goal_plan.plan_items {
+        let mut description = format!(
+            "* {box} {text}",
+            box = if plan_item.is_complete() { "[x]" } else { "[ ]" },
+            text = plan_item.text
+        );
 
-                write!(description, " ({} ![Team][])", teams.join(", "))?;
-            }
+        if let Some(parsed_owners) = plan_item.parse_owners()? {
+            match parsed_owners {
+                ParsedOwners::TeamAsks(asks) => {
+                    let teams: Vec<String> = asks.iter().map(|ask| ask.name_and_link()).collect();
 
-            ParsedOwners::Usernames(usernames) => {
-                write!(description, " ({})", usernames.join(", "))?;
+                    write!(description, " ({} ![Team][])", teams.join(", "))?;
+                }
+
+                ParsedOwners::Usernames(usernames) => {
+                    write!(description, " ({})", usernames.join(", "))?;
+                }
             }
         }
-    }
-
-    tasks.push(description);
 
-    for task in &plan_item.children {
-        tasks.extend(task_items(task)?.into_iter().map(|t| format!("  {}", &t)));
+        tasks.push(description);
     }
 
     Ok(tasks)

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

@@ -30,7 +30,7 @@ pub struct GoalDocument {
     pub summary: String,
 
     /// The "plan" for completing the goal (includes things owners will do as well as team asks)
-    pub plan_items: Vec<PlanItem>,
+    pub goal_plans: Vec<GoalPlan>,
 
     /// List of team asks extracted from the goal
     pub team_asks: Vec<TeamAsk>,
@@ -50,13 +50,22 @@ pub struct Metadata {
 
 pub const TRACKING_ISSUE_ROW: &str = "Tracking issue";
 
+/// Items required to complete the goal.
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct GoalPlan {
+    /// If `Some`, title of the subsection in which these items were found.
+    pub subgoal: Option<String>,
+
+    /// List of items found in the table.
+    pub plan_items: Vec<PlanItem>,
+}
+
 /// Identifies a particular ask for a set of Rust teams
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct PlanItem {
     pub text: String,
     pub owners: String,
     pub notes: String,
-    pub children: Vec<PlanItem>,
 }
 
 /// Returns the "owner(s)" of a plan-item, which can be
@@ -116,20 +125,23 @@ impl GoalDocument {
 
         let link_path = Arc::new(link_path.to_path_buf());
 
-        let plan_items = match metadata.status {
+        let goal_plans = match metadata.status {
             Status::Flagship | Status::Accepted | Status::Proposed => {
                 extract_plan_items(&sections)?
             }
             Status::NotAccepted => vec![],
         };
 
         let mut team_asks = vec![];
-        for plan_item in &plan_items {
-            team_asks.extend(plan_item.team_asks(
-                &link_path,
-                &metadata.short_title,
-                &metadata.owners,
-            )?);
+        for goal_plan in &goal_plans {
+            let goal_title = goal_plan.subgoal.as_deref().unwrap_or(&metadata.short_title);
+            for plan_item in &goal_plan.plan_items {
+                team_asks.extend(plan_item.team_asks(
+                    &link_path,
+                    goal_title,
+                    &metadata.owners,
+                )?);
+            }
         }
 
         Ok(Some(GoalDocument {
@@ -138,7 +150,7 @@ impl GoalDocument {
             summary: summary.unwrap_or_else(|| metadata.title.clone()),
             metadata,
             team_asks,
-            plan_items,
+            goal_plans,
         }))
     }
 
@@ -201,7 +213,7 @@ pub fn format_team_asks(asks_of_any_team: &[&TeamAsk]) -> anyhow::Result<String>
 
         for subgoal in subgoals {
             table.push(vec![
-                format!("*{}*", subgoal),
+                format!("**{}**", subgoal),
                 "".to_string(),
                 "".to_string(),
             ]);
@@ -390,29 +402,52 @@ fn extract_summary(sections: &[Section]) -> anyhow::Result<Option<String>> {
     Ok(Some(ownership_section.text.trim().to_string()))
 }
 
-fn extract_plan_items<'i>(sections: &[Section]) -> anyhow::Result<Vec<PlanItem>> {
-    let Some(ownership_section) = sections
+fn extract_plan_items<'i>(sections: &[Section]) -> anyhow::Result<Vec<GoalPlan>> {
+    let Some(ownership_index) = sections
         .iter()
-        .find(|section| section.title == "Ownership and team asks")
+        .position(|section| section.title == "Ownership and team asks")
     else {
         anyhow::bail!("no `Ownership and team asks` section found")
     };
 
-    let Some(table) = ownership_section.tables.first() else {
-        anyhow::bail!(
-            "on line {}, no table found in `Ownership and team asks` section",
-            ownership_section.line_num
-        )
-    };
+    // Extract the plan items from the main section (if any)
+    let level= sections[ownership_index].level;
+
+    let mut goal_plans = vec![];
+    goal_plans.extend(goal_plan(None, &sections[ownership_index])?);
+
+    for subsection in sections.iter().skip(ownership_index + 1).take_while(|s| s.level > level) {
+        goal_plans.extend(goal_plan(Some(subsection.title.clone()), subsection)?);
+    }
 
-    expect_headers(table, &["Subgoal", "Owner(s) or team(s)", "Notes"])?;
+    if goal_plans.is_empty() {
+        anyhow::bail!("no goal table items found in the `Ownership and team asks` section or subsections")
+    }
+
+    Ok(goal_plans)
+}
 
-    let mut rows = table.rows.iter().peekable();
-    let mut plan_items = vec![];
-    while rows.peek().is_some() {
-        plan_items.push(extract_plan_item(&mut rows)?);
+fn goal_plan(subgoal: Option<String>, section: &Section) -> anyhow::Result<Option<GoalPlan>> {
+    match section.tables.len() {
+        0 => Ok(None),
+        1 => {
+            let table = &section.tables[0];
+            expect_headers(table, &["Task", "Owner(s) or team(s)", "Notes"])?;
+        
+            let mut rows = table.rows.iter().peekable();
+            let mut plan_items = vec![];
+            while rows.peek().is_some() {
+                plan_items.push(extract_plan_item(&mut rows)?);
+            }
+        
+            Ok(Some(GoalPlan {
+                subgoal,
+                plan_items,
+            }))
+        }
+        _ => anyhow::bail!("multiple goal tables found in section `{}`", section.title),
     }
-    Ok(plan_items)
+    
 }
 
 fn extract_plan_item(
@@ -422,33 +457,11 @@ fn extract_plan_item(
         anyhow::bail!("unexpected end of table");
     };
 
-    let mut subgoal = row[0].trim();
-    let mut is_child = false;
-
-    if subgoal.starts_with(ARROW) {
-        // e.g., "↳ stabilization" is a subtask of the metagoal
-        subgoal = row[0][ARROW.len()..].trim();
-        is_child = true;
-    }
-
-    let mut item = PlanItem {
-        text: subgoal.to_string(),
+    Ok(PlanItem {
+        text: row[0].to_string(),
         owners: row[1].to_string(),
         notes: row[2].to_string(),
-        children: vec![],
-    };
-
-    if !is_child {
-        while let Some(row) = rows.peek() {
-            if !row[0].starts_with(ARROW) {
-                break;
-            }
-
-            item.children.push(extract_plan_item(rows)?);
-        }
-    }
-
-    Ok(item)
+    })
 }
 
 impl PlanItem {
@@ -543,16 +556,6 @@ impl PlanItem {
             });
         }
 
-        for child in &self.children {
-            // If this item has owners listed, they take precedence, otherwise use the owners in scope.
-            let owners = if self.owners.is_empty() {
-                goal_owners
-            } else {
-                &self.owners
-            };
-            asks.extend(child.team_asks(link_path, &self.text, owners)?);
-        }
-
         Ok(asks)
     }
 }

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

@@ -4,11 +4,23 @@ use std::{fmt::Display, path::Path};
 
 use crate::util;
 
+/// A "section" is a piece of markdown that begins with `##` and which extends until the next section.
+/// Note that we don't track the hierarchical structure of sections in particular.
 #[derive(Debug)]
 pub struct Section {
+    /// Line numberin the document
     pub line_num: usize,
+
+    /// Number of hashes
+    pub level: usize,
+
+    /// Title of the section -- what came after the `#` in the markdown.
     pub title: String,
+
+    /// Markdown text until start of next section, excluding tables
     pub text: String,
+
+    /// Tables are parsed and stored here
     pub tables: Vec<Table>,
 }
 
@@ -30,10 +42,11 @@ pub fn parse(path: &Path) -> anyhow::Result<Vec<Section>> {
         // eprintln!("line = {:?}", line);
         // eprintln!("categorized = {:?}", categorized);
         match categorized {
-            CategorizeLine::Title(title) => {
+            CategorizeLine::Title(level, title) => {
                 close_section(&mut result, &mut open_section, &mut open_table);
                 open_section = Some(Section {
                     line_num,
+                    level,
                     title,
                     text: String::new(),
                     tables: vec![],
@@ -131,15 +144,16 @@ fn close_section(
 
 #[derive(Debug)]
 enum CategorizeLine {
-    Title(String),
+    Title(usize, String),
     TableRow(Vec<String>),
     TableDashRow(usize),
     Other,
 }
 
 fn categorize_line(line: &str) -> CategorizeLine {
     if line.starts_with('#') {
-        CategorizeLine::Title(line.trim_start_matches('#').trim().to_string())
+        let level = line.chars().take_while(|&ch| ch == '#').count();
+        CategorizeLine::Title(level, line.trim_start_matches('#').trim().to_string())
     } else if line.starts_with('|') && line.ends_with('|') {
         let line = &line[1..line.len() - 1];
         let columns = line.split('|').map(|s| s.trim());

src/2024h2/ATPIT.md

@@ -60,7 +60,7 @@ None.
 
 **Owner:** oli-obk owns this goal.
 
-| Subgoal                | Owner(s) or team(s)      | Notes |
+| Task                   | Owner(s) or team(s)      | Notes |
 |------------------------|--------------------------|-------|
 | Implementation         | @oli-obk                 |       |
 | FCP decision(s)           | ![Team][] [types]        |       |

src/2024h2/Patterns-of-empty-types.md

@@ -95,7 +95,7 @@ already for several months.
   the compiler team, but not more than the ordinary.
 
 
-| Subgoal                      | Owner(s) or team(s)  | Notes |
+| Task                         | Owner(s) or team(s)  | Notes |
 | ---------------------------- | -------------------- | ----- |
 | Author RFC                   | @Nadrieril           |       |
 | Implementation               | @Nadrieril           |       |

src/2024h2/Polonius.md

@@ -44,7 +44,7 @@ Other support provided by @amandasystems as part of her PhD.
 
 [amanda]: https://github.com/amandasystems
 
-| Subgoal          | Owner(s) or team(s)  | Notes          |
+| Task             | Owner(s) or team(s)  | Notes          |
 | ---------------- | -------------------- | -------------- |
 | Design review    | @nikomatsakis        |                |
 | Implementation   | @lqd, @amandasystems |                |

src/2024h2/Project-goal-slate.md

@@ -77,7 +77,7 @@ More concretely, assuming this goal program is successful, we would like to begi
 
 * @nikomatsakis can commit 20% time (avg of 1 days per week) to pursue this task, which he estimates to be sufficient.
 
-| Subgoal                                    | Owner(s) or team(s)            | Notes                                                                                     |
+| Task                                       | Owner(s) or team(s)            | Notes                                                                                     |
 | ------------------------------------------ | ------------------------------ | ----------------------------------------------------------------------------------------- |
 | RFC decision                               | ![Team][] [leadership-council] | ![Complete][]                                                                             |
 | Inside Rust blog post inviting feedback    |                                | [Posted](https://blog.rust-lang.org/inside-rust/2024/05/07/announcing-project-goals.html) |

src/2024h2/Relaxing-the-Orphan-Rule.md

@@ -119,7 +119,7 @@ This section defines the specific work items that are planned and who is expecte
     * List ![Help wanted][] if there is an owner but they need support, for example funding.
     * Other needs (e.g., complete, in FCP, etc) are also fine.
 
-| Subgoal                       | Owner(s) or team(s)      | Notes                      |
+| Task                          | Owner(s) or team(s)      | Notes                      |
 | ----------------------------- | ------------------------ | -------------------------- |
 | Ownership and implementation  | ![Help wanted][]         |                            |
 | RFC authoring                 | ![Help wanted][]         |                            |

src/2024h2/Rust-2024-Edition.md

@@ -51,7 +51,7 @@ The "Edition Axioms" were [laid out in RFC #3085](https://rust-lang.github.io/rf
 
 **Owner:** @traviscross
 
-| Subgoal                  | Owner(s) or team(s)            | Notes                       |
+| Task                     | Owner(s) or team(s)            | Notes                       |
 | ------------------------ | ------------------------------ | --------------------------- |
 | RFC decision             | ![Team][] [leadership-council] | ![Complete][] ([RFC #3501]) |
 | Stabilization decision   | ![Team][] [lang] [types]       |                             |