refactor!: use ResolvedInputSource downstream of InputContent

lychee-bin/src/commands/check.rs

@@ -398,7 +398,7 @@ mod tests {
     use crate::{formatters::get_response_formatter, options};
     use http::StatusCode;
     use log::info;
-    use lychee_lib::{CacheStatus, ClientBuilder, ErrorKind, InputSource, Uri};
+    use lychee_lib::{CacheStatus, ClientBuilder, ErrorKind, ResolvedInputSource, Uri};
 
     use super::*;
 
@@ -408,7 +408,7 @@ mod tests {
         let response = Response::new(
             Uri::try_from("http://127.0.0.1").unwrap(),
             Status::Cached(CacheStatus::Ok(200)),
-            InputSource::Stdin,
+            ResolvedInputSource::Stdin,
         );
         let formatter = get_response_formatter(&options::OutputMode::Plain);
         show_progress(
@@ -430,7 +430,7 @@ mod tests {
         let response = Response::new(
             Uri::try_from("http://127.0.0.1").unwrap(),
             Status::Cached(CacheStatus::Ok(200)),
-            InputSource::Stdin,
+            ResolvedInputSource::Stdin,
         );
         let formatter = get_response_formatter(&options::OutputMode::Plain);
         show_progress(

lychee-bin/src/formatters/stats/markdown.rs

@@ -159,7 +159,9 @@ impl StatsFormatter for Markdown {
 #[cfg(test)]
 mod tests {
     use http::StatusCode;
-    use lychee_lib::{CacheStatus, InputSource, Response, ResponseBody, Status, Uri};
+    use lychee_lib::{
+        CacheStatus, InputSource, ResolvedInputSource, Response, ResponseBody, Status, Uri,
+    };
     use reqwest::Url;
 
     use crate::formatters::suggestion::Suggestion;
@@ -219,7 +221,7 @@ mod tests {
         let response = Response::new(
             Uri::try_from("http://127.0.0.1").unwrap(),
             Status::Cached(CacheStatus::Error(Some(404))),
-            InputSource::Stdin,
+            ResolvedInputSource::Stdin,
         );
         stats.add(response);
         stats

lychee-bin/src/formatters/stats/mod.rs

@@ -55,14 +55,14 @@ where
 mod tests {
     use super::*;
 
-    use lychee_lib::{ErrorKind, Response, Status, Uri};
+    use lychee_lib::{ErrorKind, ResolvedInputSource, Response, Status, Uri};
     use url::Url;
 
     fn make_test_url(url: &str) -> Url {
         Url::parse(url).expect("Expected valid Website URI")
     }
 
-    fn make_test_response(url_str: &str, source: InputSource) -> Response {
+    fn make_test_response(url_str: &str, source: ResolvedInputSource) -> Response {
         let uri = Uri::from(make_test_url(url_str));
 
         Response::new(uri, Status::Error(ErrorKind::TestError), source)
@@ -74,12 +74,18 @@ mod tests {
 
         // Sorted list of test sources
         let test_sources = vec![
-            InputSource::RemoteUrl(Box::new(make_test_url("https://example.com/404"))),
-            InputSource::RemoteUrl(Box::new(make_test_url("https://example.com/home"))),
-            InputSource::RemoteUrl(Box::new(make_test_url("https://example.com/page/1"))),
-            InputSource::RemoteUrl(Box::new(make_test_url("https://example.com/page/10"))),
+            ResolvedInputSource::RemoteUrl(Box::new(make_test_url("https://example.com/404"))),
+            ResolvedInputSource::RemoteUrl(Box::new(make_test_url("https://example.com/home"))),
+            ResolvedInputSource::RemoteUrl(Box::new(make_test_url("https://example.com/page/1"))),
+            ResolvedInputSource::RemoteUrl(Box::new(make_test_url("https://example.com/page/10"))),
         ];
 
+        let unresolved_test_sources: Vec<InputSource> = test_sources
+            .iter()
+            .map(Clone::clone)
+            .map(Into::<InputSource>::into)
+            .collect();
+
         // Sorted list of test responses
         let test_response_urls = vec![
             "https://example.com/",
@@ -104,7 +110,7 @@ mod tests {
             .collect();
 
         // Check that the input sources are sorted
-        assert_eq!(test_sources, sorted_sources);
+        assert_eq!(unresolved_test_sources, sorted_sources);
 
         // Check that the responses are sorted
         for (_, response_bodies) in sorted_errors {

lychee-bin/src/stats.rs

@@ -90,7 +90,7 @@ impl ResponseStats {
     /// Add a response status to the appropriate map (success, fail, excluded)
     fn add_response_status(&mut self, response: Response) {
         let status = response.status();
-        let source = response.source().clone();
+        let source: InputSource = response.source().clone().into();
         let status_map_entry = match status {
             _ if status.is_error() => self.error_map.entry(source).or_default(),
             Status::Ok(_) if self.detailed_stats => self.success_map.entry(source).or_default(),
@@ -126,7 +126,9 @@ mod tests {
     use std::collections::{HashMap, HashSet};
 
     use http::StatusCode;
-    use lychee_lib::{ErrorKind, InputSource, Response, ResponseBody, Status, Uri};
+    use lychee_lib::{
+        ErrorKind, InputSource, ResolvedInputSource, Response, ResponseBody, Status, Uri,
+    };
     use reqwest::Url;
 
     use super::ResponseStats;
@@ -140,7 +142,7 @@ mod tests {
     // and it's a lot faster to just generate a fake response
     fn mock_response(status: Status) -> Response {
         let uri = website("https://some-url.com/ok");
-        Response::new(uri, status, InputSource::Stdin)
+        Response::new(uri, status, ResolvedInputSource::Stdin)
     }
 
     fn dummy_ok() -> Response {
@@ -176,7 +178,10 @@ mod tests {
 
         let response = dummy_error();
         let expected_error_map: HashMap<InputSource, HashSet<ResponseBody>> =
-            HashMap::from_iter([(response.source().clone(), HashSet::from_iter([response.1]))]);
+            HashMap::from_iter([(
+                response.source().clone().into(),
+                HashSet::from_iter([response.1]),
+            )]);
         assert_eq!(stats.error_map, expected_error_map);
 
         assert!(stats.success_map.is_empty());
@@ -196,23 +201,23 @@ mod tests {
         let mut expected_error_map: HashMap<InputSource, HashSet<ResponseBody>> = HashMap::new();
         let response = dummy_error();
         let entry = expected_error_map
-            .entry(response.source().clone())
+            .entry(response.source().clone().into())
             .or_default();
         entry.insert(response.1);
         assert_eq!(stats.error_map, expected_error_map);
 
         let mut expected_success_map: HashMap<InputSource, HashSet<ResponseBody>> = HashMap::new();
         let response = dummy_ok();
         let entry = expected_success_map
-            .entry(response.source().clone())
+            .entry(response.source().clone().into())
             .or_default();
         entry.insert(response.1);
         assert_eq!(stats.success_map, expected_success_map);
 
         let mut expected_excluded_map: HashMap<InputSource, HashSet<ResponseBody>> = HashMap::new();
         let response = dummy_excluded();
         let entry = expected_excluded_map
-            .entry(response.source().clone())
+            .entry(response.source().clone().into())
             .or_default();
         entry.insert(response.1);
         assert_eq!(stats.excluded_map, expected_excluded_map);

lychee-lib/src/extract/mod.rs

@@ -71,7 +71,7 @@ mod tests {
     use crate::{
         Uri,
         test_utils::{load_fixture, mail, website},
-        types::{FileType, InputContent, InputSource},
+        types::{FileType, InputContent, ResolvedInputSource},
         utils::url::find_links,
     };
 
@@ -204,7 +204,7 @@ mod tests {
 
     #[test]
     fn test_extract_relative_url() {
-        let source = InputSource::RemoteUrl(Box::new(
+        let source = ResolvedInputSource::RemoteUrl(Box::new(
             Url::parse("https://example.com/some-post").unwrap(),
         ));
 

lychee-lib/src/lib.rs

@@ -100,7 +100,7 @@ pub use crate::{
     types::{
         AcceptRange, AcceptRangeError, Base, BasicAuthCredentials, BasicAuthSelector, CacheStatus,
         CookieJar, ErrorKind, FileExtensions, FileType, Input, InputContent, InputResolver,
-        InputSource, Request, Response, ResponseBody, Result, Status, StatusCodeExcluder,
-        StatusCodeSelector, uri::valid::Uri,
+        InputSource, Request, ResolvedInputSource, Response, ResponseBody, Result, Status,
+        StatusCodeExcluder, StatusCodeSelector, uri::valid::Uri,
     },
 };

lychee-lib/src/types/base.rs

@@ -2,7 +2,7 @@ use reqwest::Url;
 use serde::{Deserialize, Serialize};
 use std::{convert::TryFrom, path::PathBuf};
 
-use crate::{ErrorKind, InputSource};
+use crate::{ErrorKind, ResolvedInputSource};
 
 /// When encountering links without a full domain in a document,
 /// the base determines where this resource can be found.
@@ -30,9 +30,9 @@ impl Base {
         }
     }
 
-    pub(crate) fn from_source(source: &InputSource) -> Option<Base> {
+    pub(crate) fn from_source(source: &ResolvedInputSource) -> Option<Base> {
         match &source {
-            InputSource::RemoteUrl(url) => {
+            ResolvedInputSource::RemoteUrl(url) => {
                 // Create a new URL with just the scheme, host, and port
                 let mut base_url = url.clone();
                 base_url.set_path("");
@@ -124,7 +124,7 @@ mod test_base {
             ),
         ] {
             let url = Url::parse(url).unwrap();
-            let source = InputSource::RemoteUrl(Box::new(url.clone()));
+            let source = ResolvedInputSource::RemoteUrl(Box::new(url.clone()));
             let base = Base::from_source(&source);
             let expected = Base::Remote(Url::parse(expected).unwrap());
             assert_eq!(base, Some(expected));

lychee-lib/src/types/input/content.rs

@@ -3,7 +3,7 @@
 //! The `InputContent` type represents the actual content extracted from various
 //! input sources, along with metadata about the source and file type.
 
-use super::source::InputSource;
+use super::source::ResolvedInputSource;
 use crate::ErrorKind;
 use crate::types::FileType;
 use std::borrow::Cow;
@@ -14,7 +14,7 @@ use std::path::PathBuf;
 #[derive(Debug)]
 pub struct InputContent {
     /// Input source
-    pub source: InputSource,
+    pub source: ResolvedInputSource,
     /// File type of given input
     pub file_type: FileType,
     /// Raw UTF-8 string content
@@ -26,7 +26,7 @@ impl InputContent {
     /// Create an instance of `InputContent` from an input string
     pub fn from_string(s: &str, file_type: FileType) -> Self {
         Self {
-            source: InputSource::String(Cow::Owned(s.to_owned())),
+            source: ResolvedInputSource::String(Cow::Owned(s.to_owned())),
             file_type,
             content: s.to_owned(),
         }
@@ -37,7 +37,7 @@ impl InputContent {
     pub fn from_str<S: Into<Cow<'static, str>>>(s: S, file_type: FileType) -> Self {
         let cow = s.into();
         Self {
-            source: InputSource::String(cow.clone()),
+            source: ResolvedInputSource::String(cow.clone()),
             file_type,
             content: cow.into_owned(),
         }
@@ -61,7 +61,7 @@ impl TryFrom<&PathBuf> for InputContent {
         };
 
         Ok(Self {
-            source: InputSource::String(Cow::Owned(input.clone())),
+            source: ResolvedInputSource::String(Cow::Owned(input.clone())),
             file_type: FileType::from(path),
             content: input,
         })

lychee-lib/src/types/input/input.rs

@@ -353,7 +353,7 @@ impl Input {
 
         let input_content = InputContent {
             file_type: FileType::from(&path),
-            source: InputSource::FsPath(path),
+            source: ResolvedInputSource::FsPath(path),
             content,
         };
 
@@ -371,7 +371,7 @@ impl Input {
         stdin.read_to_string(&mut content).await?;
 
         let input_content = InputContent {
-            source: InputSource::Stdin,
+            source: ResolvedInputSource::Stdin,
             file_type: file_type_hint.unwrap_or_default(),
             content,
         };

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

@@ -33,3 +33,4 @@ pub use content::InputContent;
 pub use input::Input;
 pub use resolver::InputResolver;
 pub use source::InputSource;
+pub use source::ResolvedInputSource;

lychee-lib/src/types/input/resolver.rs

@@ -152,7 +152,7 @@ impl InputResolver {
                     yield ResolvedInputSource::Stdin;
                 },
                 InputSource::String(s) => {
-                    yield ResolvedInputSource::String(s.clone().into_owned());
+                    yield ResolvedInputSource::String(s.clone());
                 }
             }
         }

lychee-lib/src/types/input/source.rs

@@ -58,7 +58,7 @@ pub enum ResolvedInputSource {
     /// Standard Input.
     Stdin,
     /// Raw string input.
-    String(String),
+    String(Cow<'static, str>),
 }
 
 impl From<ResolvedInputSource> for InputSource {
@@ -67,7 +67,7 @@ impl From<ResolvedInputSource> for InputSource {
             ResolvedInputSource::RemoteUrl(url) => InputSource::RemoteUrl(url),
             ResolvedInputSource::FsPath(path) => InputSource::FsPath(path),
             ResolvedInputSource::Stdin => InputSource::Stdin,
-            ResolvedInputSource::String(s) => InputSource::String(Cow::Owned(s)),
+            ResolvedInputSource::String(s) => InputSource::String(s),
         }
     }
 }

lychee-lib/src/types/mod.rs

@@ -23,7 +23,7 @@ pub use cache::CacheStatus;
 pub use cookies::CookieJar;
 pub use error::ErrorKind;
 pub use file::{FileExtensions, FileType};
-pub use input::{Input, InputContent, InputResolver, InputSource};
+pub use input::{Input, InputContent, InputResolver, InputSource, ResolvedInputSource};
 pub use request::Request;
 pub use response::{Response, ResponseBody};
 pub use status::Status;

lychee-lib/src/types/request.rs

@@ -2,7 +2,7 @@ use std::{borrow::Cow, convert::TryFrom, fmt::Display};
 
 use crate::{BasicAuthCredentials, ErrorKind, Uri};
 
-use super::InputSource;
+use super::ResolvedInputSource;
 
 /// A request type that can be handle by lychee
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
@@ -12,7 +12,7 @@ pub struct Request {
     pub uri: Uri,
 
     /// The resource which contained the given URI
-    pub source: InputSource,
+    pub source: ResolvedInputSource,
 
     /// Specifies how the URI was rendered inside a document
     /// (for example `img`, `a`, `pre`, or `code`).
@@ -32,7 +32,7 @@ impl Request {
     #[must_use]
     pub const fn new(
         uri: Uri,
-        source: InputSource,
+        source: ResolvedInputSource,
         element: Option<String>,
         attribute: Option<String>,
         credentials: Option<BasicAuthCredentials>,
@@ -59,7 +59,7 @@ impl TryFrom<Uri> for Request {
     fn try_from(uri: Uri) -> Result<Self, Self::Error> {
         Ok(Request::new(
             uri.clone(),
-            InputSource::RemoteUrl(Box::new(uri.url)),
+            ResolvedInputSource::RemoteUrl(Box::new(uri.url)),
             None,
             None,
             None,
@@ -74,7 +74,7 @@ impl TryFrom<String> for Request {
         let uri = Uri::try_from(s.as_str())?;
         Ok(Request::new(
             uri,
-            InputSource::String(Cow::Owned(s)),
+            ResolvedInputSource::String(Cow::Owned(s)),
             None,
             None,
             None,
@@ -89,7 +89,7 @@ impl TryFrom<&str> for Request {
         let uri = Uri::try_from(s)?;
         Ok(Request::new(
             uri,
-            InputSource::String(Cow::Owned(s.to_owned())),
+            ResolvedInputSource::String(Cow::Owned(s.to_owned())),
             None,
             None,
             None,

lychee-lib/src/types/resolver.rs

@@ -1,4 +1,4 @@
-use super::{FileType, InputContent, InputSource};
+use super::{FileType, InputContent, ResolvedInputSource};
 use crate::utils::request;
 use crate::{BasicAuthExtractor, ErrorKind, Result, Uri};
 use http::HeaderMap;
@@ -33,7 +33,7 @@ impl UrlContentResolver {
         let content = get_request_body_text(&self.client, request).await?;
 
         let input_content = InputContent {
-            source: InputSource::RemoteUrl(Box::new(url.clone())),
+            source: ResolvedInputSource::RemoteUrl(Box::new(url.clone())),
             file_type,
             content,
         };