setu-cli 0.1.4

A quick markdown link checker
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

use std::{path::PathBuf, time::Duration};

use futures::StreamExt;
use reqwest::{Client, StatusCode};

use crate::checker::{LinkCheckResult, LinkStatus, RemoteLinkStatus};

async fn evaluate_remote_url(
    mdx_path: PathBuf,
    remote_url: String,
    client: Client,
    concerns: &Option<Vec<u16>>,
) -> LinkCheckResult {
    let response = client
        .head(&remote_url)
        .timeout(Duration::from_secs(5))
        .send()
        .await;

    match response {
        Ok(res) => {
            // Concerning URL's are matched against program arguments
            let status = if res.status() == StatusCode::OK {
                RemoteLinkStatus::Reachable
            } else {
                let return_code = res.status().as_u16();
                match concerns {
                    Some(codes) if codes.contains(&return_code) => {
                        RemoteLinkStatus::Concern(return_code)
                    }
                    _ => RemoteLinkStatus::Reachable,
                }
            };
            LinkCheckResult {
                source_file: mdx_path,
                raw_link: remote_url,
                status: LinkStatus::Remote(status),
            }
        }
        Err(err) => LinkCheckResult {
            source_file: mdx_path.clone(),
            raw_link: remote_url.to_owned(),
            status: LinkStatus::Remote(RemoteLinkStatus::Invalid(err.to_string())),
        },
    }
}

pub async fn evaluate(
    mdx_path: &PathBuf,
    remote_urls: Vec<String>,
    client: &Client,
    concerns: &Option<Vec<u16>>,
) -> Vec<LinkCheckResult> {
    const MAX_CONCURRENT_REQUESTS: usize = 50;

    let worker_stream = futures::stream::iter(remote_urls)
        .map(|url| {
            let client = client.clone();
            let mdx_path = mdx_path.clone();
            async move { evaluate_remote_url(mdx_path, url, client, concerns).await }
        })
        .buffer_unordered(MAX_CONCURRENT_REQUESTS);

    let results: Vec<LinkCheckResult> = worker_stream.collect().await;
    results
}