src: lore_api_client: use color_eyre::Result

src/app.rs

@@ -2,14 +2,9 @@ use std::{collections::HashMap, path::Path, process::Command};
 use color_eyre::eyre::bail;
 use config::Config;
 use patch_hub::{
-    lore_session::{
+    lore_api_client::{BlockingLoreAPIClient, FailedFeedRequest}, lore_session::{
         self, LoreSession
-    },
-    lore_api_client::{
-        BlockingLoreAPIClient, FailedFeedRequest
-    },
-    mailing_list::MailingList,
-    patch::Patch
+    }, mailing_list::MailingList, patch::Patch
 };
 
 mod config;
@@ -74,15 +69,14 @@ impl LatestPatchsetsState {
     }
 
     pub fn fetch_current_page(self: &mut Self) -> color_eyre::Result<()> {
-        if let Err(failed_feed_request) = self
-            .lore_session.process_n_representative_patches(&self.lore_api_client, self.page_size * &self.page_number) {
-            match failed_feed_request {
-                FailedFeedRequest::UnknownError(error) => bail!("[FailedFeedRequest::UnknownError]\n*\tFailed to request feed\n*\t{error:#?}"),
-                FailedFeedRequest::StatusNotOk(feed_response) => bail!("[FailedFeedRequest::StatusNotOk]\n*\tRequest returned with non-OK status\n*\t{feed_response:#?}"),
-                FailedFeedRequest::EndOfFeed => (),
-            }
-        };
-        Ok(())
+        match self.lore_session.process_n_representative_patches(&self.lore_api_client, self.page_size * self.page_number) {
+            Ok(_) => Ok(()),
+            Err(report) => match report.downcast::<FailedFeedRequest>() {
+                Ok(FailedFeedRequest::EndOfFeed) => Ok(()),
+                Ok(other) => bail!(other),
+                Err(err) => Err(err),
+            },
+        }
     }
 
     pub fn select_below_patchset(self: &mut Self) {

src/lore_api_client.rs

@@ -1,3 +1,6 @@
+use std::fmt::Display;
+
+use color_eyre::eyre::{bail, Result};
 use reqwest::blocking::Response;
 use reqwest::Error;
 
@@ -14,6 +17,16 @@ pub enum FailedFeedRequest {
     EndOfFeed,
 }
 
+impl Display for FailedFeedRequest {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            FailedFeedRequest::UnknownError(error) => write!(f, "Unknown error: {}", error),
+            FailedFeedRequest::StatusNotOk(response) => write!(f, "Status not OK: {}", response.status()),
+            FailedFeedRequest::EndOfFeed => write!(f, "End of feed"),
+        }
+    }
+}
+
 pub struct BlockingLoreAPIClient {}
 
 impl BlockingLoreAPIClient {
@@ -23,11 +36,11 @@ impl BlockingLoreAPIClient {
 }
 
 pub trait PatchFeedRequest {
-    fn request_patch_feed(self: &Self, target_list: &str, min_index: u32) -> Result<String, FailedFeedRequest>;
+    fn request_patch_feed(self: &Self, target_list: &str, min_index: u32) -> Result<String>;
 }
 
 impl PatchFeedRequest for BlockingLoreAPIClient {
-    fn request_patch_feed(self: &Self, target_list: &str, min_index: u32) -> Result<String, FailedFeedRequest> {
+    fn request_patch_feed(self: &Self, target_list: &str, min_index: u32) -> Result<String> {
         let feed_request: String;
         let feed_response: Response;
         let feed_response_body: String;
@@ -36,17 +49,17 @@ impl PatchFeedRequest for BlockingLoreAPIClient {
 
         match reqwest::blocking::get(feed_request) {
             Ok(response) => feed_response = response,
-            Err(error) =>  return Err(FailedFeedRequest::UnknownError(error)),
+            Err(error) =>  bail!(FailedFeedRequest::UnknownError(error)),
         };
 
         match feed_response.status().as_u16() {
             200 => (),
-            _ => return Err(FailedFeedRequest::StatusNotOk(feed_response)),
+            _ => bail!(FailedFeedRequest::StatusNotOk(feed_response)),
         };
 
-        feed_response_body = feed_response.text().unwrap();
+        feed_response_body = feed_response.text()?;
         if feed_response_body.eq(r"</feed>") {
-            return Err(FailedFeedRequest::EndOfFeed);
+            bail!(FailedFeedRequest::EndOfFeed);
         };
 
         Ok(feed_response_body)

src/lore_api_client/tests.rs

@@ -1,3 +1,5 @@
+use color_eyre::eyre::Context;
+
 use super::*;
 use crate::patch::PatchFeed;
 
@@ -21,18 +23,18 @@ fn blocking_client_should_detect_failed_patch_feed_request() {
     let lore_api_client = BlockingLoreAPIClient::new();
 
     if let Err(failed_feed_request) = lore_api_client.request_patch_feed("invalid-list", 0) {
-        match failed_feed_request {
+        match failed_feed_request.downcast::<FailedFeedRequest>().context("Downcasting report to FailedFeedRequest").unwrap() {
             FailedFeedRequest::StatusNotOk(_) => (),
-            _ => panic!("Invalid request should return non 200 OK status.\n{failed_feed_request:#?}")
+            err => panic!("Invalid request should return non 200 OK status.\n{:#?}", err)
         }
     } else {
         panic!("Invalid request shouldn't be successful");
     }
 
     if let Err(failed_feed_request) = lore_api_client.request_patch_feed("amd-gfx", 300000) {
-        match failed_feed_request {
+        match failed_feed_request.downcast::<FailedFeedRequest>().context("Downcasting report to FailedFeedRequest").unwrap() {
             FailedFeedRequest::EndOfFeed => (),
-            _ => panic!("Out-of-bounds request should return end of feed.\n{failed_feed_request:#?}")
+            err => panic!("Out-of-bounds request should return end of feed.\n{err:#?}")
         }
     } else {
         panic!("Out-of-bounds request shouldn't be successful");

src/lore_session.rs

@@ -1,14 +1,15 @@
 use crate::mailing_list::MailingList;
 use crate::patch::{Patch, PatchFeed, PatchRegex};
 use crate::lore_api_client::{
-    AvailableListsRequest, FailedAvailableListsRequest, FailedFeedRequest, FailedPatchHTMLRequest, PatchFeedRequest, PatchHTMLRequest
+    AvailableListsRequest, FailedAvailableListsRequest, FailedPatchHTMLRequest, PatchFeedRequest, PatchHTMLRequest
 };
 use std::collections::HashMap;
 use std::mem::swap;
 use std::{fs::{self, File}, io};
 use std::io::{BufRead, BufReader};
 use std::path::Path;
 use std::process::{Command, Stdio};
+use color_eyre::eyre::{bail, Result};
 use regex::Regex;
 use serde_xml_rs::from_str;
 
@@ -44,14 +45,14 @@ impl LoreSession {
         self.processed_patches_map.get(message_id)
     }
 
-    pub fn process_n_representative_patches<T: PatchFeedRequest>(self: &mut Self, lore_api_client: &T, n: u32) -> Result<(), FailedFeedRequest> {
+    pub fn process_n_representative_patches<T: PatchFeedRequest>(self: &mut Self, lore_api_client: &T, n: u32) -> Result<()> {
         let mut patch_feed: PatchFeed;
         let mut processed_patches_ids: Vec<String>;
 
         while self.representative_patches_ids.len() < usize::try_from(n).unwrap() {
             match lore_api_client.request_patch_feed(&self.target_list, self.min_index) {
                 Ok(feed_response_body) => patch_feed = from_str(&feed_response_body).unwrap(),
-                Err(failed_feed_request) => return Err(failed_feed_request),
+                Err(failed_feed_request) => bail!(failed_feed_request),
             }
 
             processed_patches_ids = self.process_patches(patch_feed);

src/lore_session/tests.rs

@@ -6,7 +6,7 @@ use std::fs;
 
 struct FakeLoreAPIClient { src_path: String }
 impl PatchFeedRequest for FakeLoreAPIClient {
-    fn request_patch_feed(self: &Self, target_list: &str, min_index: u32) -> Result<String, FailedFeedRequest> {
+    fn request_patch_feed(self: &Self, target_list: &str, min_index: u32) -> Result<String> {
         let _ = min_index;
         let _ = target_list;
         Ok(fs::read_to_string(&self.src_path).unwrap())