flatiron 1.0.5

A parser and HTML renderer for the Textile markup language
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

use crate::structs::InlineTag;
use nom::{
    branch::alt,
    bytes::complete::tag,
    character::complete::{char, digit1, satisfy},
    combinator::{eof, map, opt, value},
    sequence::tuple,
    IResult,
};

pub fn punctuation(input: &str) -> IResult<&str, InlineTag> {
    let (rest, s) = alt((
        apostrophe,
        apostrophe2,
        single_closing,
        double_closing,
        dimension_sign,
        map(
            alt((
                value("‘", tag("'")),
                value("“", tag("\"")),
                value("…", tag("...")),
                value("—", tag("--")),
                value(" – ", tag(" - ")),
                value("™", tag("(TM)")),
                value("®", tag("(R)")),
                value("©", tag("(C)")),
            )),
            |s| String::from(s),
        ),
    ))(input)?;
    Ok((rest, InlineTag::Plaintext(s)))
}

fn apostrophe(input: &str) -> IResult<&str, String> {
    let (rest, (c0, apos, c1)) =
        tuple((alphanumeric, value('’', char('\'')), alphanumeric))(input)?;
    Ok((rest, format!("{}{}{}", c0, apos, c1)))
}

fn apostrophe2(input: &str) -> IResult<&str, String> {
    let (rest, (space, apos, num, alphanum, end)) = tuple((
        whitespace,
        value('’', char('\'')),
        digit1,
        opt(alphanumeric),
        satisfy(|c| !(c.is_alphanumeric() || c == '\'')),
    ))(input)?;
    Ok((
        rest,
        format!(
            "{}{}{}{}{}",
            space,
            apos,
            num,
            match alphanum {
                Some(c) => String::from(c),
                None => String::new(),
            },
            end
        ),
    ))
}

fn single_closing(input: &str) -> IResult<&str, String> {
    let (rest, (non_space, apos, end)) = tuple((
        non_whitespace,
        value('’', char('\'')),
        alt((
            value(String::new(), eof),
            map(non_alphanumeric, |c| String::from(c)),
        )),
    ))(input)?;
    Ok((rest, format!("{}{}{}", non_space, apos, end)))
}

fn double_closing(input: &str) -> IResult<&str, String> {
    let (rest, (non_space, apos, end)) = tuple((
        non_whitespace,
        value('”', char('"')),
        alt((
            value(String::new(), eof),
            map(non_alphanumeric, |c| String::from(c)),
        )),
    ))(input)?;
    Ok((rest, format!("{}{}{}", non_space, apos, end)))
}

fn alphanumeric(input: &str) -> IResult<&str, char> {
    satisfy(|c| c.is_alphanumeric())(input)
}

fn non_alphanumeric(input: &str) -> IResult<&str, char> {
    satisfy(|c| !c.is_alphanumeric())(input)
}

fn whitespace(input: &str) -> IResult<&str, char> {
    satisfy(|c| c.is_whitespace())(input)
}

fn non_whitespace(input: &str) -> IResult<&str, char> {
    satisfy(|c| !c.is_whitespace())(input)
}

fn dimension_sign(input: &str) -> IResult<&str, String> {
    let (rest, (num0, space0, x, space1, num1)) = tuple((
        digit1,
        alt((tag(" "), tag(""))),
        value('×', char('x')),
        alt((tag(" "), tag(""))),
        digit1,
    ))(input)?;
    Ok((rest, format!("{}{}{}{}{}", num0, space0, x, space1, num1)))
}