Make default search paths available as util fn

It's the removed section from the get_config() function, but with an
extra Vec<_> creation. This is necessary here because the strings from
the environment variable don't live long enough for lazy evaluation.

.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.
 
@@ -51,14 +51,3 @@ One of these, defaults to `help`:
 | upload-release | Uploads one-or-more files to an existing release, identified by it's tag name. |
 | help | prints the help text (the usage summary above). |
 
-## Unit Testing
-
-The unit test~~s~~ require a Gitea server to execute against. This information is supplied by environment variables rather than on the command line, but it is otherwise exactly the same usage.
-
-| Variable | Description |
-|-|-|
-| TEST_GITEA_SERVER | Server URL, match `-u`, `--url` |
-| TEST_GITEA_REPO | Owner + repo name, match `-u` `--repo` |
-| TEST_GITEA_KEY | API key, match `RELEASE_KEY_GITEA`. The use of a new variable for the API token is to help avoid accidentally touching a production environment during test execution. |
-| TEST_GITEA_RELEASE_TAG | Git tag used to identify the Release. Same as `upload-release`'s positional argument `<TAG_NAME>`. |
-

debian/changelog

@@ -1,5 +0,0 @@
-gt-tool (1.0.0-1) UNRELEASED; urgency=low
-
-  * Experimental release.
-
- -- Robert Garrett <robertgarrett404@gmail.com>  Sun, 1 Jun 2025 16:05:00 -0500

debian/control

@@ -1,30 +0,0 @@
-Source: gt-tool
-Maintainer: Robert Garrett <robertgarrett404@gmail.com>
-Section: misc
-Priority: optional
-Standards-Version: 4.6.2
-Build-Depends:
- debhelper-compat (= 13),
- dh-cargo,
- librust-clap-dev,
- librust-reqwest-dev,
- librust-tokio-dev,
- librust-serde-dev,
-Homepage: https://git.gelvin.dev/robert/gt-tool
-Vcs-Git: https://git.gelvin.dev/robert/gt-tool
-Vcs-Browser: https://git.gelvin.dev/robert/gt-tool
-Rules-Requires-Root: no
-
-Package: gt-tool
-Architecture: any
-Depends:
- ${misc:Depends},
- ${shlibs:Depends},
-Description: CLI tools for interacting with the Gitea API.
- Use interactively to talk to your Gitea instance, or automatically via a CI/CD
- pipeline. Currently supports:
- .
-  - showing the Releases for a project
-  - creating a new Release for a project
-  - attaching files to a release
-

debian/copyright

