dezoomify-rs 2.18.1

Allows downloading zoomable images. Supports several different formats such as zoomify, iiif, and deep zoom images.
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

use std::fmt::{Debug, Display};

use super::{DezoomerError, ImageUrl, Images, ResolvedImage, ZoomableImage};

pub fn expect_only<T: Debug>(mut values: Vec<T>) -> T {
    assert_eq!(
        values.len(),
        1,
        "expected exactly one value, got {values:#?}"
    );
    values.pop().unwrap()
}

pub fn expect_resolved_images(images: Images) -> Vec<ResolvedImage> {
    images
        .into_iter()
        .enumerate()
        .map(|(index, image)| match image {
            ZoomableImage::Resolved(image) => image,
            ZoomableImage::Url(url) => {
                panic!("expected resolved image at index {index}, got URL {url:?}")
            }
        })
        .collect()
}

pub fn expect_single_resolved(images: Images) -> ResolvedImage {
    assert_eq!(
        images.len(),
        1,
        "expected exactly one resolved image, got {images:#?}"
    );
    expect_resolved_images(images).pop().unwrap()
}

pub fn expect_image_urls(images: Images) -> Vec<ImageUrl> {
    images
        .into_iter()
        .enumerate()
        .map(|(index, image)| match image {
            ZoomableImage::Url(url) => url,
            ZoomableImage::Resolved(image) => {
                panic!("expected image URL at index {index}, got resolved image {image:?}")
            }
        })
        .collect()
}

pub fn expect_single_url(images: Images) -> ImageUrl {
    assert_eq!(
        images.len(),
        1,
        "expected exactly one image URL, got {images:#?}"
    );
    expect_image_urls(images).pop().unwrap()
}

pub fn expect_needs_data<T: Debug>(result: Result<T, DezoomerError>) -> String {
    match result {
        Err(DezoomerError::NeedsData { uri }) => uri,
        other => panic!("expected NeedsData, got {other:?}"),
    }
}

pub fn assert_error_contains<T, E>(result: Result<T, E>, fragments: &[&str])
where
    T: Debug,
    E: Debug + Display,
{
    let error = result.expect_err("expected an error").to_string();
    for fragment in fragments {
        assert!(
            error.contains(fragment),
            "expected error {error:?} to contain {fragment:?}"
        );
    }
}