docs: Update documentation and project metadata

Author: dormant-user

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "RuTorrent"
+name = "rutorrent"
 version = "0.1.2"
 description = "RuTorrent is a lightweight API that downloads magnet links and asynchronously transfers files to a remote server over SSH via rsync"
 license = "MIT"

README.md

@@ -10,11 +10,11 @@
 ### Installation
 
 ```shell
-cargo add RuTorrent
+cargo add rutorrent
 ```
 
 ### Usage
-```rust
+```rust,no_run
 use rutorrent;
 
 #[actix_rt::main]

src/api.rs

@@ -230,6 +230,10 @@ fn resolve_payload(body: &[settings::PutItem]) -> Vec<settings::PutItem> {
 ///
 /// # Arguments
 ///
+/// * `request` - Reference to the `HttpRequest` object.
+/// * `pending` - Reference to the `PendingMap` object.
+/// * `config` - Reference to the `Config` object.
+/// * `db_connection` - Database connection received through app data.
 /// * `body` - Request body that takes `PutItem` object.
 ///
 /// #### Sample Request
@@ -280,7 +284,7 @@ pub async fn put_torrent(
     request: HttpRequest,
     pending: web::Data<settings::PendingMap>,
     config: web::Data<settings::Config>,
-    db_conn: web::Data<settings::DbConn>,
+    db_connection: web::Data<settings::DBConnection>,
     body: web::Json<Vec<settings::PutItem>>,
 ) -> impl Responder {
     if !authenticator(request, &config) {
@@ -343,7 +347,7 @@ pub async fn put_torrent(
             && !item.remote_path.is_empty()
         {
             pending_lock.insert(tag.clone(), item.clone());
-            if let Ok(conn) = db_conn.lock() {
+            if let Ok(conn) = db_connection.lock() {
                 database::upsert_pending(&conn, &tag, &item);
             }
         } else {

src/main.rs

@@ -1,3 +1,6 @@
+/// Entry point for the RuTorrent application.
+///
+/// This asynchronous main function triggers the `start` function from the `rutorrent` library.
 #[actix_rt::main]
 async fn main() -> std::io::Result<()> {
     rutorrent::start().await

src/parser.rs

@@ -1,5 +1,6 @@
 use crate::constant;
 
+/// Represents the command-line arguments parsed from the environment.
 #[derive(Debug, Clone)]
 pub struct Arguments {
     pub env_file: String,
@@ -8,9 +9,13 @@ pub struct Arguments {
 
 /// Parses and returns the command-line arguments.
 ///
+/// # Arguments
+///
+/// * `metadata` - Takes the project metadata as an argument.
+///
 /// # Returns
 ///
-/// A String notion of the argument, `env_file` if present.
+/// Returns the `Arguments` object with `env_file` and `read_db` variables.
 pub fn arguments(metadata: &constant::MetaData) -> Arguments {
     let args: Vec<String> = std::env::args().collect();
 

src/rsync.rs

@@ -33,11 +33,11 @@ fn parse_progress(line: &str) -> Option<f64> {
 ///
 /// # Arguments
 ///
-/// * `state` - Shared application state used to track transfer progress and status
-/// * `hash` - Unique identifier for the transfer entry in the state
+/// * `state` - Shared application state used to track transfer progress and status.
+/// * `hash` - Unique identifier for the transfer entry in the state.
 /// * `name` - Human-readable name of the item being transferred (used for logging)
-/// * `source` - Local source path to be copied
-/// * `target` - Remote rsync target configuration (username, host, and destination path)
+/// * `source` - Local source path to be copied.
+/// * `put_item` - Reference to the `PutItem` object.
 ///
 /// # Notes
 ///

src/settings.rs

@@ -4,6 +4,7 @@ use std::num::NonZeroUsize;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use utoipa::ToSchema;
+use std::str::FromStr;
 
 /// ### SharedState
 /// Shared application state for tracking active rsync operations.
@@ -12,9 +13,12 @@ pub type SharedState = Arc<RwLock<HashMap<String, RsyncTrack>>>;
 /// Shared map for storing pending torrent metadata before resolution.
 pub type PendingMap = Arc<RwLock<HashMap<String, PutItem>>>;
 
-pub type DbConn = Arc<std::sync::Mutex<rusqlite::Connection>>;
-use std::str::FromStr;
+/// ### DBConnection
+/// Shared `ruslite` connection object.
+pub type DBConnection = Arc<std::sync::Mutex<rusqlite::Connection>>;
 
+/// ### LogOptions
+/// Options for logging output.
 #[derive(Debug, Clone, PartialEq)]
 pub enum LogOptions {
     Stdout,
@@ -24,6 +28,13 @@ pub enum LogOptions {
 impl FromStr for LogOptions {
     type Err = String;
 
+    /// Parses a string into a `LogOptions` value.
+    ///
+    /// Accepted values are:
+    /// - `"stdout"` → logs to standard output
+    /// - `"file"` → logs to a file
+    ///
+    /// Returns an error if the input does not match a supported option.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "stdout" => Ok(LogOptions::Stdout),
@@ -64,17 +75,26 @@ pub struct Config {
     pub telegram_bot_token: String,
 }
 
+/// Formats and prints the startup error message.
+///
+/// # Arguments
+///
+/// * `msg` - Message to be printed.
 fn startup_error(msg: &str) {
     eprintln!("\nStartupError:\n\t{}\n", msg);
 }
 
-/// ### Config::new
-/// Creates a new [`Config`] instance from environment variables.
-///
-/// # Returns
-///
-/// A [`Config`] populated with environment values or sensible defaults.
 impl Config {
+    /// Creates a new application configuration by reading environment variables.
+    ///
+    /// Required values are validated at startup, and the process will terminate
+    /// with an error message if any critical configuration is missing or invalid.
+    ///
+    /// This includes:
+    /// - API key validation
+    /// - Worker count validation
+    /// - Logging configuration parsing
+    /// - External service configuration normalization (e.g. URL cleanup)
     pub fn new() -> Self {
         let host = squire::get_env_var("host", Some("127.0.0.1"));
         let port = squire::get_env_var("port", Some("3000"))
@@ -225,22 +245,33 @@ pub struct PutItem {
     pub delete_after_copy: bool,
 }
 
+/// Gets the default host from the `remote_host` environment variable.
 fn default_host() -> String {
     squire::get_env_var("remote_host", None)
 }
 
+/// Gets the default username from the `remote_user` environment variable.
 fn default_username() -> String {
     squire::get_env_var("remote_user", None)
 }
 
+/// Gets the default remote path from the `remote_path` environment variable.
 fn default_path() -> String {
     squire::get_env_var("remote_path", None)
 }
 
+/// Gets the default save path from the `save_path` environment variable.
 fn default_save_path() -> String {
     squire::get_env_var("save_path", None)
 }
 
+/// Determines whether files should be deleted after copying.
+///
+/// This value is read from the `delete_after_copy` environment variable.
+/// If the variable is missing or cannot be parsed as a boolean,
+/// it defaults to `false`, since this is called during run-time.
 fn default_delete_after_copy() -> bool {
-    false
+    squire::get_env_var("delete_after_copy", Some("false"))
+        .parse::<bool>()
+        .unwrap_or(false)
 }

src/squire.rs

@@ -30,13 +30,14 @@ async fn qb_get(client: &Client, url: String) -> Option<Value> {
 /// # Arguments
 ///
 /// * `array` - Array of existing torrents in QBitAPI.
-/// * `pending` - Shared map of pending torrent metadata keyed by tags
-/// * `state` - Shared state where active torrent tracking entries are stored
+/// * `pending` - Shared map of pending torrent metadata keyed by tags.
+/// * `state` - Shared state where active torrent tracking entries are stored.
+/// * `db_connection` - Database connection received through app data.
 async fn resolve_new_torrents(
     array: &Vec<Value>,
     pending: &settings::PendingMap,
     state: &settings::SharedState,
-    db_conn: &settings::DbConn,
+    db_connection: &settings::DBConnection,
 ) {
     let mut pending_lock = pending.write().await;
     let mut db = state.write().await;
@@ -67,7 +68,7 @@ async fn resolve_new_torrents(
                     put_item: item,
                 },
             );
-            if let Ok(conn) = db_conn.lock() {
+            if let Ok(conn) = db_connection.lock() {
                 database::remove_pending(&conn, tag);
                 database::upsert(&conn, &hash, db.get(&hash).unwrap());
             }
@@ -113,10 +114,11 @@ fn notifier(title: String, body: String, config: settings::Config) {
 ///
 /// # Arguments
 ///
-/// * `client` - Authenticated HTTP client for qBittorrent API requests
-/// * `state` - Shared state used to track torrent and transfer progress
-/// * `pending` - Shared map of pending torrent metadata
-/// * `config` - Application configuration containing API settings
+/// * `client` - Authenticated HTTP client for qBittorrent API requests.
+/// * `state` - Shared state used to track torrent and transfer progress.
+/// * `pending` - Shared map of pending torrent metadata.
+/// * `config` - Application configuration containing API settings.
+/// * `db_connection` - Database connection received through app data.
 ///
 /// # Notes
 ///
@@ -129,7 +131,7 @@ pub fn spawn_worker(
     state: settings::SharedState,
     pending: settings::PendingMap,
     config: settings::Config,
-    db_conn: settings::DbConn,
+    db_connection: settings::DBConnection,
 ) {
     tokio::spawn(async move {
         log::info!("Worker started");
@@ -159,7 +161,7 @@ pub fn spawn_worker(
                 };
 
                 log::trace!("Torrents active: {:?}", array);
-                resolve_new_torrents(array, &pending, &state, &db_conn).await;
+                resolve_new_torrents(array, &pending, &state, &db_connection).await;
             } else {
                 log::error!("Failed to get info from QBitAPI");
 
@@ -210,7 +212,7 @@ pub fn spawn_worker(
                 if !returned.contains(h.as_str()) {
                     log::info!("Torrent removed from QBitAPI, dropping from state: {}", h);
                     db.remove(h);
-                    if let Ok(conn) = db_conn.lock() {
+                    if let Ok(conn) = db_connection.lock() {
                         database::remove(&conn, h);
                     }
                 }
@@ -241,7 +243,7 @@ pub fn spawn_worker(
                             config_cloned,
                         );
                         db.remove(&hash);
-                        if let Ok(conn) = db_conn.lock() {
+                        if let Ok(conn) = db_connection.lock() {
                             database::remove(&conn, &hash);
                         }
                     }
@@ -279,7 +281,7 @@ pub fn spawn_worker(
                             }
                         }
                         db.remove(&hash);
-                        if let Ok(conn) = db_conn.lock() {
+                        if let Ok(conn) = db_connection.lock() {
                             database::remove(&conn, &hash);
                         }
                     }
@@ -342,7 +344,11 @@ pub fn get_env_var(key: &str, default: Option<&str>) -> String {
     default.unwrap_or_default().to_string()
 }
 
-/// Load dotenv file using the env var `env_file` or `ENV_FILE`
+/// Load dotenv file using the `env_file` CLI arg or an environment variable.
+///
+/// # Arguments
+///
+/// * `env_file` - Takes the `env_file` passed through CLI argument.
 pub fn load_env_file(mut env_file: String) {
     if env_file.is_empty() {
         env_file = get_env_var("env_file", Some(".env"));
@@ -356,11 +362,11 @@ pub fn load_env_file(mut env_file: String) {
 /// # Description
 /// A secret is considered strong if it satisfies all the following:
 ///
-///     - Has at least `min_length` characters
-///     - Contains at least 1 digit
-///     - Contains at least 1 symbol (non-alphanumeric, non-whitespace)
-///     - Contains at least 1 uppercase letter
-///     - Contains at least 1 lowercase letter
+///  - Has at least "min_length" characters
+///  - Contains at least 1 digit
+///  - Contains at least 1 symbol (non-alphanumeric, non-whitespace)
+///  - Contains at least 1 uppercase letter
+///  - Contains at least 1 lowercase letter
 ///
 /// # Arguments
 ///

src/swagger.rs

@@ -24,6 +24,10 @@ pub struct ApiDoc;
 struct SecurityAddon;
 
 impl Modify for SecurityAddon {
+    /// Adds an API key security scheme to the OpenAPI components.
+    ///
+    /// This inserts an `apikey` header-based security scheme at the top level
+    /// so it is available in Swagger UI and other OpenAPI consumers.
     fn modify(&self, openapi: &mut utoipa::openapi::OpenApi) {
         let components = openapi.components.get_or_insert_with(Default::default);
         components.add_security_scheme(