Use new spanned diagnostics everywhere

Author: oli-obk

Cargo.lock

@@ -233,13 +233,16 @@ impl<'c> GoalPreprocessorWithContext<'c> {
 
             // Extract out the list of goals with the given status.
             let goals = self.goal_documents(chapter_path)?;
-            let mut goals_with_status: Vec<&GoalDocument> =
-                goals.iter().filter(|g| filter(g.metadata.status)).collect();
+            let mut goals_with_status: Vec<&GoalDocument> = goals
+                .iter()
+                .filter(|g| filter(g.metadata.status.content))
+                .collect();
 
             goals_with_status.sort_by_key(|g| &g.metadata.title);
 
             // Format the list of goals and replace the `<!-- -->` comment with that.
-            let output = goal::format_goal_table(&goals_with_status)?;
+            let output =
+                goal::format_goal_table(&goals_with_status).map_err(|e| anyhow::anyhow!("{e}"))?;
             chapter.content.replace_range(range, &output);
 
             // Populate with children if this is not README
@@ -281,7 +284,8 @@ impl<'c> GoalPreprocessorWithContext<'c> {
             .filter(|g| g.metadata.status.is_not_not_accepted())
             .flat_map(|g| &g.team_asks)
             .collect();
-        let format_team_asks = format_team_asks(&asks_of_any_team)?;
+        let format_team_asks =
+            format_team_asks(&asks_of_any_team).map_err(|e| anyhow::anyhow!("{e}"))?;
         chapter.content.replace_range(range, &format_team_asks);
 
         Ok(())
@@ -323,7 +327,8 @@ impl<'c> GoalPreprocessorWithContext<'c> {
             return Ok(goals.clone());
         }
 
-        let goal_documents = goal::goals_in_dir(&self.ctx.config.book.src.join(milestone_path))?;
+        let goal_documents = goal::goals_in_dir(&self.ctx.config.book.src.join(milestone_path))
+            .map_err(|e| anyhow::anyhow!("{e}"))?;
         let goals = Arc::new(goal_documents);
         self.goal_document_map
             .insert(milestone_path.to_path_buf(), goals.clone());
@@ -380,19 +385,21 @@ impl<'c> GoalPreprocessorWithContext<'c> {
             return Ok(n.clone());
         }
 
-        let display_name = match team::get_person_data(username)? {
-            Some(person) => person.data.name.clone(),
-            None => match GithubUserInfo::load(username)
-                .with_context(|| format!("loading user info for {}", username))
-            {
-                Ok(GithubUserInfo { name: Some(n), .. }) => n,
-                Ok(GithubUserInfo { name: None, .. }) => username.to_string(),
-                Err(e) => {
-                    eprintln!("{:?}", e);
-                    username.to_string()
-                }
-            },
-        };
+        let display_name =
+            match team::get_person_data(username).map_err(|e| anyhow::anyhow!("{e}"))? {
+                Some(person) => person.data.name.clone(),
+                None => match GithubUserInfo::load(username)
+                    .map_err(|e| anyhow::anyhow!("{e}"))
+                    .with_context(|| format!("loading user info for {}", username))
+                {
+                    Ok(GithubUserInfo { name: Some(n), .. }) => n,
+                    Ok(GithubUserInfo { name: None, .. }) => username.to_string(),
+                    Err(e) => {
+                        eprintln!("{:?}", e);
+                        username.to_string()
+                    }
+                },
+            };
         let display_name = Rc::new(display_name);
         self.display_names
             .insert(username.to_string(), display_name.clone());
@@ -421,7 +428,7 @@ impl<'c> GoalPreprocessorWithContext<'c> {
 
     fn link_teams(&self, chapter: &mut Chapter) -> anyhow::Result<()> {
         chapter.content.push_str("\n\n");
-        for team in team::get_team_names()? {
+        for team in team::get_team_names().map_err(|e| anyhow::anyhow!("{e}"))? {
             chapter
                 .content
                 .push_str(&format!("{team}: {}\n", team.url()));

crates/mdbook-goals/src/mdbook_preprocessor.rs

@@ -1,5 +1,6 @@
-use anyhow::{Context, Result};
 use regex::Regex;
+use rust_project_goals::spanned::{Error, Spanned};
+use rust_project_goals::{spanned::Context as _, spanned::Result};
 use std::fs::{self, File};
 use std::io::Write;
 use std::path::{Path, PathBuf};
@@ -288,8 +289,9 @@ pub fn create_cfp(timeframe: &str, force: bool, dry_run: bool) -> Result<()> {
             println!("Would create/overwrite directory: {}", dir_path.display());
         }
     } else if !dry_run {
-        fs::create_dir_all(&dir_path)
-            .with_context(|| format!("Failed to create directory {}", dir_path.display()))?;
+        fs::create_dir_all(&dir_path).with_context(|| {
+            Spanned::here(format!("Failed to create directory {}", dir_path.display()))
+        })?;
         println!("Created directory: {}", dir_path.display());
     } else {
         println!("Would create directory: {}", dir_path.display());
@@ -342,7 +344,7 @@ pub fn create_cfp(timeframe: &str, force: bool, dry_run: bool) -> Result<()> {
 fn validate_timeframe(timeframe: &str) -> Result<()> {
     let re = Regex::new(r"^\d{4}[hH][12]$").unwrap();
     if !re.is_match(timeframe) {
-        anyhow::bail!("Invalid timeframe format. Expected format: YYYYhN or YYYYHN (e.g., 2025h1, 2025H1, 2025h2, or 2025H2)");
+        return Err(Error::str("Invalid timeframe format. Expected format: YYYYhN or YYYYHN (e.g., 2025h1, 2025H1, 2025h2, or 2025H2"));
     }
     Ok(())
 }
@@ -356,8 +358,7 @@ fn copy_and_process_template(
     dry_run: bool,
 ) -> Result<()> {
     // Read the template file
-    let template_content = fs::read_to_string(template_path)
-        .with_context(|| format!("Failed to read template file: {}", template_path))?;
+    let template_content = Spanned::read_str_from_file(template_path).transpose()?;
 
     // Use the pure function to process the content
     let processed_content = text_processing::process_template_content(
@@ -369,9 +370,9 @@ fn copy_and_process_template(
     // Write to destination file
     if !dry_run {
         File::create(dest_path)
-            .with_context(|| format!("Failed to create file: {}", dest_path.display()))?
+            .with_path_context(dest_path, "Failed to create file")?
             .write_all(processed_content.as_bytes())
-            .with_context(|| format!("Failed to write to file: {}", dest_path.display()))?;
+            .with_path_context(dest_path, "Failed to write to file")?;
 
         println!("Created file: {}", dest_path.display());
     } else {
@@ -383,8 +384,7 @@ fn copy_and_process_template(
 /// Updates the SUMMARY.md file to include the new timeframe section
 fn update_summary_md(timeframe: &str, lowercase_timeframe: &str, dry_run: bool) -> Result<()> {
     let summary_path = "src/SUMMARY.md";
-    let content =
-        fs::read_to_string(summary_path).with_context(|| format!("Failed to read SUMMARY.md"))?;
+    let content = fs::read_to_string(summary_path).with_str_context("Failed to read SUMMARY.md")?;
 
     // Use the pure function to process the content
     let new_content =
@@ -408,8 +408,7 @@ fn update_summary_md(timeframe: &str, lowercase_timeframe: &str, dry_run: bool)
 
     // Write the updated content back to SUMMARY.md
     if !dry_run {
-        fs::write(summary_path, new_content)
-            .with_context(|| format!("Failed to write to SUMMARY.md"))?;
+        fs::write(summary_path, new_content).with_str_context("Failed to write to SUMMARY.md")?;
 
         println!("Updated SUMMARY.md with {} section", timeframe);
     } else {
@@ -422,8 +421,7 @@ fn update_summary_md(timeframe: &str, lowercase_timeframe: &str, dry_run: bool)
 /// Updates the src/README.md with information about the new timeframe
 fn update_main_readme(timeframe: &str, lowercase_timeframe: &str, dry_run: bool) -> Result<()> {
     let readme_path = "src/README.md";
-    let content =
-        fs::read_to_string(readme_path).with_context(|| format!("Failed to read README.md"))?;
+    let content = fs::read_to_string(readme_path).with_str_context("Failed to read README.md")?;
 
     // Use the pure function to process the content
     let new_content =
@@ -495,8 +493,7 @@ fn update_main_readme(timeframe: &str, lowercase_timeframe: &str, dry_run: bool)
 
     // Write the updated content back to README.md
     if !dry_run {
-        fs::write(readme_path, new_content)
-            .with_context(|| format!("Failed to write to src/README.md"))?;
+        fs::write(readme_path, new_content).with_str_context("Failed to write to src/README.md")?;
     }
 
     Ok(())

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

@@ -4,13 +4,14 @@ use rust_project_goals::gh::{
     issue_id::Repository,
     issues::{checkboxes, list_issues_in_milestone, ExistingGithubComment},
 };
+use rust_project_goals::spanned::Result;
 use rust_project_goals_json::{TrackingIssue, TrackingIssueUpdate, TrackingIssues};
 
 pub(super) fn generate_json(
     repository: &Repository,
     milestone: &str,
     json_path: &Option<PathBuf>,
-) -> anyhow::Result<()> {
+) -> Result<()> {
     let issues = list_issues_in_milestone(repository, milestone)?;
 
     let issues = TrackingIssues {

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

@@ -1,7 +1,9 @@
-use anyhow::Context;
 use clap::Parser;
 use regex::Regex;
-use rust_project_goals::gh::issue_id::Repository;
+use rust_project_goals::{
+    gh::issue_id::Repository,
+    spanned::{Result, Spanned},
+};
 use std::path::PathBuf;
 use walkdir::WalkDir;
 
@@ -109,7 +111,7 @@ enum Command {
     },
 }
 
-fn main() -> anyhow::Result<()> {
+fn main() -> Result<()> {
     let opt: Opt = Opt::parse();
 
     match &opt.cmd {
@@ -138,8 +140,11 @@ fn main() -> anyhow::Result<()> {
             commit,
             sleep,
         } => {
-            rfc::generate_issues(&opt.repository, path, *commit, *sleep)
-                .with_context(|| format!("failed to adjust issues; rerun command to resume"))?;
+            rfc::generate_issues(&opt.repository, path, *commit, *sleep).map_err(|e| {
+                e.wrap_str(Spanned::here(
+                    "failed to adjust issues; rerun command to resume",
+                ))
+            })?;
         }
 
         Command::TeamRepo {
@@ -174,7 +179,7 @@ fn main() -> anyhow::Result<()> {
     Ok(())
 }
 
-fn check() -> anyhow::Result<()> {
+fn check() -> Result<()> {
     // Look for all directories like `2024h2` or `2025h1` and load goals from those directories.
     let regex = Regex::new(r"\d\d\d\dh[12]")?;