@@ -1,43 +0,0 @@
-Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
-Upstream-Name: gt-tools
-Upstream-Contact: Robert Garrett <robertgarrett404@gmail.com>
-Source: https://source.mnt.re/reform/mnt-reform-setup-wizard
-
-Files: *
-Copyright: 2025 Robert Garrett <robertgarrett404@gmail.com>
-License: GPL-3+
-
-Files: debian/*
-Copyright: 2025 Robert Garrett <robertgarrett404@gmail.com>
-License: GPL-3+
-
-Files: debian/rules
-Copyright:
- Johannes Schauer Marin Rodrigues <josch@debian.org>
- 2025 Robert Garrett <robertgarrett404@gmail.com>
-License: GPL-3+
-Comment:
- The debian/rules file is liften directly from the tuigreet package. It was
- linked in the Debian Rust Team Book as a pretty simple example package. The
- only change I've made is to remove the documentation generation target.
- .
- https://salsa.debian.org/debian/tuigreet/-/blob/master/debian/rules?ref_type=heads
-
-
-License: GPL-3+
- This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 3 of the License, or
- (at your option) any later version.
- .
- It is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
- License for more details.
- .
- You should have received a copy of the GNU General Public License
- along with it.  If not, see <http://www.gnu.org/licenses/>.
- .
- On Debian systems, the full text of the GNU General Public License version 3
- can be found in the file /usr/share/common-licenses/GPL-3.
-

debian/gbp.conf

@@ -1,6 +0,0 @@
-[DEFAULT]
-compression = xz
-compression-level = 9
-upstream-tag = v%(version)s
-debian-branch = deb
-

debian/patches/0001-Rust-edition-downgrade-to-2021.patch

@@ -1,23 +0,0 @@
-From: Robert Garrett <robertgarrett404@gmail.com>
-Date: Sun, 1 Jun 2025 17:59:20 -0500
-Subject: Rust edition downgrade to 2021
-
-Debian Bookworm uses Rust 1.64 which only supports up to the 2021
-edition.
----
- Cargo.toml | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/Cargo.toml b/Cargo.toml
-index febccc4..cf52754 100644
---- a/Cargo.toml
-+++ b/Cargo.toml
-@@ -1,7 +1,7 @@
- [package]
- name = "gt-tool"
- version = "1.0.0"
--edition = "2024"
-+edition = "2021"
- 
- [dependencies]
- clap = { version = "4.0.7", features = ["derive", "env"] }

debian/patches/0002-Use-pre-Rust-1.81-compatible-file-exists-test.patch

@@ -1,31 +0,0 @@
-From: Robert Garrett <robertgarrett404@gmail.com>
-Date: Sun, 1 Jun 2025 18:01:21 -0500
-Subject: Use pre Rust 1.81 compatible file-exists test
-
-The function `std::fs::exists(...)` was stabilized in Rust 1.81, which
-means it can't be used in the Debian Bookworm build. This patch swaps to
-a compatible implementation leaning on the std::path::Path struct.
----
- src/api/release_attachment.rs | 5 +++--
- 1 file changed, 3 insertions(+), 2 deletions(-)
-
-diff --git a/src/api/release_attachment.rs b/src/api/release_attachment.rs
-index 9af71bf..8a0c798 100644
---- a/src/api/release_attachment.rs
-+++ b/src/api/release_attachment.rs
-@@ -1,4 +1,4 @@
--use std::fs;
-+use std::{fs, path};
- 
- pub fn check_release_match_repo() {}
- pub fn get_release_attachment() {}
-@@ -16,7 +16,8 @@ pub async fn create_release_attachment(
- 
-     // Ensure all files exists before starting the uploads
-     for file in &files {
--        match fs::exists(file) {
-+        let path = path::Path::new(file);
-+        match path.try_exists() {
-             Ok(true) => continue,
-             Ok(false) => return Err(crate::Error::NoSuchFile),
-             Err(e) => {

debian/patches/series

@@ -1,2 +0,0 @@
-0001-Rust-edition-downgrade-to-2021.patch
-0002-Use-pre-Rust-1.81-compatible-file-exists-test.patch

debian/rules

@@ -1,26 +0,0 @@
-#!/usr/bin/make -f
-
-export DEB_BUILD_MAINT_OPTIONS = hardening=+all
-DPKG_EXPORT_BUILDFLAGS = 1
-include /usr/share/dpkg/default.mk
-include /usr/share/rustc/architecture.mk
-export DEB_HOST_RUST_TYPE
-export PATH:=/usr/share/cargo/bin:$(PATH)
-export CARGO=/usr/share/cargo/bin/cargo
-export CARGO_HOME=$(CURDIR)/debian/cargo_home
-export CARGO_REGISTRY=$(CURDIR)/debian/cargo_registry
-export DEB_CARGO_CRATE=$(DEB_SOURCE)_$(DEB_VERSION_UPSTREAM)
-
-%:
-	dh $@ --buildsystem=cargo
-
-execute_after_dh_auto_clean:
-	$(CARGO) clean
-	rm -rf $(CARGO_HOME)
-	rm -rf $(CARGO_REGISTRY)
-	rm -f debian/cargo-checksum.json
-
-execute_before_dh_auto_configure:
-	$(CARGO) prepare-debian $(CARGO_REGISTRY) --link-from-system
-	rm -f Cargo.lock
-	touch debian/cargo-checksum.json

debian/source/format

@@ -1 +0,0 @@
-3.0 (quilt)

src/api/release.rs

@@ -1,14 +1,9 @@
-use serde::{Deserialize, Serialize};
-
 use crate::{
-    ApiError, Result,
+    Result,
-    structs::{
+    structs::release::{CreateReleaseOption, Release},
-        self,
-        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> {
@@ -22,7 +17,8 @@ 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>>()
             .await
@@ -32,14 +28,11 @@ pub async fn list_releases(
                 crate::Error::WrappedReqwestErr(reqwest_err)
             })?;
         return Ok(release_list);
-}
+    } else if response.status().is_client_error() {
-
+        let mesg = crate::decode_client_error(response).await?;
-#[derive(Debug, Deserialize, Serialize)]
+        return Err(crate::Error::ApiErrorMessage(mesg));
-#[serde(untagged)]
+    }
-enum CreateResult {
+    panic!("Reached end of list_releases without matching a return pathway.");
-    Success(structs::release::Release),
-    ErrWithMessage(ApiError),
-    Empty,
 }
 
 pub async fn create_release(
@@ -49,31 +42,27 @@ pub async fn create_release(
     submission: CreateReleaseOption,
 ) -> Result<Release> {
     let request_url = format!("{gitea_url}/api/v1/repos/{repo}/releases");
-    let req = client
+    let response = client
         .post(request_url)
         .json(&submission)
         .send()
         .await
-        .map_err(|e| crate::Error::from(e))?;
+        .map_err(crate::Error::from)?;
-    let new_release = req
+    if response.status().is_success() {
-        .json::<CreateResult>()
+        let new_release = response
+            .json::<Release>()
             .await
-        .map_err(|e| crate::Error::from(e))?;
+            .map_err(crate::Error::from)?;
-    match new_release {
+        return Ok(new_release);
-        CreateResult::Success(release) => Ok(release),
+    } else if response.status().is_client_error() {
-        CreateResult::ErrWithMessage(api_error) => {
+        let mesg = crate::decode_client_error(response).await?;
-            if api_error.message == "token is required" {
+        return Err(crate::Error::ApiErrorMessage(mesg));
-                Err(crate::Error::MissingAuthToken)
-            } else {
-                Err(crate::Error::ApiErrorMessage(api_error))
-            }
-        }
-        CreateResult::Empty => panic!("How can we have 200 OK and no release info? No. Crash"),
     }
+    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

@@ -1,4 +1,6 @@
-use std::fs;
+use std::{fs, path};
+
+use crate::structs::Attachment;
 
 pub fn check_release_match_repo() {}
 pub fn get_release_attachment() {}
@@ -10,23 +12,22 @@ pub async fn create_release_attachment(
     gitea_url: &str,
     repo: &str,
     release_id: usize,
-    files: Vec<String>,
+    file: String,
-) -> crate::Result<()> {
+) -> crate::Result<Attachment> {
     let request_url = format!("{gitea_url}/api/v1/repos/{repo}/releases/{release_id}/assets");
 
-    // Ensure all files exists before starting the uploads
+    let path = path::Path::new(&file);
-    for file in &files {
+    match path.try_exists() {
-        match fs::exists(file) {
+        Ok(true) => (),
-            Ok(true) => continue,
         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)"
+            );
         }
     }
 
-    for file in files {
     println!("Uploading file {}", &file);
     let data = reqwest::multipart::Part::stream(fs::read(&file).unwrap())
         .file_name("attachment")
@@ -34,150 +35,24 @@ pub async fn create_release_attachment(
 
     let form = reqwest::multipart::Form::new().part("attachment", data);
 
-        let request = client
+    let response = client
         .post(&request_url)
         .multipart(form)
         .query(&[("name", file.split("/").last())])
         .send()
         .await?;
+    if response.status().is_success() {
+        // TODO: create a struct Attachment and return it to the caller.
+        let attachment_desc = response
+            .json::<Attachment>()
+            .await
+            .map_err(crate::Error::from)?;
+        return Ok(attachment_desc);
+    } else if response.status().is_client_error() {
+        let mesg = crate::decode_client_error(response).await?;
+        return Err(crate::Error::ApiErrorMessage(mesg));
     }
-    Ok(())
+    panic!("Reached end of release_attachment without matching a return path");
 }
 pub fn edit_release_attachment() {}
 pub fn delete_release_attachment() {}
-
-#[cfg(test)]
-mod tests {
-    use reqwest::header::{self, ACCEPT};
-
-    use crate::structs::release::Release;
-
-
-    #[tokio::test]
-    async fn attach_file_exists() {
-        let conf = TestConfig::new();
-        let release_candidates =
-            crate::api::release::list_releases(
-                &conf.client,
-                &conf.server,
-                &conf.repo
-            )
-            .await
-            .expect("Failed to get releases. Pre-conditions unmet, aborting test!");
-
-        let release = match_release_by_tag(&conf.release_tag, release_candidates)
-            .expect("Failed to select matching release. Pre-conditions unmet, aborting test!");
-        
-        let api_result = super::create_release_attachment(
-            &conf.client,
-            &conf.server,
-            &conf.repo,
-            release.id,
-            vec![String::from("Cargo.toml")],
-        )
-        .await;
-    }
-
-    #[tokio::test]
-    async fn attach_file_missing() {
-        let conf = TestConfig::new();
-        let release_candidates =
-            crate::api::release::list_releases(
-                &conf.client,
-                &conf.server,
-                &conf.repo
-            )
-            .await
-            .expect("Failed to get releases. Pre-conditions unmet, aborting test!");
-
-        let release = match_release_by_tag(&conf.release_tag, release_candidates)
-            .expect("Failed to select matching release. Pre-conditions unmet, aborting test!");
-        
-        let api_result = super::create_release_attachment(
-            &conf.client,
-            &conf.server,
-            &conf.repo,
-            release.id,
-            vec![String::from("./this-file-doesnt-exist")],
-        )
-        .await;
-        let api_err = api_result.expect_err("Received Ok(()) after uploading non-existent file. That's nonsense, the API Function is wrong.");
-        match api_err {
-            crate::Error::Placeholder => panic!("Received dummy response from the API function. Finish implementing it, stupid"),
-            crate::Error::WrappedReqwestErr(error) => panic!("Received a reqwest::Error from the API function: {error}"),
-            crate::Error::MissingAuthToken => unreachable!("Missing auth token... in a unit test that already panics without the auth token..."),
-            crate::Error::NoSuchFile => (), // test passes
-            crate::Error::ApiErrorMessage(api_error) => panic!("Received an error message from the API: {api_error:?}"),
-        }
-    }
-
-    struct TestConfig {
-        server: String,
-        repo: String,
-        release_tag: String,
-        client: reqwest::Client,
-    }
-
-    impl TestConfig {
-        fn new() -> Self {
-            let server = std::env::var("TEST_GITEA_SERVER")
-                .expect("Must set server address in env var \"TEST_GITEA_SERVER\"");
-            let repo = std::env::var("TEST_GITEA_REPO")
-                .expect("Must set <user>/<repo> name in env var \"TEST_GITEA_REPO\"");
-            let token = format!(
-                "token {}",
-                std::env::var("TEST_GITEA_KEY")
-                    .expect("Must set the API token in env var \"TEST_GITEA_KEY\"")
-            );
-            let release_tag = std::env::var("TEST_GITEA_RELEASE_TAG")
-                .expect("Must set the target release tag in env var \"TEST_GITEA_RELEASE_TAG\"");
-
-            let mut headers = reqwest::header::HeaderMap::new();
-            headers.append(ACCEPT, header::HeaderValue::from_static("application/json"));
-            headers.append("Authorization", token.parse().unwrap());
-
-            let client = reqwest::Client::builder()
-                .user_agent(format!(
-                    "gt-tools-autotest-agent{}",
-                    env!("CARGO_PKG_VERSION")
-                ))
-                .default_headers(headers)
-                .build()
-                .expect("Failed to build reqwest::Client.");
-
-            return Self {
-                server,
-                repo,
-                release_tag,
-                client
-            };
-        }
-    }
-
-    // Testing utils
-    fn match_release_by_tag(tag: &String, releases: Vec<Release>) -> Option<Release> {
-        let mut release: Option<Release> = None;
-        for rel in releases {
-            if rel.tag_name == *tag {
-                // Only store the value if one hasn't been stored already
-                if let Some(first_release) = &release {
-                    // if there was already a match, begin the error diagnostic creation.
-                    let first_id = first_release.id;
-                    let second_id = rel.id;
-                    assert!(
-                        first_id != second_id,
-                        "FAILURE: Found the same release ID twice while scanning for duplicate tags. How did we get the same one twice?"
-                    );
-                    eprintln!("ERROR: Two releases have been found for the tag \"{tag}\".");
-                    eprintln!("ERROR:    first ID: {first_id}");
-                    eprintln!("ERROR:    second ID: {second_id}");
-                    panic!("ERROR: Nonsense detected, I'm bailing out!");
-                } else {
-                    // else, store our first (and hopefully only) match
-                    release = Some(rel);
-                }
-            }
-        }
-        return release;
-    }
-}

src/config.rs

@@ -0,0 +1,424 @@
+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
+            let maybe_proj = get_table(cfg_table, project)
+                // 3. convert to PartialConfig
+                .and_then(PartialConfig::try_from)
+                // 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)?,
+                    ))
+                })
+                // 5. Merge the PartialConfigs together, project-specific has higher priority
+                .and_then(|pair| {
+                    Ok(pair.0.merge(pair.1))
+                });
+            maybe_proj
+        })
+        .filter_map(|res| res.ok())
+        .fold(PartialConfig::default(), |acc, inc|{
+            acc.merge(inc)
+        });
+    return Ok(config_iter);
+}
+
+#[derive(Debug, Default)]
+#[cfg_attr(test, derive(PartialEq))]
+pub struct PartialConfig {
+    project_path: Option<String>,
+    gitea_url: Option<String>,
+    owner: Option<String>,
+    repo: Option<String>,
+    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;
+
+    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(),
+        })
+    }
+
+}
+
+#[derive(Debug, Default)]
+#[cfg_attr(test, derive(PartialEq))]
+struct WholeFile {
+    all: PartialConfig,
+    project_overrides: Vec<PartialConfig>,
+}
+
+fn load_from_file(path: &str) -> Result<WholeFile> {
+    let res = std::fs::read_to_string(path);
+    match res {
+        Ok(s) => read_conf_str(s.as_str()),
+        Err(e) => {
+            eprintln!("->> file io err: {:?}", e);
+            Err(Error::CouldntReadFile)
+        }
+    }
+}
+
+fn read_conf_str(text: &str) -> Result<WholeFile> {
+    let mut whole = WholeFile::default();
+
+    let toml_val = text.parse::<Value>()?;
+
+    // The config file is one big table. If the string we decoded is
+    // some other toml::Value variant, it's not correct.
+    // Try getting it as a table, return Err(BadFormat) otherwise.
+    let cfg_table = toml_val.as_table().ok_or(Error::BadFormat)?;
+
+    // Get the global config out of the file
+    let table_all = get_table(cfg_table, "all")?;
+    whole.all = PartialConfig::try_from(table_all)?;
+
+    // Loop over the per-project configs, if any.
+    let per_project_keys = cfg_table
+        .keys()
+        .filter(|s| { // Discard the "[all]" table
+            *s != "all"
+        });
+
+    for path in per_project_keys {
+        let tab = get_table(cfg_table, path)?;
+        let part_cfg = PartialConfig::try_from(tab)?
+            .project_path(path.clone());
+        whole.project_overrides.push(part_cfg);
+    }
+    Ok(whole)
+}
+
+/// The outer value must be a Table so we can get the sub-table from it.
+fn get_table<'outer>(outer: &'outer Table, table_name: impl ToString) -> Result<&'outer Table> {
+    Ok(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> (outer: &'outer Table, property: impl ToString) -> Result<Option<&'outer String>> {
+    let maybe_prop = get_property(outer, property);
+    match maybe_prop {
+        Ok(value) => Ok(Some(value)),
+        Err(e) => {
+            if let Error::NoSuchProperty = e {
+                return Ok(None);
+            } else {
+                return 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>(outer: &'outer Table, property: impl ToString) -> Result<&'outer 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::*;
+
+    // Util for generating a reference struct
+    fn gen_expected_struct() -> WholeFile {
+        WholeFile {
+            all: PartialConfig {
+                project_path: None,
+                gitea_url: Some(String::from("http://localhost:3000")),
+                owner: None,
+                repo: None,
+                token: Some(String::from("fake-token"))
+            },
+            project_overrides: vec![
+                PartialConfig {
+                    project_path: Some(String::from("/home/robert/projects/gt-tool")),
+                    gitea_url: None,
+                    owner: Some(String::from("robert")),
+                    repo: Some(String::from("gt-tool")),
+                    token: None,
+                },
+                PartialConfig {
+                    project_path: Some(String::from("/home/robert/projects/rcalc")),
+                    gitea_url: None,
+                    owner: Some(String::from("jamis")),
+                    repo: Some(String::from("rcalc")),
+                    token: None,
+                },
+                PartialConfig {
+                    project_path: Some(String::from("/home/robert/projects/rcalc-builders")),
+                    gitea_url: None,
+                    owner: Some(String::from("jamis")),
+                    repo: Some(String::from("rcalc")),
+                    token: None,
+                },
+            
+            ],
+        }
+    }
+
+    #[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 read_config_string_ok() -> Result<()> {
+        let fx_sample_config_string = include_str!("../test_data/sample_config.toml");
+        let fx_expected_struct = gen_expected_struct();
+        let conf = read_conf_str(fx_sample_config_string)?;
+        
+        assert_eq!(conf, fx_expected_struct);
+        Ok(())
+    }
+
+    /* TODO: Improve semantics around reading an empty string
+    An empty config string will result in Error::NoSuchTable when "[all]"
+    is retrieved. But this will *also* happen when other configs are present,
+    but "[all]" isn't. Do I treat these as valid configurations, using some
+    hard-coded default as the fallback? Or do I reject configs that don't have
+    an all-table?
+     */
+    #[test]
+    fn read_config_string_empty() {
+        let fx_sample_cfg = "";
+        let conf = read_conf_str(fx_sample_cfg);
+        assert!(conf.is_err());
+    }
+
+    #[test]
+    // File exists and has valid configuration.
+    fn load_from_file_ok() -> Result<()> {
+        let conf = load_from_file("test_data/sample_config.toml")?;
+        assert_eq!(conf, gen_expected_struct());
+        Ok(())
+    }
+
+    #[test]
+    // File does not exist.
+    fn load_from_file_missing() -> Result<()> {
+        let res = load_from_file("test_data/doesnt_exist.toml");
+        let err = res.unwrap_err();
+        assert_eq!(err, Error::CouldntReadFile);
+        Ok(())
+    }
+
+    #[test]
+    // File exists but has garbage inside.
+    // TODO: This bumps against the same semantic issue as the todo note on
+    // the 'read_config_string_empty' test
+    fn load_from_file_bad() {
+        let res = load_from_file("test_data/missing_all_table.toml");
+        assert!(res.is_err());
+    }
+
+    #[test]
+    // FIXME: Allow user-specified search paths, then update test to use them.
+    // This test can only work if there's a config file the program can find.
+    // Right now, that means a file called "gt-tool.toml" in
+    // 1. `/etc`
+    // 2. anything inside `$XDG_CONFIG_DIRS`
+    fn check_get_config() -> 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(())
+    }
+}

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,6 +11,13 @@ pub struct ApiError {
     url: String,
 }
 
