knave 0.13.4

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

use std::convert::Infallible;
use std::ffi::OsStr;

use clap::builder::{StringValueParser, TypedValueParser};
use clap::error::{ContextKind, ContextValue, ErrorKind};
use clap::{Arg, Command, Error};

use super::doc::DocCommand;
use crate::language::Language;

#[derive(Clone)]
pub struct TermParser;

impl TermParser {
    const LONG_FLAG_PREFIX: &str = "--";

    fn unknown_flag(command: &Command, flag: String) -> Error {
        let mut error = Self::unexpected(command, flag);
        error.insert(
            ContextKind::Suggested,
            ContextValue::StyledStrs(vec![Self::separator_tip().into()]),
        );
        error
    }

    fn separator_tip() -> String {
        format!(
            "to look up a term that starts with `{prefix}`, write `{} {} {prefix} <term>`",
            Language::NAME,
            DocCommand::NAME,
            prefix = Self::LONG_FLAG_PREFIX
        )
    }

    fn unexpected(command: &Command, argument: String) -> Error {
        let mut error = Error::new(ErrorKind::UnknownArgument).with_cmd(command);
        error.insert(ContextKind::InvalidArg, ContextValue::String(argument));
        error.insert(
            ContextKind::Usage,
            ContextValue::StyledStr(command.clone().render_usage()),
        );
        error
    }
}

impl TypedValueParser for TermParser {
    type Value = String;

    fn parse_ref(
        &self,
        command: &Command,
        argument: Option<&Arg>,
        value: &OsStr,
    ) -> Result<String, Error> {
        let term = StringValueParser::new().parse_ref(command, argument, value)?;
        if term.starts_with(Self::LONG_FLAG_PREFIX) {
            return Err(Self::unknown_flag(command, term));
        }
        Ok(term)
    }
}

#[derive(Clone)]
pub struct SurplusParser;

impl TypedValueParser for SurplusParser {
    type Value = Infallible;

    fn parse_ref(
        &self,
        command: &Command,
        _argument: Option<&Arg>,
        value: &OsStr,
    ) -> Result<Infallible, Error> {
        Err(TermParser::unexpected(
            command,
            value.to_string_lossy().into_owned(),
        ))
    }
}