ironpress 1.4.4

Pure Rust HTML/CSS/Markdown to PDF converter with layout engine, LaTeX math, tables, images, custom fonts, and streaming output. No browser, no system dependencies.
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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::layout::engine::LayoutBorderSide;
use crate::style::computed::BorderStyle;

/// CSS table box that supplied one collapsed-border candidate. Declaration
/// order is also the CSS tie-break order from least to most specific.
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord)]
pub(super) enum CollapsedBorderOrigin {
    #[default]
    Table,
    ColumnGroup,
    Column,
    RowGroup,
    Row,
    Cell,
}

/// One authored border side together with its table-box origin.
#[derive(Debug, Clone, Copy, Default)]
pub(super) struct BorderCandidate {
    pub(super) side: LayoutBorderSide,
    pub(super) origin: CollapsedBorderOrigin,
}

pub(super) fn collapsed_style_rank(style: BorderStyle) -> u8 {
    match style {
        BorderStyle::Double => 8,
        BorderStyle::Solid => 7,
        BorderStyle::Dashed => 6,
        BorderStyle::Dotted => 5,
        BorderStyle::Ridge => 4,
        BorderStyle::Outset => 3,
        BorderStyle::Groove => 2,
        BorderStyle::Inset => 1,
        BorderStyle::Hidden | BorderStyle::None => 0,
    }
}

fn collapsed_border_winner(first: BorderCandidate, second: BorderCandidate) -> Option<usize> {
    match (first.side.style, second.side.style) {
        (BorderStyle::Hidden, _) => return Some(0),
        (_, BorderStyle::Hidden) => return Some(1),
        _ => {}
    }
    match (first.side.paints(), second.side.paints()) {
        (false, false) => return None,
        (true, false) => return Some(0),
        (false, true) => return Some(1),
        (true, true) => {}
    }
    match first
        .side
        .width
        .partial_cmp(&second.side.width)
        .unwrap_or(std::cmp::Ordering::Equal)
    {
        std::cmp::Ordering::Greater => Some(0),
        std::cmp::Ordering::Less => Some(1),
        std::cmp::Ordering::Equal => {
            let first_rank = collapsed_style_rank(first.side.style);
            let second_rank = collapsed_style_rank(second.side.style);
            match first_rank.cmp(&second_rank) {
                std::cmp::Ordering::Greater => Some(0),
                std::cmp::Ordering::Less => Some(1),
                std::cmp::Ordering::Equal => {
                    if first.origin >= second.origin {
                        Some(0)
                    } else {
                        Some(1)
                    }
                }
            }
        }
    }
}

pub(super) fn harmonize_candidates(
    candidates: impl IntoIterator<Item = BorderCandidate>,
) -> BorderCandidate {
    candidates
        .into_iter()
        .reduce(
            |winner, candidate| match collapsed_border_winner(winner, candidate) {
                Some(1) => candidate,
                _ => winner,
            },
        )
        .unwrap_or_default()
}

pub(super) fn resolved_side(candidate: BorderCandidate) -> LayoutBorderSide {
    if candidate.side.style == BorderStyle::Hidden {
        LayoutBorderSide::default()
    } else {
        candidate.side
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn solid(width: f32) -> LayoutBorderSide {
        LayoutBorderSide {
            width,
            style: BorderStyle::Solid,
            ..Default::default()
        }
    }

    #[test]
    fn collapsed_style_rank_covers_the_full_css_order() {
        let ordered = [
            BorderStyle::Inset,
            BorderStyle::Groove,
            BorderStyle::Outset,
            BorderStyle::Ridge,
            BorderStyle::Dotted,
            BorderStyle::Dashed,
            BorderStyle::Solid,
            BorderStyle::Double,
        ];
        for pair in ordered.windows(2) {
            assert!(collapsed_style_rank(pair[0]) < collapsed_style_rank(pair[1]));
        }
    }

    #[test]
    fn hidden_border_suppresses_a_collapsed_neighbor() {
        let hidden = BorderCandidate {
            side: LayoutBorderSide {
                style: BorderStyle::Hidden,
                ..Default::default()
            },
            origin: CollapsedBorderOrigin::Cell,
        };
        let solid = BorderCandidate {
            side: solid(8.0),
            origin: CollapsedBorderOrigin::Cell,
        };
        assert_eq!(collapsed_border_winner(hidden, solid), Some(0));
    }
}