imgscale 0.2.1

A library for generating various sizes of an image and the appropriate html <img> tag
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

use crate::{Error, Result, model::GeneratedImage};
use std::path::{self, Path};

#[rustfmt::skip]
pub fn build_img_tag(images: &[GeneratedImage], sizes: Option<&str>, alt: Option<&str>) -> Result<String> {
    let srcset = build_srcset(images);
    let last_image = images.last().ok_or(Error::EmptyImageList)?;
    let fallback_src = last_image.web_url();

    let sizes = match sizes {
        Some(s) => s.into(),
        None => {
            let max_width = last_image.width();
            format!("(max-width: {max_width}px) 100vw, {max_width}px")
        }
    };

    let alt = alt.unwrap_or("INSERT ALT TEXT HERE");

Ok(format!(
r###"<img
  srcset="{}"
  sizes="{}"
  src="{}"
  loading="lazy" decoding="async"
  alt="{}"
>"###,
srcset, sizes, fallback_src, alt,
))
}

fn build_srcset(images: &[GeneratedImage]) -> String {
    images
        .iter()
        .map(|img| img.as_srcset_entry())
        .collect::<Vec<String>>()
        .join(", ")
}

pub(crate) fn resolve_web_url(file_path: &Path, webserver_root: Option<&Path>) -> Result<String> {
    let webserver_root = match webserver_root {
        Some(root) => root,
        None => {
            let filename = file_path
                .file_name()
                .ok_or_else(|| Error::FilenameExtraction(file_path.to_path_buf()))?
                .to_str()
                .ok_or_else(|| Error::InvalidUtf8(format!("{:?}", file_path)))?;
            return Ok(filename.to_string());
        }
    };

    let absolute_file = path::absolute(file_path)?;
    let absolute_root = path::absolute(webserver_root)?;

    let relative_path =
        absolute_file
            .strip_prefix(&absolute_root)
            .map_err(|_| Error::FileOutsideRoot {
                file: absolute_file.clone(),
                root: absolute_root,
            })?;

    let mut web_url = String::new();
    for component in relative_path.components() {
        if let path::Component::Normal(segment) = component {
            if let Some(segment_str) = segment.to_str() {
                web_url.push('/');
                web_url.push_str(segment_str);
            } else {
                return Err(Error::InvalidUtf8(format!("{:?}", relative_path)));
            }
        }
    }

    if web_url.is_empty() {
        Ok("/".to_string())
    } else {
        Ok(web_url)
    }
}