Another autoformat

Same thing as the previous commit, but for the "[all]" table.

.gitea/workflows/release.yml

@@ -8,6 +8,11 @@ jobs:
     name: Compile and upload a release build
     steps:
       - uses: actions/checkout@v4
+      - name: Get Cargo version
+        run: echo "cargo_version=v$(grep "^version" Cargo.toml | cut -d \" -f2)" >> $GITHUB_ENV
+      - name: Abort if Cargo.toml & Git Tag versions don't match
+        if: ${{ env.cargo_version != github.ref_name }}
+        run: exit 1
       - name: Install Rust Stable
         uses: dtolnay/rust-toolchain@stable
       - name: Build binary crate

Cargo.toml

@@ -1,13 +1,16 @@
 [package]
 name = "gt-tool"
-version = "1.0.0"
+version = "2.2.0"
 edition = "2024"
 
 [dependencies]
 clap = { version = "4.0.7", features = ["derive", "env"] }
+colored = "2.0.0"
+itertools = "0.10.0"
 reqwest = { version = "0.11.13", features = ["json", "stream", "multipart"] }
 serde = { version = "1.0.152", features = ["derive"] }
 tokio = { version = "1.24.2", features = ["macros", "rt-multi-thread"] }
+toml = "0.5"
 
 # Packages available in Debian (Sid)
 # clap = "4.5.23"

README.md

@@ -1,4 +1,4 @@
-# gt-tools
+# gt-tool
 
 CLI tools for interacting with the Gitea API. Use interactively to talk to your Gitea instance, or automatically via a CI/CD pipeline.
 

src/api/release.rs

@@ -1,12 +1,9 @@
-
 use crate::{
     Result,
-    structs::{
+    structs::release::{CreateReleaseOption, Release},
-        release::{CreateReleaseOption, Release},
-    },
 };
 
