fix typos; extend docs

README.md

@@ -336,7 +336,7 @@ Options:
           [default: 1d]
 
       --cache-exclude-status <CACHE_EXCLUDE_STATUS>
-          A List status codes that will be ignored from the cache
+          A list of status codes that will be ignored from the cache
 
           The following accept range syntax is supported: [start]..[=]end|code. Some valid
           examples are:

lychee-bin/src/commands/check.rs

@@ -309,6 +309,14 @@ async fn handle(
     response
 }
 
+/// Returns `true` if the response should be ignored in the cache.
+///
+/// The response should be ignored if:
+/// - The URI is a file URI.
+/// - The status is excluded.
+/// - The status is unsupported.
+/// - The status is unknown.
+/// - The status code is excluded from the cache.
 fn ignore_cache(uri: &Uri, status: &Status, cache_exclude_status: &HashSet<u16>) -> bool {
     let status_code_excluded = status
         .code()
@@ -433,39 +441,49 @@ mod tests {
     }
 
     #[test]
-    fn test_ignore_cache() {
-        let mut exclude = HashSet::new();
-
-        // Cache is not ignored
+    fn test_cache_by_default() {
         assert!(!ignore_cache(
             &Uri::try_from("https://[::1]").unwrap(),
             &Status::Ok(StatusCode::OK),
-            &exclude
+            &HashSet::default()
         ));
+    }
 
-        // Cache is ignored for file URLs
+    #[test]
+    // Cache is ignored for file URLs
+    fn test_cache_ignore_file_urls() {
         assert!(ignore_cache(
             &Uri::try_from("file:///home").unwrap(),
             &Status::Ok(StatusCode::OK),
-            &exclude
+            &HashSet::default()
         ));
+    }
 
-        // Cache is ignored for unsupported status
+    #[test]
+    // Cache is ignored for unsupported status
+    fn test_cache_ignore_unsupported_status() {
         assert!(ignore_cache(
             &Uri::try_from("https://[::1]").unwrap(),
             &Status::Unsupported(ErrorKind::EmptyUrl),
-            &exclude
+            &HashSet::default()
         ));
+    }
 
-        // Cache is ignored for unknown status
+    #[test]
+    // Cache is ignored for unknown status
+    fn test_cache_ignore_unknown_status() {
         assert!(ignore_cache(
             &Uri::try_from("https://[::1]").unwrap(),
             &Status::UnknownStatusCode(StatusCode::IM_A_TEAPOT),
-            &exclude
+            &HashSet::default()
         ));
+    }
 
+    #[test]
+    fn test_cache_ignore_excluded_status() {
         // Cache is ignored for excluded status codes
-        exclude.insert(200);
+        let exclude = [StatusCode::OK.as_u16()].iter().copied().collect();
+
         assert!(ignore_cache(
             &Uri::try_from("https://[::1]").unwrap(),
             &Status::Ok(StatusCode::OK),

lychee-bin/src/options.rs

@@ -236,7 +236,7 @@ pub(crate) struct Config {
     #[arg(
         long,
         default_value_t,
-        long_help = "A List status codes that will be ignored from the cache
+        long_help = "A list of status codes that will be ignored from the cache
 
 The following accept range syntax is supported: [start]..[=]end|code. Some valid
 examples are:

lychee-lib/src/types/accept/range.rs

@@ -7,8 +7,8 @@ use thiserror::Error;
 static RANGE_PATTERN: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"^([0-9]{3})?\.\.(=?)([0-9]{3})+$|^([0-9]{3})$").unwrap());
 
-/// The [`AcceptRangeParseError`] indicates that the parsing process of an
-/// [`AcceptRange`]  from a string failed due to various underlying reasons.
+/// Indicates that the parsing process of an [`AcceptRange`]  from a string
+/// failed due to various underlying reasons.
 #[derive(Debug, Error, PartialEq)]
 pub enum AcceptRangeError {
     /// The string input didn't contain any range pattern.

lychee-lib/src/types/status_code/excluder.rs

@@ -6,10 +6,12 @@ use crate::{
     types::accept::AcceptRange, types::status_code::StatusCodeSelectorError, AcceptRangeError,
 };
 
-/// An [`StatusCodeExcluder`] holds ranges of HTTP status codes, and determines whether a specific
-/// code is matched, so the link can be counted as valid (not broken) or excluded.
-/// `StatusCodeExcluder` differs from `StatusCodeSelector` in the defaults it provides. As this is
-/// meant to exclude status codes, the default is to keep everything.
+/// A [`StatusCodeExcluder`] holds ranges of HTTP status codes, and determines
+/// whether a specific code is matched, so the link can be counted as valid (not
+/// broken) or excluded. `StatusCodeExcluder` differs from
+/// [`StatusCodeSelector`](super::selector::StatusCodeSelector) in the defaults
+/// it provides. As this is meant to exclude status codes, the default is to
+/// keep everything.
 #[derive(Clone, Debug, PartialEq)]
 pub struct StatusCodeExcluder {
     ranges: Vec<AcceptRange>,

lychee-lib/src/types/status_code/selector.rs

@@ -14,10 +14,12 @@ pub enum StatusCodeSelectorError {
     AcceptRangeError(#[from] AcceptRangeError),
 }
 
-/// An [`StatusCodeSelector`] holds ranges of HTTP status codes, and determines whether a specific
-/// code is matched, so the link can be counted as valid (not broken) or excluded.
-/// `StatusCodeSelector` differs from `StatusCodeExcluder` in the defaults it provides. As this is
-/// meant to select valid status codes, the default includes every successful status.
+/// A [`StatusCodeSelector`] holds ranges of HTTP status codes, and determines
+/// whether a specific code is matched, so the link can be counted as valid (not
+/// broken) or excluded. `StatusCodeSelector` differs from
+/// [`StatusCodeExcluder`](super::excluder::StatusCodeExcluder)
+///  in the defaults it provides. As this is meant to
+/// select valid status codes, the default includes every successful status.
 #[derive(Clone, Debug, PartialEq)]
 pub struct StatusCodeSelector {
     ranges: Vec<AcceptRange>,