Bump to v2.2.0

I don't know for sure if the string-ified version of a Release struct is
being printed to the terminal. As such, I don't know if the user wants,
does not want, or has mixed intentions for the stringification of this
thing.

No Display impl, instead just a `colorized()` method.

Cargo.toml

@@ -1,10 +1,12 @@
 [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"] }

README.md

@@ -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>`. |
-

src/api/release.rs

@@ -1,12 +1,9 @@
-
 use crate::{
-    ApiError, Result,
-    structs::{
-        release::{CreateReleaseOption, Release},
-    },
+    Result,
+    structs::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

@@ -1,4 +1,4 @@
-use std::fs;
+use std::{fs, path};
 
 use crate::structs::Attachment;
 
@@ -16,13 +16,16 @@ pub async fn create_release_attachment(
 ) -> crate::Result<Attachment> {
     let request_url = format!("{gitea_url}/api/v1/repos/{repo}/releases/{release_id}/assets");
 
-    match fs::exists(&file) {
+    let path = path::Path::new(&file);
+    match path.try_exists() {
         Ok(true) => (),
         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);
@@ -43,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/lib.rs

@@ -10,13 +10,11 @@ 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| {
-            crate::Error::WrappedReqwestErr(reqwest_err)
-        })
+        .map_err(crate::Error::WrappedReqwestErr)
 }
 
 #[derive(Debug)]

src/main.rs

@@ -1,4 +1,4 @@
-use std::fs;
+use std::path;
 
 use gt_tool::cli::Args;
 use gt_tool::structs::release::{CreateReleaseOption, Release};
@@ -21,10 +21,7 @@ async fn main() -> Result<(), gt_tool::Error> {
         headers.append("Authorization", token.parse().unwrap());
     }
     let client = reqwest::Client::builder()
-        .user_agent(format!(
-            "gt-tools-agent-{}",
-            env!("CARGO_PKG_VERSION")
-        ))
+        .user_agent(format!("gt-tools-agent-{}", env!("CARGO_PKG_VERSION")))
         .default_headers(headers)
         .build()?;
 
@@ -32,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 {
-                println!("{:?}", release);
-            }
+            // Print in reverse order so the newest items are closest to the
+            // 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,
@@ -51,13 +54,8 @@ async fn main() -> Result<(), gt_tool::Error> {
                 tag_name,
                 target_commitish,
             };
-            gt_tool::api::release::create_release(
-                &client,
-                &args.gitea_url,
-                &args.repo,
-                submission,
-            )
-            .await?;
+            gt_tool::api::release::create_release(&client, &args.gitea_url, &args.repo, submission)
+                .await?;
         }
         gt_tool::cli::Commands::UploadRelease {
             tag_name,
@@ -81,13 +79,16 @@ async fn main() -> Result<(), gt_tool::Error> {
 
             if let Some(release) = match_release_by_tag(&tag_name, release_candidates) {
                 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(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 {
@@ -141,5 +142,5 @@ fn match_release_by_tag(tag: &String, releases: Vec<Release>) -> Option<Release>
             }
         }
     }
-    return release;
+    release
 }

src/structs/mod.rs

@@ -9,7 +9,7 @@ pub struct Attachment {
     name: String,
     size: i64,
     download_count: i64,
-    created: String, // TODO: Date-time struct
+    created_at: String, // TODO: Date-time struct
     uuid: String,
-    download_url: 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,