load data properly for the edition

Author: nikomatsakis

mdbook-goals/src/gh/issues.rs

@@ -77,6 +77,47 @@ impl std::fmt::Display for ExistingIssueState {
     }
 }
 
+pub struct CountIssues {
+    pub open: u32,
+    pub closed: u32,
+}
+
+pub fn count_issues_matching_search(
+    repository: &Repository,
+    search: &str,
+) -> anyhow::Result<CountIssues> {
+    #[derive(Deserialize)]
+    struct JustState {
+        state: ExistingIssueState,
+    }
+
+    let output = Command::new("gh")
+        .arg("-R")
+        .arg(&repository.to_string())
+        .arg("issue")
+        .arg("list")
+        .arg("-S")
+        .arg(search)
+        .arg("-s")
+        .arg("all")
+        .arg("--json")
+        .arg("state")
+        .output()?;
+
+    let existing_issues: Vec<JustState> = serde_json::from_slice(&output.stdout)?;
+
+    let mut count_issues = CountIssues { open: 0, closed: 0 };
+
+    for issue in &existing_issues {
+        match issue.state {
+            ExistingIssueState::Open => count_issues.open += 1,
+            ExistingIssueState::Closed => count_issues.closed += 1,
+        }
+    }
+
+    Ok(count_issues)
+}
+
 pub fn list_issue_titles_in_milestone(
     repository: &Repository,
     timeframe: &str,

mdbook-goals/src/goal.rs

@@ -258,7 +258,7 @@ pub fn format_goal_table(goals: &[&GoalDocument]) -> anyhow::Result<String> {
 
             let progress_bar = match &goal.metadata.tracking_issue {
                 Some(issue_id @ IssueId { repository: Repository { org, repo }, number }) => format!(
-                    "<a href='{url}' alt='Tracking issue'><progress id='{milestone}:{org}:{repo}:{number}' value='0' max='100'></progress></a>",
+                    "<a href='{url}' alt='Tracking issue'><div class='tracking-issue-progress' id='{milestone}:{org}:{repo}:{number}'></div></a>",
                     url = issue_id.url(),
                 ),
                 None => format!("(no tracking issue)"),

mdbook-goals/src/json.rs

@@ -6,16 +6,16 @@
 //! to the types in `gh` and so forth but because they represent
 //! a versioned API, we copy them over here to insulate them from incidental changes.
 
-use std::path::PathBuf;
+use std::{path::PathBuf, str::FromStr};
 
 use serde::Serialize;
 
 use crate::{
     gh::{
         issue_id::Repository,
         issues::{
-            list_issue_titles_in_milestone, ExistingGithubComment, ExistingGithubIssue,
-            ExistingIssueState,
+            count_issues_matching_search, list_issue_titles_in_milestone, CountIssues,
+            ExistingGithubComment, ExistingGithubIssue, ExistingIssueState,
         },
     },
     re,
@@ -32,13 +32,17 @@ pub(super) fn generate_json(
         issues: issues
             .into_iter()
             .map(|(title, issue)| {
-                let (total_checkboxes, checked_checkboxes) = checkboxes(&issue);
+                let progress = match checkboxes(&issue) {
+                    Ok(pair) => pair,
+                    Err(e) => Progress::Error {
+                        message: e.to_string(),
+                    },
+                };
                 TrackingIssue {
                     number: issue.number,
                     title,
                     flagship: is_flagship(&issue),
-                    total_checkboxes,
-                    checked_checkboxes,
+                    progress,
                     assignees: issue.assignees.into_iter().collect(),
                     updates: updates(issue.comments),
                     state: issue.state,
@@ -80,11 +84,8 @@ struct TrackingIssue {
     /// True if this is a flagship goal
     flagship: bool,
 
-    /// Total checkboxes appearing in the body (i.e., `* [ ]` or `* [x]`)
-    total_checkboxes: u32,
-
-    /// Checked checkboxes appearing in the body (i.e., `* [x]`)
-    checked_checkboxes: u32,
+    /// State of progress
+    progress: Progress,
 
     /// Set of assigned people
     assignees: Vec<String>,
@@ -96,6 +97,23 @@ struct TrackingIssue {
     state: ExistingIssueState,
 }
 
+#[derive(Serialize)]
+enum Progress {
+    /// We could not find any checkboxes or other deatils on the tracking issue.
+    /// So all we have is "open" or "closed".
+    Binary,
+
+    /// We found checkboxes or  issue listing.
+    Tracked {
+        completed: u32,
+        total: u32,
+    },
+
+    Error {
+        message: String,
+    },
+}
+
 #[derive(Serialize)]
 struct TrackingIssueUpdate {
     pub author: String,
@@ -105,21 +123,49 @@ struct TrackingIssueUpdate {
     pub url: String,
 }
 
-fn checkboxes(issue: &ExistingGithubIssue) -> (u32, u32) {
-    let mut total = 0;
-    let mut checked = 0;
+/// Identify how many sub-items have been completed.
+/// These can be encoded in two different ways:
+///
+/// * Option A, the most common, is to have checkboxes in the issue. We just count the number that are checked.
+/// * Option B is to include a metadata line called "Tracked issues" that lists a search query. We count the number of open vs closed issues in that query.
+///
+/// Returns a tuple (completed, total) with the number of completed items and the total number of items.
+fn checkboxes(issue: &ExistingGithubIssue) -> anyhow::Result<Progress> {
+    let mut checkboxes = None;
+    let mut issues = None;
 
     for line in issue.body.lines() {
-        if re::CHECKBOX.is_match(line) {
-            total += 1;
+        // Does this match TRACKED_ISSUES?
+        if let Some(c) = re::TRACKED_ISSUES_QUERY.captures(line) {
+            let repo = Repository::from_str(&c[1])?;
+            let query = &c[2];
+
+            if issues.is_some() {
+                anyhow::bail!("found multiple search queries for Tracked Issues");
+            }
+
+            let CountIssues { open, closed } = count_issues_matching_search(&repo, query)?;
+            issues = Some((closed, open + closed));
         }
 
+        let (checked, total) = checkboxes.unwrap_or((0, 0));
+
         if re::CHECKED_CHECKBOX.is_match(line) {
-            checked += 1;
+            checkboxes = Some((checked + 1, total + 1));
+        } else if re::CHECKBOX.is_match(line) {
+            checkboxes = Some((checked, total + 1));
         }
     }
 
-    (total, checked)
+    eprintln!("#{}: {checkboxes:?}, {issues:?}", issue.number);
+
+    match (checkboxes, issues) {
+        (Some((completed, total)), None) | (None, Some((completed, total))) => {
+            Ok(Progress::Tracked { completed, total })
+        }
+        (None, None) => Ok(Progress::Binary),
+        (Some(_), Some(_)) => anyhow::bail!("found both Tracked Issues and checkboxes"),
+    }
 }
 
 fn is_flagship(issue: &ExistingGithubIssue) -> bool {

mdbook-goals/src/re.rs

@@ -32,3 +32,8 @@ lazy_static! {
 lazy_static! {
     pub static ref CHECKED_CHECKBOX: Regex = Regex::new(r"\s*[-*] \[x\] ").unwrap();
 }
+
+lazy_static! {
+    pub static ref TRACKED_ISSUES_QUERY: Regex =
+        Regex::new(r"^\| *Tracked +issues *\| *\[([^ ]*) ([^]]*)\]\(.*\) *\| *$").unwrap();
+}

src/how_to/report_status.md

@@ -4,6 +4,16 @@ Every accepted project goal has an associated tracking issue.
 
 Owners are expected to provide regular status updates in the form of a comment indicating how things are going.
 
+## Documenting your plan and your progress
+
+To help users
+
+### Checkboxes
+
+The deafult
+
+### Search queries
+
 ## Status updates are reported out
 
 The status updates from the tracking issues are used to author a blog post for Inside Rust on a monthly basis.