munyo 0.8.0

A data language which aims to be the most efficient way to handwrite data.
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

use crate::{
    builder::builder::{Builder, MetaBuilder},
    error::parse_fail::{parse_fail, PairHelper, ParseFail, ParseFailHelper, ParseFailHelper2},
};

use super::{
    builder_tree::BuilderTree,
    inner_lang::build,
    munyo_parser::{Pair, Pairs, Rule},
    parse_content::parse_content,
    parse_main_line::parse_main_line,
    state::State,
};

pub(crate) fn parse_line_contents<MB, B>(
    pair: Pair,
    indent_level: usize,
    state: &mut State,
    tree: &mut BuilderTree<B>,
    meta_builder: &MB,
) -> Result<(), ParseFail>
where
    MB: MetaBuilder<Item = B>,
    B: Builder,
{
    match pair.as_rule() {
        Rule::define_stmt => {
            state.set_indent(indent_level).op(&pair)?;
            parse_define_stmt(pair.into_inner(), indent_level, state)?;
        }
        Rule::main_line => {
            state.set_indent(indent_level).op(&pair)?;
            let start_index = pair.start_index();
            let r = parse_main_line(pair.into_inner())?;
            build(state, tree, r, meta_builder, start_index).oe(start_index)?;
        }
        Rule::commented_line => {}
        _ => {}
    }
    Ok(())
}

fn parse_define_stmt(
    mut pairs: Pairs,
    indent_level: usize,
    state: &mut State,
) -> Result<(), ParseFail> {
    let mut default_type: String = String::new();
    let mut empty_line_type: String = String::new();
    let mut is_single = false;
    let mut is_double = false;
    let mut is_triple = false;

    state
        .set_indent(indent_level)
        .map_err(|s| parse_fail(&pairs.next().unwrap(), &s))?;

    for pair in pairs {
        match pair.as_rule() {
            Rule::define_stmt_start_symbol => match pair.as_str() {
                ">>>" => is_triple = true,
                ">>" => is_double = true,
                ">" => is_single = true,
                _ => unreachable!(),
            },
            Rule::content => {
                default_type = parse_content(pair.into_inner(), "")?;
            }
            Rule::content_for_empty_line => {
                empty_line_type =
                    parse_content(pair.into_inner().next().unwrap().into_inner(), "")?;
            }
            Rule::comment_text => {}
            _ => unreachable!(),
        }
    }

	let default_type = default_type.trim_matches(' ').to_string();
	let empty_line_type = empty_line_type.trim_matches(' ').to_string();

    if is_single {
        state.set_single_default_types(indent_level, default_type, empty_line_type)
    } else if is_double {
        state.set_doubled_default_types(indent_level, default_type, empty_line_type)
    } else if is_triple {
        state.set_tripled_default_types(indent_level, default_type, empty_line_type)
    } else {
        unreachable!()
    }
    Ok(())
}