tangibl 0.1.0

A parser for generating an AST from a set of predefined TopCodes
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

#[cfg(test)]
use enum_iterator::Sequence;
use num_enum::TryFromPrimitive;

#[cfg_attr(test, derive(Sequence))]
#[derive(Clone, Copy, Debug, PartialEq, Eq, TryFromPrimitive)]
#[repr(u32)]
pub enum TokenCode {
    Start = 61,

    // Flow
    // Conditional
    Blocked = 31,
    // Commands
    MoveBackwards = 47,
    MoveForwards = 55,
    Shoot = 59,
    TurnLeft = 79,
    TurnRight = 87,
    // Integer Methods
    Repeat = 91,
    // Boolean Methods
    While = 155,

    // Integer values
    Value1 = 93,
    Value2 = 103,
    Value3 = 107,
    Value4 = 109,
    Value5 = 115,
    Value6 = 117,
    Value7 = 121,
    Value8 = 143,
    ValueInfinite = 151,

    // Conditions
    IsBlocked = 157,
    IsPathClear = 167,

    // An undefined token value
    Undefined = 0,
}

impl TokenCode {
    pub fn value(&self) -> u32 {
        *self as u32
    }
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct Token {
    pub code: TokenCode,
    pub diameter: f64,
    pub orientation: f64,
    pub x: f64,
    pub y: f64,
}

impl Token {
    pub fn new(code: TokenCode, diameter: f64, orientation: f64, x: f64, y: f64) -> Self {
        Self {
            code,
            diameter,
            orientation,
            x,
            y,
        }
    }

    /// Is part of the regular flow of the program. In other words, has a previous and next token.
    pub fn is_flow(&self) -> bool {
        matches!(
            self.code,
            TokenCode::Blocked
                | TokenCode::MoveBackwards
                | TokenCode::MoveForwards
                | TokenCode::Shoot
                | TokenCode::TurnLeft
                | TokenCode::TurnRight
                | TokenCode::Repeat
                | TokenCode::While
        )
    }

    pub fn is_command(&self) -> bool {
        matches!(
            self.code,
            TokenCode::Shoot
                | TokenCode::TurnLeft
                | TokenCode::TurnRight
                | TokenCode::MoveForwards
                | TokenCode::MoveBackwards
        )
    }

    /// Represents a positive integer value.
    pub fn is_value(&self) -> bool {
        matches!(
            self.code,
            TokenCode::Value1
                | TokenCode::Value2
                | TokenCode::Value3
                | TokenCode::Value4
                | TokenCode::Value5
                | TokenCode::Value6
                | TokenCode::Value7
                | TokenCode::Value8
                | TokenCode::ValueInfinite
        )
    }

    /// A method with a condition.
    pub fn is_condition(&self) -> bool {
        matches!(self.code, TokenCode::IsBlocked | TokenCode::IsPathClear)
    }

    /// The ratio of the current token to the expected diameter.
    pub fn ratio(&self, diameter: f64) -> f64 {
        self.diameter / diameter
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use enum_iterator::all;
    use topcodes::TopCode;

    #[test]
    fn tokencode_enum_values_are_valid_topcodes() {
        let tokens = all::<TokenCode>().collect::<Vec<_>>();
        for token in tokens {
            assert!(TopCode::checksum(token.value()) || token.value() == 0);
        }
    }
}