add LycheeResult to disambiguate from std Result

lychee-bin/src/commands/dump.rs

@@ -2,7 +2,6 @@ use log::error;
 use log::warn;
 use lychee_lib::Request;
 use lychee_lib::RequestError;
-use lychee_lib::Result;
 use std::fs;
 use std::io::{self, Write};
 use tokio_stream::StreamExt;
@@ -13,9 +12,9 @@ use crate::verbosity::Verbosity;
 use super::CommandParams;
 
 /// Dump all detected links to stdout without checking them
-pub(crate) async fn dump<S>(params: CommandParams<S>) -> Result<ExitCode>
+pub(crate) async fn dump<S>(params: CommandParams<S>) -> lychee_lib::Result<ExitCode>
 where
-    S: futures::Stream<Item = std::result::Result<Request, RequestError>>,
+    S: futures::Stream<Item = Result<Request, RequestError>>,
 {
     let requests = params.requests;
     tokio::pin!(requests);

lychee-bin/src/commands/mod.rs

@@ -15,13 +15,10 @@ use std::sync::Arc;
 use crate::cache::Cache;
 use crate::options::Config;
 use lychee_lib::RequestError;
-use lychee_lib::Result;
 use lychee_lib::{Client, Request};
 
 /// Parameters passed to every command
-pub(crate) struct CommandParams<
-    S: futures::Stream<Item = std::result::Result<Request, RequestError>>,
-> {
+pub(crate) struct CommandParams<S: futures::Stream<Item = Result<Request, RequestError>>> {
     pub(crate) client: Client,
     pub(crate) cache: Arc<Cache>,
     pub(crate) requests: S,
@@ -33,7 +30,7 @@ pub(crate) struct CommandParams<
 /// # Errors
 ///
 /// Returns an error if the output file cannot be opened.
-fn create_writer(output: Option<PathBuf>) -> Result<Box<dyn Write>> {
+fn create_writer(output: Option<PathBuf>) -> lychee_lib::Result<Box<dyn Write>> {
     Ok(match output {
         Some(path) => Box::new(fs::OpenOptions::new().append(true).open(path)?),
         None => Box::new(io::stdout().lock()),

lychee-lib/src/collector.rs

@@ -5,8 +5,8 @@ use crate::filter::PathExcludes;
 
 use crate::types::resolver::UrlContentResolver;
 use crate::{
-    Base, Input, Request, RequestError, Result, basic_auth::BasicAuthExtractor, extract::Extractor,
-    types::FileExtensions, types::uri::raw::RawUri, utils::request,
+    Base, Input, LycheeResult, Request, RequestError, basic_auth::BasicAuthExtractor,
+    extract::Extractor, types::FileExtensions, types::uri::raw::RawUri, utils::request,
 };
 use futures::TryStreamExt;
 use futures::{
@@ -72,7 +72,7 @@ impl Collector {
     ///
     /// Returns an `Err` if the `root_dir` is not an absolute path
     /// or if the reqwest `Client` fails to build
-    pub fn new(root_dir: Option<PathBuf>, base: Option<Base>) -> Result<Self> {
+    pub fn new(root_dir: Option<PathBuf>, base: Option<Base>) -> LycheeResult<Self> {
         if let Some(root_dir) = &root_dir
             && root_dir.is_relative()
         {
@@ -183,7 +183,7 @@ impl Collector {
     pub fn collect_links(
         self,
         inputs: HashSet<Input>,
-    ) -> impl Stream<Item = std::result::Result<Request, RequestError>> {
+    ) -> impl Stream<Item = Result<Request, RequestError>> {
         self.collect_links_from_file_types(inputs, crate::types::FileType::default_extensions())
     }
 
@@ -198,7 +198,7 @@ impl Collector {
         self,
         inputs: HashSet<Input>,
         extensions: FileExtensions,
-    ) -> impl Stream<Item = std::result::Result<Request, RequestError>> {
+    ) -> impl Stream<Item = Result<Request, RequestError>> {
         let skip_missing_inputs = self.skip_missing_inputs;
         let skip_hidden = self.skip_hidden;
         let skip_ignored = self.skip_ignored;
@@ -258,7 +258,7 @@ impl Collector {
                         base.as_ref(),
                         basic_auth_extractor.as_ref(),
                     );
-                    std::result::Result::Ok(stream::iter(requests))
+                    Result::Ok(stream::iter(requests))
                 }
             })
             .try_flatten()
@@ -276,7 +276,7 @@ mod tests {
 
     use super::*;
     use crate::{
-        Result, Uri,
+        LycheeResult, Uri,
         filter::PathExcludes,
         types::{FileType, Input, InputSource},
     };
@@ -286,7 +286,7 @@ mod tests {
         inputs: HashSet<Input>,
         root_dir: Option<PathBuf>,
         base: Option<Base>,
-    ) -> Result<HashSet<Uri>> {
+    ) -> LycheeResult<HashSet<Uri>> {
         let responses = Collector::new(root_dir, base)?.collect_links(inputs);
         Ok(responses.map(|r| r.unwrap().uri).collect().await)
     }
@@ -300,7 +300,7 @@ mod tests {
         root_dir: Option<PathBuf>,
         base: Option<Base>,
         extensions: FileExtensions,
-    ) -> Result<HashSet<Uri>> {
+    ) -> LycheeResult<HashSet<Uri>> {
         let responses = Collector::new(root_dir, base)?
             .include_verbatim(true)
             .collect_links_from_file_types(inputs, extensions);
@@ -314,7 +314,7 @@ mod tests {
     const TEST_GLOB_2_MAIL: &str = "test@glob-2.io";
 
     #[tokio::test]
-    async fn test_file_without_extension_is_plaintext() -> Result<()> {
+    async fn test_file_without_extension_is_plaintext() -> LycheeResult<()> {
         let temp_dir = tempfile::tempdir().unwrap();
         // Treat as plaintext file (no extension)
         let file_path = temp_dir.path().join("README");
@@ -339,7 +339,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_url_without_extension_is_html() -> Result<()> {
+    async fn test_url_without_extension_is_html() -> LycheeResult<()> {
         let input = Input::new("https://example.com/", None, true)?;
         let contents: Vec<_> = input
             .get_contents(
@@ -360,7 +360,7 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_collect_links() -> Result<()> {
+    async fn test_collect_links() -> LycheeResult<()> {
         let temp_dir = tempfile::tempdir().unwrap();
         let temp_dir_path = temp_dir.path();
 

lychee-lib/src/lib.rs

@@ -95,8 +95,8 @@ pub use crate::{
     types::{
         AcceptRange, AcceptRangeError, Base, BasicAuthCredentials, BasicAuthSelector, CacheStatus,
         CookieJar, ErrorKind, FileExtensions, FileType, Input, InputContent, InputResolver,
-        InputSource, Preprocessor, Redirects, Request, RequestError, ResolvedInputSource, Response,
-        ResponseBody, Result, Status, StatusCodeExcluder, StatusCodeSelector, uri::raw::RawUri,
-        uri::valid::Uri,
+        InputSource, LycheeResult, Preprocessor, Redirects, Request, RequestError,
+        ResolvedInputSource, Response, ResponseBody, Result, Status, StatusCodeExcluder,
+        StatusCodeSelector, uri::raw::RawUri, uri::valid::Uri,
     },
 };

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

@@ -9,7 +9,7 @@ use super::source::{InputSource, ResolvedInputSource};
 use crate::Preprocessor;
 use crate::filter::PathExcludes;
 use crate::types::{FileType, RequestError, file::FileExtensions, resolver::UrlContentResolver};
-use crate::{ErrorKind, Result};
+use crate::{ErrorKind, LycheeResult};
 use async_stream::try_stream;
 use futures::stream::{Stream, StreamExt};
 use std::path::{Path, PathBuf};
@@ -42,7 +42,7 @@ impl Input {
         input: &str,
         file_type_hint: Option<FileType>,
         glob_ignore_case: bool,
-    ) -> Result<Self> {
+    ) -> LycheeResult<Self> {
         let source = InputSource::new(input, glob_ignore_case)?;
         Ok(Self {
             source,
@@ -57,7 +57,7 @@ impl Input {
     /// Returns an error if:
     /// - the input does not exist (i.e. the path is invalid)
     /// - the input cannot be parsed as a URL
-    pub fn from_value(value: &str) -> Result<Self> {
+    pub fn from_value(value: &str) -> LycheeResult<Self> {
         Self::new(value, None, false)
     }
 
@@ -95,7 +95,7 @@ impl Input {
         resolver: UrlContentResolver,
         excluded_paths: PathExcludes,
         preprocessor: Option<Preprocessor>,
-    ) -> impl Stream<Item = std::result::Result<InputContent, RequestError>> {
+    ) -> impl Stream<Item = Result<InputContent, RequestError>> {
         try_stream! {
             let source = self.source.clone();
 
@@ -223,7 +223,7 @@ impl Input {
         skip_hidden: bool,
         skip_ignored: bool,
         excluded_paths: &PathExcludes,
-    ) -> impl Stream<Item = Result<String>> {
+    ) -> impl Stream<Item = LycheeResult<String>> {
         InputResolver::resolve(
             &self,
             file_extensions,
@@ -250,7 +250,7 @@ impl Input {
     pub async fn path_content<P: Into<PathBuf> + AsRef<Path> + Clone>(
         path: P,
         preprocessor: Option<&Preprocessor>,
-    ) -> Result<InputContent> {
+    ) -> LycheeResult<InputContent> {
         let path = path.into();
         let content = Self::get_content(&path, preprocessor).await?;
 
@@ -266,7 +266,7 @@ impl Input {
     /// # Errors
     ///
     /// Returns an error if stdin cannot be read
-    pub async fn stdin_content(file_type_hint: Option<FileType>) -> Result<InputContent> {
+    pub async fn stdin_content(file_type_hint: Option<FileType>) -> LycheeResult<InputContent> {
         let mut content = String::new();
         let mut stdin = stdin();
         stdin.read_to_string(&mut content).await?;
@@ -288,7 +288,10 @@ impl Input {
 
     /// Get content of file.
     /// Get preprocessed file content if [`Preprocessor`] is [`Some`]
-    async fn get_content(path: &PathBuf, preprocessor: Option<&Preprocessor>) -> Result<String> {
+    async fn get_content(
+        path: &PathBuf,
+        preprocessor: Option<&Preprocessor>,
+    ) -> LycheeResult<String> {
         if let Some(pre) = preprocessor {
             pre.process(path)
         } else {
@@ -302,7 +305,7 @@ impl Input {
 impl TryFrom<&str> for Input {
     type Error = crate::ErrorKind;
 
-    fn try_from(value: &str) -> std::result::Result<Self, Self::Error> {
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
         Self::from_value(value)
     }
 }

lychee-lib/src/types/mod.rs

@@ -35,3 +35,6 @@ pub use status_code::*;
 
 /// The lychee `Result` type
 pub type Result<T> = std::result::Result<T, crate::ErrorKind>;
+
+/// The lychee `Result` type, aliased to avoid conflicting with std::result::Result.
+pub type LycheeResult<T> = Result<T>;

lychee-lib/src/utils/request.rs

@@ -3,7 +3,7 @@ use reqwest::Url;
 use std::path::{Path, PathBuf};
 
 use crate::{
-    Base, BasicAuthCredentials, ErrorKind, Request, RequestError, Result, Uri,
+    Base, BasicAuthCredentials, ErrorKind, LycheeResult, Request, RequestError, Uri,
     basic_auth::BasicAuthExtractor,
     types::{ResolvedInputSource, uri::raw::RawUri},
     utils::{path, url},
@@ -24,7 +24,7 @@ fn create_request(
     root_dir: Option<&PathBuf>,
     base: Option<&Base>,
     extractor: Option<&BasicAuthExtractor>,
-) -> Result<Request> {
+) -> LycheeResult<Request> {
     let uri = try_parse_into_uri(raw_uri, source, root_dir, base)?;
     let source = source.clone();
     let element = raw_uri.element.clone();
@@ -50,7 +50,7 @@ fn try_parse_into_uri(
     source: &ResolvedInputSource,
     root_dir: Option<&PathBuf>,
     base: Option<&Base>,
-) -> Result<Uri> {
+) -> LycheeResult<Uri> {
     let text = prepend_root_dir_if_absolute_local_link(&raw_uri.text, root_dir);
     let uri = match Uri::try_from(raw_uri.clone()) {
         Ok(uri) => uri,
@@ -86,7 +86,7 @@ fn create_uri_from_file_path(
     file_path: &Path,
     link_text: &str,
     ignore_absolute_local_links: bool,
-) -> Result<Uri> {
+) -> LycheeResult<Uri> {
     let target_path = if is_anchor(link_text) {
         // For anchors, we need to append the anchor to the file name.
         let file_name = file_path
@@ -119,7 +119,7 @@ pub(crate) fn create(
     root_dir: Option<&PathBuf>,
     base: Option<&Base>,
     extractor: Option<&BasicAuthExtractor>,
-) -> Vec<std::result::Result<Request, RequestError>> {
+) -> Vec<Result<Request, RequestError>> {
     let base = base.cloned().or_else(|| Base::from_source(source));
 
     uris.into_iter()
@@ -146,7 +146,7 @@ fn resolve_and_create_url(
     src_path: &Path,
     dest_path: &str,
     ignore_absolute_local_links: bool,
-) -> Result<Url> {
+) -> LycheeResult<Url> {
     let (dest_path, fragment) = url::remove_get_params_and_separate_fragment(dest_path);
 
     // Decode the destination path to avoid double-encoding
@@ -191,7 +191,7 @@ mod tests {
     /// Create requests from the given raw URIs and returns requests that were
     /// constructed successfully, silently ignoring link parsing errors.
     ///
-    /// This reduces the Result handling which is needed in test cases. Test
+    /// This reduces the LycheeResult handling which is needed in test cases. Test
     /// cases can still detect the unexpected appearance of errors by the
     /// length being different.
     fn create_ok_only(
@@ -203,7 +203,7 @@ mod tests {
     ) -> HashSet<Request> {
         create(uris, source, root_dir, base, extractor)
             .into_iter()
-            .filter_map(std::result::Result::ok)
+            .filter_map(Result::ok)
             .collect()
     }