kzones-config 0.1.2

Make definitions of kzones layouts easier
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

use pest::{error::Error as PestError, iterators::Pair, Parser};
use pest_derive::Parser;
use snafu::prelude::*;

use crate::{
    instruction::{Instruction, Node},
    zone::Direction,
};

#[derive(Parser)]
#[grammar = "grammar.pest"]
pub struct LayoutParser;

pub fn parse(input: &str) -> ParserResult<Instruction> {
    let mut parse = LayoutParser::parse(Rule::instruction, input).context(PestSnafu)?;
    let pair: pest::iterators::Pair<'_, Rule> = parse.next().expect("At last one pair is expected");
    let result = parse_instruction(pair)?;
    match parse.next() {
        Some(_) => Err(ParserError::MoreThanOne),
        None => Ok(result),
    }
}

fn parse_instruction(pair: Pair<Rule>) -> ParserResult<Instruction> {
    let mut inner = pair.into_inner();
    let direction = match inner.next().map(|p| p.as_rule()) {
        Some(Rule::horizontal) => Direction::Horizontal,
        Some(Rule::vertical) => Direction::Vertical,
        _ => unreachable!("Expected horizontal or vertical direction"),
    };
    let children_result: Result<Vec<_>, ParserError> = inner.map(parse_node).collect();
    Ok(Instruction::Split {
        direction,
        children: children_result?,
    })
}

fn parse_node(pair: Pair<Rule>) -> ParserResult<Node> {
    let rule = pair.as_rule();
    let mut inner = pair.into_inner();
    let first_pair = inner.next().expect("Node always have at last one child");
    let ratio = first_pair
        .as_str()
        .parse()
        .expect("Rule allows only correct integers");
    let result = match rule {
        Rule::leaf => Node {
            ratio,
            instruction: Instruction::Leaf,
        },
        Rule::split => {
            let instruction =
                parse_instruction(inner.next().expect("Split always have a second inner rule"))?;
            Node { ratio, instruction }
        }
        _ => unreachable!("Expected leaf or split"),
    };
    Ok(result)
}

#[cfg(test)]
mod tests {
    use crate::{
        instruction::{Instruction, Node},
        zone::Direction,
    };

    use super::parse;

    #[test]
    fn test_parse() {
        let actual = parse("h(1, 2: v(3, 4), 5)").unwrap();
        let expected = Instruction::Split {
            direction: Direction::Horizontal,
            children: vec![
                Node {
                    ratio: 1.0,
                    instruction: Instruction::Leaf,
                },
                Node {
                    ratio: 2.0,
                    instruction: Instruction::Split {
                        direction: Direction::Vertical,
                        children: vec![
                            Node {
                                ratio: 3.0,
                                instruction: Instruction::Leaf,
                            },
                            Node {
                                ratio: 4.0,
                                instruction: Instruction::Leaf,
                            },
                        ],
                    },
                },
                Node {
                    ratio: 5.0,
                    instruction: Instruction::Leaf,
                },
            ],
        };

        assert_eq!(expected, actual);
    }
}

pub type ParserResult<T> = Result<T, ParserError>;

#[derive(Debug, Snafu)]
pub enum ParserError {
    #[snafu(display("parser error:\n{source}"))]
    Pest { source: PestError<Rule> },
    #[snafu(display("more than one layout description"))]
    MoreThanOne,
}