rested 0.11.0

Language/Interpreter for easily defining and running requests to an http server.
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

use crate::lexer::locations::Span;
use tower_lsp::lsp_types::Position;

pub trait ContainsPosition {
    fn contains(&self, position: &Position) -> bool;
    fn is_after(&self, position: &Position) -> bool;
    fn is_on_or_after(&self, position: &Position) -> bool;
}

impl ContainsPosition for Span {
    fn contains(&self, position: &Position) -> bool {
        if self.start.line == self.end.line && self.start.line == position.line as usize {
            return (self.start.col..=self.end.col).contains(&(position.character as usize));
        }
        (self.start.line..=self.end.line).contains(&(position.line as usize))
    }

    fn is_after(&self, position: &Position) -> bool {
        if self.start.line < position.line as usize {
            return false;
        }

        if self.start.line == position.line as usize {
            return self.start.col > position.character as usize;
        }

        return true;
    }

    fn is_on_or_after(&self, position: &Position) -> bool {
        return self.is_after(position) || self.contains(position);
    }
}

#[cfg(test)]
mod tests {
    use crate::language_server::position::ContainsPosition;
    use crate::lexer::locations::Position;
    use crate::lexer::locations::Span;

    use tower_lsp::lsp_types;

    const SPAN: Span = Span {
        start: Position {
            value: 4,
            line: 0,
            col: 4,
        },
        end: Position {
            value: 9,
            line: 0,
            col: 9,
        },
    };

    const NO_SPAN: Span = Span {
        start: Position {
            value: 13,
            line: 1,
            col: 12,
        },
        end: Position {
            value: 13,
            line: 1,
            col: 12,
        },
    };

    #[test]
    fn test_contains() {
        let position = &tower_lsp::lsp_types::Position {
            line: 0,
            character: 4,
        };

        assert!(SPAN.contains(position));

        let position = &tower_lsp::lsp_types::Position {
            line: 0,
            character: 7,
        };

        assert!(SPAN.contains(position));

        let position = &tower_lsp::lsp_types::Position {
            line: 0,
            character: 10,
        };

        assert!(!SPAN.contains(position));

        let position = &tower_lsp::lsp_types::Position {
            line: 2,
            character: 4,
        };

        assert!(!SPAN.contains(position));

        assert!(NO_SPAN.contains(&tower_lsp::lsp_types::Position {
            line: 1,
            character: 12,
        }))
    }

    #[test]
    fn test_is_after() {
        assert!(SPAN.is_after(&lsp_types::Position {
            line: 0,
            character: 1
        }))
    }
}