feat: Add support for ranges in the --accept option / config field

lychee-lib/src/lib.rs

@@ -91,8 +91,8 @@ pub use crate::{
     collector::Collector,
     filter::{Excludes, Filter, Includes},
     types::{
-        uri::valid::Uri, Base, BasicAuthCredentials, BasicAuthSelector, CacheStatus, CookieJar,
-        ErrorKind, FileType, Input, InputContent, InputSource, Request, Response, ResponseBody,
-        Result, Status,
+        uri::valid::Uri, AcceptRange, AcceptRangeParseError, AcceptSelector, Base,
+        BasicAuthCredentials, BasicAuthSelector, CacheStatus, CookieJar, ErrorKind, FileType,
+        Input, InputContent, InputSource, Request, Response, ResponseBody, Result, Status,
     },
 };

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

@@ -0,0 +1,5 @@
+mod range;
+mod selector;
+
+pub use range::*;
+pub use selector::*;

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

@@ -0,0 +1,133 @@
+use std::{num::ParseIntError, ops::RangeInclusive, str::FromStr};
+
+use once_cell::sync::Lazy;
+use regex::Regex;
+use thiserror::Error;
+
+static RANGE_PATTERN: Lazy<Regex> = Lazy::new(|| Regex::new(r"([0-9]*)?..(=?)([0-9]+)+").unwrap());
+
+/// The [`AcceptRangeParseError`] indicates that the parsing process of an
+/// [`AcceptRange`]  from a string failed due to various underlying reasons.
+#[derive(Debug, Error, PartialEq)]
+pub enum AcceptRangeParseError {
+    /// The string input didn't contain any range pattern.
+    #[error("No range pattern found")]
+    NoRangePattern,
+
+    /// The start or end index could not be parsed as an integer.
+    #[error("Failed to parse str as integer")]
+    ParseIntError(#[from] ParseIntError),
+
+    /// The start index is larger than the end index.
+    #[error("Invalid range indices, only start < end supported")]
+    InvalidRangeIndices,
+}
+
+/// [`AcceptRange`] specifies which HTTP status codes are accepted and
+/// considered successful when checking a remote URL.
+#[derive(Debug, PartialEq)]
+pub struct AcceptRange(RangeInclusive<usize>);
+
+impl FromStr for AcceptRange {
+    type Err = AcceptRangeParseError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let captures = RANGE_PATTERN
+            .captures(s)
+            .ok_or(AcceptRangeParseError::NoRangePattern)?;
+
+        let inclusive = !captures[2].is_empty();
+
+        let start: usize = captures[1].parse().unwrap_or_default();
+        let end: usize = captures[3].parse()?;
+
+        if start >= end {
+            return Err(AcceptRangeParseError::InvalidRangeIndices);
+        }
+
+        match inclusive {
+            true => Ok(Self::new(start, end)),
+            false => Ok(Self::new(start, end - 1)),
+        }
+    }
+}
+
+impl AcceptRange {
+    /// Creates a new [`AcceptRange`] which matches values between `start` and
+    /// `end` (both inclusive).
+    pub fn new(start: usize, end: usize) -> Self {
+        Self(RangeInclusive::new(start, end))
+    }
+
+    /// Returns the `start` value of this [`AcceptRange`].
+    pub fn start(&self) -> &usize {
+        self.0.start()
+    }
+
+    /// Returns the `end` value of this [`AcceptRange`].
+    pub fn end(&self) -> &usize {
+        self.0.end()
+    }
+
+    /// Returns wether this [`AcceptRange`] contains `value`.
+    pub fn contains(&self, value: usize) -> bool {
+        self.0.contains(&value)
+    }
+
+    pub(crate) fn update_start(&mut self, new_start: usize) {
+        self.0 = RangeInclusive::new(new_start, *self.end());
+    }
+
+    pub(crate) fn update_end(&mut self, new_end: usize) {
+        self.0 = RangeInclusive::new(*self.start(), new_end);
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_from_str() {
+        let range = AcceptRange::from_str("0..10").unwrap();
+
+        assert!(range.contains(0));
+        assert!(range.contains(9));
+        assert!(!range.contains(10));
+    }
+
+    #[test]
+    fn test_from_str_inclusive() {
+        let range = AcceptRange::from_str("0..=10").unwrap();
+
+        assert!(range.contains(0));
+        assert!(range.contains(9));
+        assert!(range.contains(10));
+        assert!(!range.contains(11));
+    }
+
+    #[test]
+    fn test_from_str_open_start() {
+        let range = AcceptRange::from_str("..10").unwrap();
+
+        assert!(range.contains(0));
+        assert!(range.contains(9));
+        assert!(!range.contains(10));
+    }
+
+    #[test]
+    fn test_from_str_open_start_inclusive() {
+        let range = AcceptRange::from_str("..=10").unwrap();
+
+        assert!(range.contains(0));
+        assert!(range.contains(9));
+        assert!(range.contains(10));
+        assert!(!range.contains(11));
+    }
+
+    #[test]
+    fn test_from_str_invalid_indices() {
+        let range = AcceptRange::from_str("10..=0");
+        assert_eq!(range, Err(AcceptRangeParseError::InvalidRangeIndices))
+    }
+}

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

@@ -0,0 +1,115 @@
+use crate::types::accept::AcceptRange;
+
+/// A [`AcceptSelector`] determines if a returned HTTP status code should be
+/// accepted and thus counted as a valid (not broken) link.
+#[derive(Debug)]
+pub struct AcceptSelector {
+    ranges: Vec<AcceptRange>,
+}
+
+impl AcceptSelector {
+    /// Creates a new empty [`AcceptSelector`].
+    pub fn new() -> Self {
+        Self { ranges: Vec::new() }
+    }
+
+    /// Adds a range of accepted HTTP status codes to this [`AcceptSelector`].
+    /// This method merges the new and existing ranges if they overlap.
+    pub fn add_range(&mut self, range: AcceptRange) -> &mut Self {
+        // Merge with previous range if possible
+        if let Some(last) = self.ranges.last_mut() {
+            // Merge when there is an overlap between the last end value and the
+            // to be inserted new range start value.
+            if last.end() >= range.start() {
+                last.update_end(*range.end());
+                return self;
+            }
+
+            // Merge when there is an overlap between the last start value and
+            // the to be inserted new range end value. Only do this, if the new
+            // start value is smaller than the last start value.
+            if last.start() <= range.end() && range.start() <= last.start() {
+                last.update_start(*range.start());
+                return self;
+            }
+        }
+
+        // If neither is the case, the ranges have no overlap at all. Just add
+        // to the list of ranges.
+        self.ranges.push(range);
+        self
+    }
+
+    /// Returns wether this [`AcceptSelector`] contains `value`.
+    pub fn contains(&self, value: usize) -> bool {
+        for range in &self.ranges {
+            if range.contains(value) {
+                return true;
+            }
+        }
+
+        false
+    }
+
+    pub(crate) fn len(&self) -> usize {
+        self.ranges.len()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_non_overlapping_ranges() {
+        let range1 = AcceptRange::new(0, 10);
+        let range2 = AcceptRange::new(20, 30);
+
+        let mut selector = AcceptSelector::new();
+        selector.add_range(range1).add_range(range2);
+
+        assert!(selector.contains(0));
+        assert!(selector.contains(10));
+        assert!(selector.contains(20));
+        assert!(selector.contains(30));
+
+        assert!(!selector.contains(15));
+        assert!(!selector.contains(35));
+
+        assert_eq!(selector.len(), 2);
+    }
+
+    #[test]
+    fn test_overlapping_start_ranges() {
+        let range1 = AcceptRange::new(8, 20);
+        let range2 = AcceptRange::new(0, 10);
+
+        let mut selector = AcceptSelector::new();
+        selector.add_range(range1).add_range(range2);
+
+        assert!(selector.contains(0));
+        assert!(selector.contains(10));
+        assert!(selector.contains(20));
+
+        assert!(!selector.contains(35));
+
+        assert_eq!(selector.len(), 1);
+    }
+
+    #[test]
+    fn test_overlapping_end_ranges() {
+        let range1 = AcceptRange::new(0, 10);
+        let range2 = AcceptRange::new(8, 20);
+
+        let mut selector = AcceptSelector::new();
+        selector.add_range(range1).add_range(range2);
+
+        assert!(selector.contains(0));
+        assert!(selector.contains(10));
+        assert!(selector.contains(20));
+
+        assert!(!selector.contains(35));
+
+        assert_eq!(selector.len(), 1);
+    }
+}

lychee-lib/src/types/mod.rs

@@ -1,5 +1,6 @@
 #![allow(unreachable_pub)]
 
+mod accept;
 mod base;
 mod basic_auth;
 mod cache;
@@ -13,6 +14,7 @@ mod response;
 mod status;
 pub(crate) mod uri;
 
+pub use accept::*;
 pub use base::Base;
 pub use basic_auth::{BasicAuthCredentials, BasicAuthSelector};
 pub use cache::CacheStatus;