codegen: Simplify match Err + bail! reporting with .context() and ? operator (#308)

As mentioned in [#299] these verbose `Err` unwrapping structs
accidentally slept in thanks to `anyhow` being pulled in with
`default-features = false`; default features are now enabled which allow
`anyhow` to do what it was designed for: turn any `Error` type into an
`anyhow::Error` for painless propagation/bubbling of many different
error types.  As a bonus we can use their `Context` trait to rewrap
errors with more information where necessary, such as file paths or
describing the operation at hand (as was already done manually in the
`bail!` macros, while `Display`-formatting the underlying error).

[#299]: bitshifter/glam-rs#299 (comment)

Author: MarijnS95

src/main.rs

@@ -1,10 +1,8 @@
 mod outputs;
 
-use anyhow::bail;
+use anyhow::{bail, Context};
 use clap::{arg, command};
 use rustfmt_wrapper::rustfmt;
-use std::fs::File;
-use std::io::Write;
 use std::path::Path;
 
 use outputs::build_output_pairs;
@@ -13,19 +11,9 @@ const GLAM_ROOT: &str = "..";
 
 fn is_modified(repo: &git2::Repository, output_path: &str) -> anyhow::Result<bool> {
     match repo.status_file(Path::new(output_path)) {
-        Ok(status) => {
-            Ok(status.is_wt_modified())
-            // if status.is_wt_modified() {
-            //     bail!("{} is already modified, revert or stash your changes.", output_path);
-            // }
-        }
-        Err(e) => {
-            if e.code() == git2::ErrorCode::NotFound {
-                Ok(false)
-            } else {
-                bail!("git file status failed for {}: {}", output_path, e);
-            }
-        }
+        Ok(status) => Ok(status.is_wt_modified()),
+        Err(e) if e.code() == git2::ErrorCode::NotFound => Ok(false),
+        Err(e) => Err(e).with_context(|| format!("git file status failed for {}", output_path)),
     }
 }
 
@@ -34,14 +22,8 @@ fn generate_file(
     context: &tera::Context,
     template_path: &str,
 ) -> anyhow::Result<String> {
-    let buffer = match tera.render(template_path, context) {
-        Ok(output) => output,
-        Err(e) => {
-            bail!("tera error encountered: {}", e);
-        }
-    };
-
-    Ok(buffer)
+    tera.render(template_path, context)
+        .context("tera render error")
 }
 
 fn main() -> anyhow::Result<()> {
@@ -65,26 +47,22 @@ fn main() -> anyhow::Result<()> {
     let verbose = matches.is_present("verbose");
 
     if stdout && output_path_glob.is_none() {
+        // TODO: What if the glob matches multiple files?
         bail!("specify a single file to output to stdout.");
     }
 
     let glob = if let Some(output_path_glob) = output_path_glob {
-        match globset::Glob::new(output_path_glob) {
-            Ok(glob) => Some(glob.compile_matcher()),
-            Err(e) => bail!("failed to compile glob: {}", e),
-        }
+        Some(
+            globset::Glob::new(output_path_glob)
+                .context("failed to compile glob")?
+                .compile_matcher(),
+        )
     } else {
         None
     };
-    let tera = match tera::Tera::new("templates/**/*.rs.tera") {
-        Ok(t) => t,
-        Err(e) => bail!("Parsing error(s): {}", e),
-    };
+    let tera = tera::Tera::new("templates/**/*.rs.tera").context("tera parsing error(s)")?;
 
-    let repo = match git2::Repository::open(GLAM_ROOT) {
-        Ok(repo) => repo,
-        Err(e) => bail!("failed to open git repo: {}", e),
-    };
+    let repo = git2::Repository::open(GLAM_ROOT).context("failed to open git repo")?;
     let workdir = repo.workdir().unwrap();
 
     let output_pairs = build_output_pairs();
@@ -126,33 +104,23 @@ fn main() -> anyhow::Result<()> {
         let mut output_str = generate_file(&tera, context, template_path)?;
 
         if fmt_output || check {
-            match rustfmt(&output_str) {
-                Ok(output) => output_str = output,
-                Err(e) => {
-                    bail!("rustfmt error encountered: {}", e);
-                }
-            }
+            output_str = rustfmt(&output_str).context("rustfmt failed")?;
         }
 
         let full_output_path = workdir.join(output_path);
 
         if check {
-            match File::open(&full_output_path) {
-                Ok(mut file) => {
-                    use std::io::Read;
-                    let mut original_str = String::new();
-                    if let Err(e) = file.read_to_string(&mut original_str) {
-                        println!("'{output_path}' could not be read: {e}");
-                        output_differences += 1;
-                    } else if output_str != original_str {
+            match std::fs::read_to_string(&full_output_path) {
+                Ok(original_str) => {
+                    if output_str != original_str {
                         println!("'{output_path}' is different");
                         output_differences += 1;
                     } else if verbose {
                         println!("'{output_path}' is the same");
                     }
                 }
                 Err(e) => {
-                    println!("{output_path} could not be opened: {e}");
+                    println!("{output_path} could not be opened or read: {e}");
                     output_differences += 1;
                 }
             };
@@ -164,16 +132,8 @@ fn main() -> anyhow::Result<()> {
             continue;
         }
 
-        let mut output_file = match File::create(&full_output_path) {
-            Ok(file) => file,
-            Err(e) => {
-                bail!("failed to create {}: {}", full_output_path.display(), e);
-            }
-        };
-
-        if let Err(e) = write!(output_file, "{}", output_str) {
-            bail!("failed to write output: {}", e);
-        }
+        std::fs::write(&full_output_path, output_str)
+            .with_context(|| format!("failed to write {}", full_output_path.display()))?;
     }
 
     if check && output_differences > 0 {