etch 0.4.2

Not just a text formatter, don't mark it down, etch it.
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

use crate::nodes::Node;
use crate::plugins::Plugin;
use crate::state::*;

const ELEMENTS: [&str; 7] = ["h1", "h2", "h3", "h4", "h5", "h6", "p"];

#[derive(Debug, PartialEq)]
pub struct WidowedWordsPlugin;

impl WidowedWordsPlugin {
    pub fn new() -> Shared<Self> {
        Shared::share(WidowedWordsPlugin)
    }
}

impl Plugin for WidowedWordsPlugin {
    fn on_node_parsed(&mut self, token: Node) -> Node {
        match token.clone() {
            Node::Element { name, .. } => {
                if ELEMENTS.contains(&name.as_str()) {
                    DeWidower::default().process(token)
                } else {
                    token
                }
            }
            _ => token,
        }
    }
}

struct DeWidower {
    break_found: bool,
}

impl Default for DeWidower {
    fn default() -> Self {
        DeWidower { break_found: false }
    }
}

impl DeWidower {
    fn process(&mut self, token: Node) -> Node {
        match token {
            Node::Element {
                name,
                tags,
                attributes,
                children,
            } => {
                let children = if let Some(children) = children {
                    let mut children: Vec<Node> = children
                        .into_iter()
                        .rev()
                        .map(|child| match child {
                            Node::Element { .. } => self.process(child),
                            Node::Whitespace { .. } => {
                                if !self.break_found {
                                    self.break_found = true;

                                    Node::NonBreakingSpace { space: " ".into() }
                                } else {
                                    child
                                }
                            }
                            _ => child,
                        })
                        .collect();

                    children.reverse();

                    Some(children)
                } else {
                    None
                };

                Node::Element {
                    name,
                    tags,
                    attributes,
                    children,
                }
            }
            _ => token,
        }
    }
}