ruSTLa 0.38.0

A reStructuredText → LarST ⊂ LaTeX transpiler.
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
143
144
145
146
147
148
149

/*!
A submodule for `State::EnumeratedList` related transition functions.

Copyright © 2020 Santtu Söderholm
*/

use super::*;

/// Parses enumerated list items inside enumerated lists.
pub fn enumerator(
    src_lines: &Vec<String>,
    base_indent: usize,
    section_level: &mut usize,
    line_cursor: &mut LineCursor,
    mut doctree: DocTree,
    captures: &regex::Captures,
    pattern_name: &Pattern,
) -> TransitionResult {

    let (list_delims, list_kind, list_start_index, n_of_items,list_enumerator_indent) = match doctree.shared_node_data() {
        TreeNodeType::EnumeratedList { delims, kind, start_index, n_of_items, enumerator_indent } => (*delims, *kind, *start_index, *n_of_items, *enumerator_indent),
        _ => return TransitionResult::Failure {
            message: format!("Not focused on enumerated list when parsing an enumerated list item on line {}. Computer says no...", line_cursor.sum_total()),
            doctree: doctree
        }
    };

    let detected_enumerator_indent = captures.get(1).unwrap().as_str().chars().count() + base_indent;
    let detected_text_indent = captures.get(0).unwrap().as_str().chars().count() + base_indent;

    // Retrieve parent list information
    let (detected_number, detected_kind, detected_delims) =
        match converters::enum_captures_to_int_kind_and_delims(
            &captures,
            Some(&list_kind),
            true,
            false,
            n_of_items,
            list_start_index,
        ) {
            Some((number, kind, delims)) => (number, kind, delims),
            None => return TransitionResult::Failure {
                message: format!(
                    "Could not convert a list enumerator to number on line {}. Computer saus no...",
                    line_cursor.sum_total()
                ),
                doctree: doctree,
            },
        };

    // Ceck validity of list item
    if ! Parser::is_enumerated_list_item(
        src_lines,
        line_cursor,
        captures,
        section_level,
        base_indent,
        detected_enumerator_indent,
        detected_number,
        detected_kind,
        detected_delims,
        pattern_name,
        &list_kind,
        true,
        n_of_items,
        list_start_index
    ) {
        return super::body::text(src_lines, base_indent, section_level, line_cursor, doctree, captures, pattern_name)
    };
    if list_delims == detected_delims
        && detected_kind == list_kind
        && list_enumerator_indent == detected_enumerator_indent
        && detected_number == n_of_items + list_start_index
    {
        // Modify relevant list parameters
        if let TreeNodeType::EnumeratedList { n_of_items, .. } = doctree.mut_node_data() {
            *n_of_items += 1;
        }
        let item_node_data = TreeNodeType::EnumeratedListItem {
            delims: list_delims,
            kind: detected_kind,
            index_in_list: detected_number,
            enumerator_indent: detected_enumerator_indent,
            text_indent: detected_text_indent,
        };
        doctree = match doctree.push_data_and_focus(item_node_data) {
            Ok(tree) => tree,
            Err(tree) => {
                return TransitionResult::Failure {
                    message: format!(
                        "Node insertion error on line {}. Computer says no...",
                        line_cursor.sum_total()
                    ),
                    doctree: tree,
                }
            }
        };
        let relative_indent = detected_text_indent - base_indent;
        let (lines, offset) = match Parser::read_indented_block(
            src_lines,
            line_cursor.relative_offset(),
            false,
            true,
            Some(relative_indent),
            Some(relative_indent),
            false
        ) {
            IndentedBlockResult::Ok { lines, offset, .. } => (lines, offset),
            _ => return TransitionResult::Failure {
                message: format!(
                    "Could not read text block on line {}.",
                    line_cursor.sum_total()
                ),
                doctree: doctree
            }
        };

        let (doctree, state_stack) = match Parser::new(
            lines,
            doctree,
            detected_text_indent,
            line_cursor.sum_total(),
            State::ListItem,
            *section_level
        ).parse() {
            ParsingResult::EOF {doctree, state_stack}
            | ParsingResult::EmptyStateStack {doctree, state_stack} => (doctree, state_stack),
            ParsingResult::Failure {doctree, message }  => return TransitionResult::Failure {
                message: format!(
                    "Nested parsing failed on line {}.",
                    line_cursor.sum_total()
                ),
                doctree: doctree
            }
        };

        return TransitionResult::Success {
            doctree: doctree,
            push_or_pop: PushOrPop::Push(state_stack),
            line_advance: LineAdvance::Some(offset),
        };
    } else {
        return TransitionResult::Success {
            doctree: doctree.focus_on_parent(),
            push_or_pop: PushOrPop::Pop,
            line_advance: LineAdvance::None,
        };
    }
}