-pub fn get_release(id: u64) -> Result<Release> {
+pub fn get_release(_id: u64) -> Result<Release> {
     todo!();
 }
 pub fn get_latest_release() -> Result<Release> {
@@ -20,7 +17,7 @@ pub async fn list_releases(
 ) -> Result<Vec<Release>> {
     let request_url = format!("{gitea_url}/api/v1/repos/{repo}/releases/");
     let req = client.get(request_url).send().await;
-    let response = req.map_err(|reqwest_err| crate::Error::WrappedReqwestErr(reqwest_err))?;
+    let response = req.map_err(crate::Error::WrappedReqwestErr)?;
     if response.status().is_success() {
         let release_list = response
             .json::<Vec<Release>>()
@@ -50,22 +47,22 @@ pub async fn create_release(
         .json(&submission)
         .send()
         .await
-        .map_err(|e| crate::Error::from(e))?;
+        .map_err(crate::Error::from)?;
     if response.status().is_success() {
         let new_release = response
             .json::<Release>()
             .await
-            .map_err(|e| crate::Error::from(e))?;
+            .map_err(crate::Error::from)?;
         return Ok(new_release);
     } else if response.status().is_client_error() {
         let mesg = crate::decode_client_error(response).await?;
-        return Err(crate::Error::ApiErrorMessage(mesg))
+        return Err(crate::Error::ApiErrorMessage(mesg));
     }
     panic!("Reached end of create_release without matching a return path");
 }
-pub fn edit_release(id: u64) -> Result<Release> {
+pub fn edit_release(_id: u64) -> Result<Release> {
     todo!();
 }
-pub fn delete_release(id: u64) -> Result<()> {
+pub fn delete_release(_id: u64) -> Result<()> {
     todo!();
 }

src/api/release_attachment.rs

@@ -22,8 +22,10 @@ pub async fn create_release_attachment(
         Ok(false) => return Err(crate::Error::NoSuchFile),
         Err(e) => {
             eprintln!("Uh oh! The file-exists check couldn't be done: {e}");
-            panic!("TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)");
+            panic!(
-        },
+                "TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)"
+            );
+        }
     }
 
     println!("Uploading file {}", &file);
@@ -44,7 +46,7 @@ pub async fn create_release_attachment(
         let attachment_desc = response
             .json::<Attachment>()
             .await
-            .map_err(|e| crate::Error::from(e))?;
+            .map_err(crate::Error::from)?;
         return Ok(attachment_desc);
     } else if response.status().is_client_error() {
         let mesg = crate::decode_client_error(response).await?;

src/cli.rs

@@ -4,9 +4,9 @@ use clap::{Parser, Subcommand};
 #[command(version, about, long_about = None)]
 pub struct Args {
     #[arg(short = 'u', long = "url", env = "GTTOOL_GITEA_URL")]
-    pub gitea_url: String,
+    pub gitea_url: Option<String>,
     #[arg(short = 'r', long = "repo", env = "GTTOOL_FQRN")]
-    pub repo: String,
+    pub repo: Option<String>,
 
     #[command(subcommand)]
     pub command: Commands,

src/config.rs

@@ -0,0 +1,352 @@
+use std::path::PathBuf;
+
+use toml::{Value, value::Table};
+
+pub type Result<T> = core::result::Result<T, Error>;
+
+#[derive(Debug)]
+#[cfg_attr(test, derive(PartialEq))]
+pub enum Error {
+    BadFormat,
+    NoSuchProperty,
+    NoSuchTable,
+    CouldntReadFile,
+    TomlWrap(toml::de::Error),
+}
+
+impl From<toml::de::Error> for Error {
+    fn from(value: toml::de::Error) -> Self {
+        Error::TomlWrap(value)
+    }
+}
+
+impl core::fmt::Display for Error {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // FIXME: Print a nice output, don't just reuse the Debug impl
+        write!(fmt, "{self:?}")
+    }
+}
+
+impl std::error::Error for Error {}
+
+/// Creates an iterator of default (Linux) search paths. The iterator output
+/// is a list of files named "gt-tool.toml" found in decreasingly specific
+/// configuration folders.
+///
+/// - any dirs listed in env var `$XDG_CONFIG_DIRS`
+/// - and the `/etc` dir
+///
+/// This is so that user-specific configs are used first, then machine-wide
+/// ones.
+pub fn default_paths() -> impl Iterator<Item = PathBuf> {
+    // Read env var `XDG_CONFIG_DIRS` and split on ":" to get highest-priority list
+    // TODO: Emit warning when paths aren't unicode
+    std::env::var("XDG_CONFIG_DIRS")
+        .unwrap_or(String::from(""))
+        .split(":")
+        // Set up the "/etc" list
+        //      Which is pretty silly, in this case.
+        //      Maybe a future version will scan nested folders and this will make
+        //      more sense.
+        // glue on the "/etc" path
+        .chain(["/etc"])
+        .map(|path_str| {
+            let mut path = PathBuf::from(path_str);
+            path.push("gt-tool.toml");
+            path
+        })
+        .collect::<Vec<_>>()
+        .into_iter()
+}
+
+/// Searches through the files, `search_files`, for configuration related to a
+/// project, `project`.
+///
+/// The project string is used as a map key and should match the real path of a
+/// project on disk. These are the table names for each config section.
+///
+/// The search files iterator must produce *files* not *folders.* For now,
+/// there is no mechanism to ensure correct usage. Files that can't be opened
+/// will quietly be skipped, so there will be no warning when one gives a
+/// folder.
+///
+/// Use `fn default_paths()` to get a reasonable (Linux) default.
+///
+/// TODO: Check for, and warn or error when given a dir.
+pub fn get_config(
+    project: &str,
+    search_files: impl Iterator<Item = PathBuf>,
+) -> Result<PartialConfig> {
+    /*
+    1. Get conf search (from fn input)
+    2. Iterate config dirs
+    3. Try load toml::Value from file
+    4. Try-get proj-specific table
+    5. Try-get "[all]" table
+    6. (merge) Update `Option::None`s in proj-spec with `Some(_)`s from "[all]"
+    7. (merge, again) Fold the PartialConfigs into a finished one
+    */
+
+    let file_iter = search_files;
+
+    let toml_iter = file_iter
+        .map(std::fs::read_to_string) // read text from file
+        .filter_map(|res| res.ok()) // remove any error messages
+        // TODO: Log warnings when files couldn't be read.
+        .map(|toml_text| toml_text.parse::<Value>()) // try convert to `toml::Value`
+        .filter_map(|res| res.ok()); // remove any failed parses
+    let config_iter = toml_iter
+        .map(|val| -> Result<PartialConfig> {
+            // Like `fn read_conf_str(...)`, but doesn't produce a `WholeFile`
+
+            // 1. Get the top-level table that is the config file
+            let cfg_table = val.as_table().ok_or(Error::BadFormat)?;
+
+            // 2. Get table
+
+            get_table(cfg_table, project)
+                // 3a. convert to PartialConfig
+                .and_then(PartialConfig::try_from)
+                // 3b. or default, if the table couldn't be found.
+                .or(Ok(PartialConfig::default()))
+                // 4. assemble a 2-tuple of PartialConfigs by...
+                .and_then(|proj| {
+                    Ok((
+                        // 4-1. Passing in the project-specific PartialConfig
+                        proj.project_path(project),
+                        // 4-2. Getting and converting to PartialConfig, or returning any Err() if one appears.
+                        get_table(cfg_table, "all")
+                            .and_then(PartialConfig::try_from)
+                            .unwrap_or(PartialConfig::default()),
+                    ))
+                })
+                .map(|pair| pair.0.merge(pair.1))
+        })
+        .filter_map(|res| res.ok())
+        .fold(PartialConfig::default(), |acc, inc| acc.merge(inc));
+    Ok(config_iter)
+}
+
+#[derive(Debug, Default)]
+#[cfg_attr(test, derive(PartialEq))]
+pub struct PartialConfig {
+    project_path: Option<String>,
+    pub gitea_url: Option<String>,
+    pub owner: Option<String>,
+    pub repo: Option<String>,
+    pub token: Option<String>,
+}
+
+impl PartialConfig {
+    // One lonely builder-pattern function to set the project path.
+    // This is so I can do continuation style calls instead of a bunch of
+    // successive `let conf = ...` temporaries.
+    fn project_path(self, path: impl ToString) -> Self {
+        PartialConfig {
+            project_path: Some(path.to_string()),
+            ..self
+        }
+    }
+
+    // Merges two `PartialConfig`'s together, producing a new one.
+    // Non-None values on the right-hand side are used to replace values
+    // in the left-hand side, even if they are Some(_).
+    fn merge(self, other: Self) -> Self {
+        Self {
+            project_path: other.project_path.or(self.project_path),
+            gitea_url: other.gitea_url.or(self.gitea_url),
+            owner: other.owner.or(self.owner),
+            repo: other.repo.or(self.repo),
+            token: other.token.or(self.token),
+        }
+    }
+}
+
+impl TryFrom<&Table> for PartialConfig {
+    type Error = crate::config::Error;
+
+    /// Scans properties out of a `toml::Table` to get a PartialConfig.
+    ///
+    /// `Error::NoSuchProperty` is quietly ignored (mapped to `None`) since it
+    /// isn't an error in this context.
+    ///
+    /// All other errors are propagated and should be treated as real failures.
+    fn try_from(value: &Table) -> Result<Self> {
+        Ok(Self {
+            // can't get table name because that key is gone by this point.
+            project_path: None,
+            gitea_url: get_maybe_property(value, "gitea_url")?.cloned(),
+            owner: get_maybe_property(value, "owner")?.cloned(),
+            repo: get_maybe_property(value, "repo")?.cloned(),
+            token: get_maybe_property(value, "token")?.cloned(),
+        })
+    }
+}
+
+/// The outer value must be a Table so we can get the sub-table from it.
+fn get_table(outer: &Table, table_name: impl ToString) -> Result<&Table> {
+    outer
+        .get(&table_name.to_string())
+        .ok_or(Error::NoSuchTable)?
+        .as_table()
+        .ok_or(Error::BadFormat)
+}
+
+/// Similar to `get_property()` but maps the "Error::NoSuchProperty" result to
+/// Option::None. Some properties aren't specified, and that's okay... sometimes.
+fn get_maybe_property(outer: &Table, property: impl ToString) -> Result<Option<&String>> {
+    let maybe_prop = get_property(outer, property);
+    match maybe_prop {
+        Ok(value) => Ok(Some(value)),
+        Err(e) => {
+            if let Error::NoSuchProperty = e {
+                Ok(None)
+            } else {
+                Err(e)
+            }
+        }
+    }
+}
+
+/// The config properties are individual strings. This gets the named property,
+/// or an error explaining why it couldn't be fetched.
+fn get_property(outer: &Table, property: impl ToString) -> Result<&String> {
+    let maybe_prop = outer
+        .get(&property.to_string())
+        .ok_or(Error::NoSuchProperty)?;
+    if let Value::String(text) = maybe_prop {
+        Ok(text)
+    } else {
+        Err(Error::BadFormat)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use toml::map::Map;
+
+    use super::*;
+
+    #[test]
+    fn read_single_prop() -> Result<()> {
+        let fx_input_str = "owner = \"dingus\"";
+        let fx_value = fx_input_str.parse::<Value>()?;
+        let fx_value = fx_value.as_table().ok_or(Error::NoSuchTable)?;
+        let expected = "dingus";
+
+        let res = get_property(&fx_value, String::from("owner"))?;
+        assert_eq!(res, expected);
+        Ok(())
+    }
+
+    // The property is given the value of empty-string `""`
+    #[test]
+    fn read_single_prop_empty_quotes() -> Result<()> {
+        let fx_input_str = "owner = \"\"";
+        let fx_value = fx_input_str.parse::<Value>()?;
+        let fx_value = fx_value.as_table().ok_or(Error::NoSuchTable)?;
+        let expected = "";
+
+        let res = get_property(&fx_value, String::from("owner"))?;
+        assert_eq!(res, expected);
+        Ok(())
+    }
+
+    #[test]
+    fn read_table() -> Result<()> {
+        let fx_input_str = "[tab]\nwith_a_garbage = \"value\"";
+        let fx_value = fx_input_str.parse::<Value>()?;
+        let fx_value = fx_value.as_table().ok_or(Error::BadFormat)?;
+        let mut expected: Map<String, Value> = Map::new();
+        expected.insert(
+            String::from("with_a_garbage"),
+            Value::String(String::from("value")),
+        );
+
+        let res = get_table(&fx_value, String::from("tab"))?;
+        assert_eq!(res, &expected);
+        Ok(())
+    }
+
+    #[test]
+    fn test_get_config_with_specific_match() -> Result<()> {
+        let search_paths = ["./test_data/sample_config.toml"]
+            .into_iter()
+            .map(PathBuf::from);
+        let load_result = get_config("/home/robert/projects/gt-tool", search_paths)?;
+        let expected = PartialConfig {
+            project_path: Some(String::from("/home/robert/projects/gt-tool")),
+            owner: Some(String::from("robert")),
+            repo: Some(String::from("gt-tool")),
+            gitea_url: Some(String::from("http://localhost:3000")),
+            token: Some(String::from("fake-token")),
+        };
+
+        assert_eq!(load_result, expected);
+        Ok(())
+    }
+
+    // Ensure the config comes back with something even when there is no
+    // matching project-specific table.
+    #[test]
+    fn test_get_config_no_specific_match() -> Result<()> {
+        let search_paths = ["./test_data/sample_config.toml"]
+            .into_iter()
+            .map(PathBuf::from);
+        let load_result = get_config("/no/such/project", search_paths)?;
+        let expected = PartialConfig {
+            project_path: Some(String::from("/no/such/project")),
+            owner: None,
+            repo: None,
+            gitea_url: Some(String::from("http://localhost:3000")),
+            token: Some(String::from("fake-token")),
+        };
+        assert_eq!(load_result, expected);
+        Ok(())
+    }
+
+    // Ensure the config comes back with something even when there is no
+    // "[all]" table
+    #[test]
+    fn test_get_config_without_all() -> Result<()> {
+        let search_paths = ["./test_data/missing_all_table.toml"]
+            .into_iter()
+            .map(PathBuf::from);
+        let load_result = get_config("/some/other/path", search_paths)?;
+        let expected = PartialConfig {
+            project_path: Some(String::from("/some/other/path")),
+            gitea_url: Some(String::from("fake-url")),
+            ..PartialConfig::default()
+        };
+        assert_eq!(load_result, expected);
+        Ok(())
+    }
+
+    // Ensure that trying to load files that don't exist simply get skipped over
+    // instead of causing a short-circuit exit or other bogus output.
+    #[test]
+    fn test_get_config_many_missing_files() -> Result<()> {
+        let search_paths = [
+            "./test_data/not_real_1.toml",
+            "./test_data/not_real_2.toml",
+            "./test_data/not_real_3.toml",
+            "./test_data/not_real_4.toml",
+            "./test_data/not_real_5.toml",
+            "./test_data/sample_config.toml",
+            "./test_data/not_real_6.toml",
+        ]
+        .into_iter()
+        .map(PathBuf::from);
+        let load_result = get_config("/home/robert/projects/gt-tool", search_paths)?;
+        let expected = PartialConfig {
+            project_path: Some(String::from("/home/robert/projects/gt-tool")),
+            owner: Some(String::from("robert")),
+            repo: Some(String::from("gt-tool")),
+            gitea_url: Some(String::from("http://localhost:3000")),
+            token: Some(String::from("fake-token")),
+        };
+
+        assert_eq!(load_result, expected);
+        Ok(())
+    }
+}

src/lib.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 pub mod api;
 pub mod cli;
+pub mod config;
 pub mod structs;
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -10,18 +11,19 @@ pub struct ApiError {
     url: String,
 }
 
-pub (crate) async fn decode_client_error(response: reqwest::Response) -> Result<ApiError> {
+pub(crate) async fn decode_client_error(response: reqwest::Response) -> Result<ApiError> {
     response
         .json::<ApiError>()
         .await
-        .map_err(|reqwest_err| {
+        .map_err(crate::Error::WrappedReqwestErr)
-            crate::Error::WrappedReqwestErr(reqwest_err)
-        })
 }
 
 #[derive(Debug)]
 pub enum Error {
-    Placeholder, // TODO: Enumerate error modes
+    Placeholder,     // TODO: Enumerate error modes
+    MissingGiteaUrl, // the gitea URL wasn't specified on the CLI, env, or config file.
+    MissingRepoFRQN, // either the owner, repo, or both weren't specified in the loaded PartialConfig
+    WrappedConfigErr(config::Error),
     WrappedReqwestErr(reqwest::Error),
     MissingAuthToken,
     NoSuchFile, // for release attachment 'file exists' pre-check.
@@ -35,4 +37,10 @@ impl From<reqwest::Error> for crate::Error {
     }
 }
 
+impl From<crate::config::Error> for crate::Error {
+    fn from(value: crate::config::Error) -> Self {
+        Self::WrappedConfigErr(value)
+    }
+}
+
 type Result<T> = core::result::Result<T, Error>;

src/main.rs

@@ -1,4 +1,3 @@
-
 use std::path;
 
 use gt_tool::cli::Args;
@@ -13,6 +12,37 @@ use reqwest::header::ACCEPT;
 async fn main() -> Result<(), gt_tool::Error> {
     let args = Args::parse();
 
+    // TODO: Heuristics to guess project path
+    // See issue #8: https://git.gelvin.dev/robert/gt-tool/issues/8
+    let pwd = std::env::current_dir()
+        .map_err(|_e| gt_tool::Error::WrappedConfigErr(gt_tool::config::Error::CouldntReadFile))?;
+    let config = gt_tool::config::get_config(
+        pwd.to_str()
+            .expect("I assumed the path can be UTF-8, but that didn't work out..."),
+        gt_tool::config::default_paths(),
+    )?;
+    println!("->> Loaded Config: {config:?}");
+    // arg parser also checks the environment. Prefer CLI/env, then config file.
+    let gitea_url = args
+        .gitea_url
+        .or(config.gitea_url)
+        .ok_or(gt_tool::Error::MissingGiteaUrl)?;
+    // Config files split the repo FQRN into "owner" and "repo" (confusing naming, sorry)
+    // These must be merged back together and passed along.
+    let conf_fqrn = config
+        .owner
+        .ok_or(gt_tool::Error::MissingRepoFRQN)
+        .and_then(|mut own| {
+            let repo = config.repo.ok_or(gt_tool::Error::MissingRepoFRQN)?;
+            own.push_str("/");
+            own.push_str(&repo);
+            Ok(own)
+        });
+    let repo_fqrn = args
+        .repo
+        .ok_or(gt_tool::Error::MissingRepoFRQN)
+        .or(conf_fqrn)?;
+
     let mut headers = reqwest::header::HeaderMap::new();
     headers.append(ACCEPT, header::HeaderValue::from_static("application/json"));
 
@@ -22,20 +52,23 @@ async fn main() -> Result<(), gt_tool::Error> {
         headers.append("Authorization", token.parse().unwrap());
     }
     let client = reqwest::Client::builder()
-        .user_agent(format!(
+        .user_agent(format!("gt-tools-agent-{}", env!("CARGO_PKG_VERSION")))
-            "gt-tools-agent-{}",
-            env!("CARGO_PKG_VERSION")
-        ))
         .default_headers(headers)
         .build()?;
 
     match args.command {
         gt_tool::cli::Commands::ListReleases => {
             let releases =
-                gt_tool::api::release::list_releases(&client, &args.gitea_url, &args.repo).await?;
+                gt_tool::api::release::list_releases(&client, &gitea_url, &repo_fqrn).await?;
-            for release in releases {
+            // Print in reverse order so the newest items are closest to the
-                println!("{:?}", release);
+            // user's command prompt. Otherwise the newest item scrolls off the
-            }
+            // screen and can't be seen.
+            itertools::Itertools::intersperse(
+                releases.iter().rev().map(|release| release.colorized()),
+                String::from(""),
+            )
+            .map(|release| println!("{}", release))
+            .fold((), |_, _| ());
         }
         gt_tool::cli::Commands::CreateRelease {
             name,
@@ -52,13 +85,8 @@ async fn main() -> Result<(), gt_tool::Error> {
                 tag_name,
                 target_commitish,
             };
-            gt_tool::api::release::create_release(
+            gt_tool::api::release::create_release(&client, &gitea_url, &repo_fqrn, submission)
-                &client,
+                .await?;
-                &args.gitea_url,
-                &args.repo,
-                submission,
-            )
-            .await?;
         }
         gt_tool::cli::Commands::UploadRelease {
             tag_name,
@@ -78,7 +106,7 @@ async fn main() -> Result<(), gt_tool::Error> {
             // Grab all, find the one that matches the input tag.
             // Scream if there are multiple matches.
             let release_candidates =
-                gt_tool::api::release::list_releases(&client, &args.gitea_url, &args.repo).await?;
+                gt_tool::api::release::list_releases(&client, &gitea_url, &repo_fqrn).await?;
 
             if let Some(release) = match_release_by_tag(&tag_name, release_candidates) {
                 for file in &files {
@@ -88,17 +116,15 @@ async fn main() -> Result<(), gt_tool::Error> {
                         Ok(false) => return Err(gt_tool::Error::NoSuchFile),
                         Err(e) => {
                             eprintln!("Uh oh! The file-exists check couldn't be done: {e}");
-                            panic!("TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)");
+                            panic!(
-                        },
+                                "TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)"
+                            );
+                        }
                     }
                 }
                 for file in files {
                     let _attach_desc = gt_tool::api::release_attachment::create_release_attachment(
-                        &client,
+                        &client, &gitea_url, &repo_fqrn, release.id, file,
-                        &args.gitea_url,
-                        &args.repo,
-                        release.id,
-                        file,
                     )
                     .await?;
                 }
@@ -143,5 +169,5 @@ fn match_release_by_tag(tag: &String, releases: Vec<Release>) -> Option<Release>
             }
         }
     }
-    return release;
+    release
 }

src/structs/release.rs

@@ -1,3 +1,4 @@
+use colored::Colorize;
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -19,6 +20,36 @@ pub struct Release {
     author: Author,
 }
 
+impl Release {
+    pub fn colorized(&self) -> String {
+        let tag = "Tag:".green().bold();
+        let name = "Name:".green();
+        let published = "Published:".bright_green();
+        let created = "Created:".green().dimmed();
+        let author = "Author:".blue();
+        let body = if !self.body.is_empty() {
+            &self.body.white()
+        } else {
+            &String::from("(empty body)").dimmed()
+        };
+
+        format!(
+            "{tag} {}
+{name} {}
+  {}
+{published} {} ({created} {})
+{author} {} ({})",
+            self.tag_name.bold(),
+            self.name,
+            body,
+            self.published_at,
+            self.created_at.dimmed(),
+            self.author.login,
+            self.author.email,
+        )
+    }
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Author {
     id: usize,

test_data/missing_all_table.toml

@@ -0,0 +1,5 @@
+# There must be an "[all]" table or the loader will reject the config file.
+
+["/some/other/path"]
+gitea_url = "fake-url"
+

test_data/sample_config.toml

@@ -0,0 +1,15 @@
+[all]
+gitea_url = "http://localhost:3000"
+token = "fake-token"
+
+["/home/robert/projects/gt-tool"]
+owner = "robert"
+repo = "gt-tool"
+
+["/home/robert/projects/rcalc"]
+owner = "jamis"
+repo = "rcalc"
+
+["/home/robert/projects/rcalc-builders"]
+owner = "jamis"
+repo = "rcalc"