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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

#[macro_use]
extern crate log;
#[macro_use]
extern crate clap;
#[macro_use]
extern crate lazy_static;

use crate::link::Link;
use crate::markup::MarkupFile;
pub mod cli;
pub mod file_traversal;
pub mod link;
pub mod link_extractor;
pub mod link_validator;
pub mod logger;
pub mod markup;
pub use colored::*;

#[derive(Default)]
pub struct Config {
    pub log_level: logger::LogLevel,
    pub folder: String,
    pub markup_types: Vec<markup::MarkupType>,
}

#[derive(Debug, PartialEq)]
pub enum LinkCheckResult {
    Ok(String),
    Failed(String),
    NotImplemented(String),
}

impl LinkCheckResult {
    pub fn success(&self) -> bool {
        match self {
            LinkCheckResult::Ok(..) => true,
            _ => false,
        }
    }
}

pub fn run(config: &Config) -> Result<(), ()> {
    let mut files: Vec<MarkupFile> = Vec::new();
    file_traversal::find(&config, &mut files);

    let mut links: Vec<Link> = Vec::new();
    for file in files {
        links.append(&mut link_extractor::find_links(&file));
    }

    let mut result = Vec::new();
    for link in &links {
        result.push(link_validator::check(link));
    }

    let mut invalid_links = vec![];
    let mut warnings = 0;
    for res in &result {
        match res {
            LinkCheckResult::Ok(val) => {
                println!("{} {}", "OK".green(), val);
            }
            LinkCheckResult::NotImplemented(err) => {
                println!("{} {}", "Warning".yellow(), err);
                warnings += 1;
            }
            LinkCheckResult::Failed(err) => {
                eprintln!("{} {}", "Error".red(), err);
                invalid_links.push(err);
            }
        }
    }

    println!("");
    println!("Result");
    println!("");
    println!("Links: {}", &result.len());
    println!("Warnings: {}", warnings);
    println!("Errors: {}", &invalid_links.len());

    if !invalid_links.is_empty() {
        eprintln!("");
        eprintln!("The following links could not be resolved:");
        for il in invalid_links {
            eprintln!("   {} {}", "Error".red(), il);
        }
        Err(())
    } else {
        Ok(())
    }
}