add more doc comments

src/args.rs

@@ -7,6 +7,7 @@ use std::path::PathBuf;
 #[derive(Clone, Debug, Default, Parser)]
 #[command(version, author, about)]
 #[group(id = "noisy", multiple = true)]
+/// Arguments for the application binary.
 pub struct Args {
     /// A list of files or directories to process.
     ///

src/comic.rs

@@ -1,15 +1,16 @@
 use std::fmt::Display;
 use std::str::FromStr;
 
-pub use error::ComicError;
-pub use format::{Format, FormatError};
-
 mod error;
 mod format;
 mod parse;
 mod regex;
 
+pub use error::ComicError;
+pub use format::{Format, FormatError};
+
 #[derive(Debug, PartialEq, Eq)]
+/// A comic.
 pub struct Comic {
     // Name of the series.
     //

src/comic/error.rs

@@ -2,9 +2,10 @@ use std::num::ParseIntError;
 
 use thiserror::Error;
 
-use super::FormatError;
+use crate::comic::FormatError;
 
 #[derive(Debug, Error)]
+/// Errors that can occur when parsing a comic book file name.
 pub enum ComicError {
     #[error("invalid input: no capture groups matched")]
     GetCaptures,

src/comic/format.rs

@@ -5,13 +5,19 @@ use thiserror::Error;
 
 #[derive(Debug, Error)]
 #[error("invalid format")]
+/// Error that occurs when parsing a comic book format.
 pub struct FormatError;
 
 #[derive(Debug, PartialEq, Eq)]
+/// The format of a comic book file.
 pub enum Format {
+    /// 7z archive.
     Cb7,
+    /// Rar archive.
     Cbr,
+    /// Tar archive.
     Cbt,
+    /// Zip archive.
     Cbz,
 }
 

src/logger.rs

@@ -2,6 +2,7 @@ use log::LevelFilter;
 
 use crate::args::Args;
 
+/// Initialize the logger.
 pub fn init(args: &Args) {
     let mut level = match args.verbose {
         0 => LevelFilter::Error,

src/process/processor.rs

@@ -1,24 +1,25 @@
-use std::{
-    fs,
-    path::{Path, PathBuf},
-};
+use std::fs;
+use std::path::{Path, PathBuf};
 
 use anyhow::Context;
 
 use crate::comic::Comic;
-
-use super::ProcessorSettings;
+use crate::process::ProcessorSettings;
 
 #[derive(Default)]
+/// Processor for organising comic files
 pub struct Processor {
+    /// Settings for the processor
     settings: ProcessorSettings,
 }
 
 impl Processor {
+    /// Create a new Processor instance with the provided settings
     pub fn new(settings: ProcessorSettings) -> Processor {
         Self { settings }
     }
 
+    /// Process the provided targets
     pub fn process(&self, targets: Vec<PathBuf>) -> anyhow::Result<()> {
         log::trace!("processing targets");
 
@@ -56,8 +57,11 @@ impl Processor {
 
         Ok(())
     }
+}
 
-    pub(crate) fn process_dir(&self, path: &Path) -> anyhow::Result<()> {
+impl Processor {
+    /// Process the provided directory
+    fn process_dir(&self, path: &Path) -> anyhow::Result<()> {
         log::debug!("processing dir: {}", path.display());
 
         let directory = path
@@ -117,7 +121,8 @@ impl Processor {
         Ok(())
     }
 
-    pub(crate) fn process_file(&self, path: &Path) -> anyhow::Result<()> {
+    /// Process the provided file
+    fn process_file(&self, path: &Path) -> anyhow::Result<()> {
         log::debug!("processing file: {}", path.display());
 
         let name = path.file_name().context("getting file name")?;

src/process/settings.rs

@@ -3,21 +3,31 @@ use std::path::PathBuf;
 use crate::args::Args;
 
 #[derive(Default)]
+/// Settings for the processor
 pub struct ProcessorSettings {
+    /// The output directory for the processed files
     pub output: PathBuf,
+    /// Whether to output files in series subdirectories
     pub series: bool,
+    /// Whether to move files instead of copying them
     pub move_files: bool,
+    /// Whether to perform a dry run
     pub dry_run: bool,
+    /// Whether to exit after processing
     pub exit: bool,
+    /// Whether to force overwrite of existing files
     pub force: bool,
+    /// Whether to process files recursively
     pub recursive: bool,
 }
 
 impl ProcessorSettings {
+    /// Create a new ProcessorSettings instance with default values
     pub fn new() -> ProcessorSettings {
         ProcessorSettings::default()
     }
 
+    /// Create a new ProcessorSettings instance from the provided Args
     pub fn from_args(args: &Args) -> ProcessorSettings {
         ProcessorSettings {
             output: args.output.clone(),