knave 0.13.1

A Lisp programming language for humans and agents that infers types and ownership and compiles to readable Rust
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

use std::borrow::Cow;

use rustyline::Helper;
use rustyline::completion::Completer;
use rustyline::highlight::{CmdKind, Highlighter};
use rustyline::hint::Hinter;
use rustyline::validate::{ValidationContext, ValidationResult, Validator};

use super::open_input::OpenInput;
use super::token_colors::TokenColors;
use crate::diagnostic::DiagnosticRenderer;

pub struct InputHelper;

impl InputHelper {
    pub fn styled_prompt(prompt: &str) -> String {
        let style = DiagnosticRenderer::GUTTER_STYLE;
        format!("{style}{prompt}{style:#}")
    }

    fn validation_of(input: &str) -> ValidationResult {
        if OpenInput::awaits_more(input) {
            return ValidationResult::Incomplete;
        }
        ValidationResult::Valid(None)
    }
}

impl Highlighter for InputHelper {
    fn highlight<'l>(&self, line: &'l str, _cursor: usize) -> Cow<'l, str> {
        Cow::Owned(TokenColors::Painted.paint(line))
    }

    fn highlight_prompt<'b, 's: 'b, 'p: 'b>(
        &'s self,
        prompt: &'p str,
        _default: bool,
    ) -> Cow<'b, str> {
        Cow::Owned(Self::styled_prompt(prompt))
    }

    fn highlight_char(&self, _line: &str, _cursor: usize, _kind: CmdKind) -> bool {
        true
    }
}

impl Validator for InputHelper {
    fn validate(&self, context: &mut ValidationContext) -> rustyline::Result<ValidationResult> {
        Ok(Self::validation_of(context.input()))
    }
}

impl Completer for InputHelper {
    type Candidate = String;
}

impl Hinter for InputHelper {
    type Hint = String;
}

impl Helper for InputHelper {}

#[cfg(test)]
mod tests {
    use super::*;

    struct HelperFixture;

    impl HelperFixture {
        fn colored(line: &str) -> String {
            InputHelper.highlight(line, 0).into_owned()
        }

        fn continues(input: &str) -> bool {
            matches!(
                InputHelper::validation_of(input),
                ValidationResult::Incomplete
            )
        }
    }

    #[test]
    fn the_typed_line_takes_the_token_colors() {
        assert_eq!(
            HelperFixture::colored("(f :x 1)"),
            TokenColors::Painted.paint("(f :x 1)")
        );
    }

    #[test]
    fn the_prompt_takes_the_gutter_style() {
        let style = DiagnosticRenderer::GUTTER_STYLE;
        let helper = InputHelper;
        assert_eq!(
            helper.highlight_prompt("> ", true),
            format!("{style}> {style:#}")
        );
        assert!(helper.highlight_char("(f 1)", 0, CmdKind::Other));
    }

    #[test]
    fn an_unclosed_list_or_string_continues_the_input() {
        assert!(HelperFixture::continues("(defn f (x)"));
        assert!(HelperFixture::continues("(println \"a"));
    }

    #[test]
    fn a_closed_form_or_another_reader_error_ends_the_input() {
        assert!(!HelperFixture::continues("(+ 1 2)"));
        assert!(!HelperFixture::continues(") ("));
        assert!(!HelperFixture::continues("1 ; ("));
    }
}