+pub(crate) async fn decode_client_error(response: reqwest::Response) -> Result<ApiError> {
+    response
+        .json::<ApiError>()
+        .await
+        .map_err(crate::Error::WrappedReqwestErr)
+}
+
 #[derive(Debug)]
 pub enum Error {
     Placeholder, // TODO: Enumerate error modes

src/main.rs

@@ -1,3 +1,5 @@
+use std::path;
+
 use gt_tool::cli::Args;
 use gt_tool::structs::release::{CreateReleaseOption, Release};
 
@@ -19,10 +21,7 @@ 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()?;
 
@@ -30,9 +29,15 @@ async fn main() -> Result<(), gt_tool::Error> {
         gt_tool::cli::Commands::ListReleases => {
             let releases =
                 gt_tool::api::release::list_releases(&client, &args.gitea_url, &args.repo).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,
@@ -49,12 +54,7 @@ async fn main() -> Result<(), gt_tool::Error> {
                 tag_name,
                 target_commitish,
             };
-            gt_tool::api::release::create_release(
+            gt_tool::api::release::create_release(&client, &args.gitea_url, &args.repo, submission)
-                &client,
-                &args.gitea_url,
-                &args.repo,
-                submission,
-            )
                 .await?;
         }
         gt_tool::cli::Commands::UploadRelease {
@@ -78,14 +78,29 @@ async fn main() -> Result<(), gt_tool::Error> {
                 gt_tool::api::release::list_releases(&client, &args.gitea_url, &args.repo).await?;
 
             if let Some(release) = match_release_by_tag(&tag_name, release_candidates) {
-                gt_tool::api::release_attachment::create_release_attachment(
+                for file in &files {
+                    let path = path::Path::new(&file);
+                    match path.try_exists() {
+                        Ok(true) => continue,
+                        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)"
+                            );
+                        }
+                    }
+                }
+                for file in files {
+                    let _attach_desc = gt_tool::api::release_attachment::create_release_attachment(
                         &client,
                         &args.gitea_url,
                         &args.repo,
                         release.id,
-                    files,
+                        file,
                     )
                     .await?;
+                }
             } else {
                 println!("ERR: Couldn't find a release matching the tag \"{tag_name}\".");
                 return Err(gt_tool::Error::NoSuchRelease);
@@ -127,5 +142,5 @@ fn match_release_by_tag(tag: &String, releases: Vec<Release>) -> Option<Release>
             }
         }
     }
-    return release;
+    release
 }

src/structs/mod.rs

@@ -1,2 +1,15 @@
+use serde::{Deserialize, Serialize};
+
 pub mod release;
 pub mod repo;
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Attachment {
+    id: usize,
+    name: String,
+    size: i64,
+    download_count: i64,
+    created_at: String, // TODO: Date-time struct
+    uuid: String,
+    browser_download_url: String,
+}

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"