aster-completion 0.2.0

Natural shell completion
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

use serde::{Deserialize, Serialize};

pub const PROTOCOL_VERSION: u32 = 7;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct RequestEnvelope {
    pub version: u32,
    #[serde(flatten)]
    pub request: Request,
}

impl RequestEnvelope {
    pub fn new(request: Request) -> Self {
        Self {
            version: PROTOCOL_VERSION,
            request,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(tag = "type", rename_all = "snake_case", deny_unknown_fields)]
pub enum Request {
    Ping,
    Shutdown,
    Record {
        command: String,
        cwd: String,
        exit_code: i32,
        observed_at_ms: i64,
        session_id: String,
    },
    Complete {
        buffer: String,
        cursor_byte: usize,
        cwd: String,
        limit: Option<usize>,
    },
    Fuzzy {
        query: String,
        cwd: String,
        limit: Option<usize>,
    },
    ImportHistory {
        path: String,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum Response {
    Pong { version: String },
    Recorded,
    ShuttingDown,
    Completion(CompletionResponse),
    Imported { imported: usize, skipped: bool },
    Error { message: String },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct CompletionResponse {
    pub replace_start_byte: usize,
    pub replace_end_byte: usize,
    pub candidates: Vec<Candidate>,
    pub enrichment_pending: bool,
}

impl CompletionResponse {
    pub fn empty(cursor_byte: usize) -> Self {
        Self {
            replace_start_byte: cursor_byte,
            replace_end_byte: cursor_byte,
            candidates: Vec::new(),
            enrichment_pending: false,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Candidate {
    pub display: String,
    pub description: String,
    pub description_pending: bool,
    pub kind: CandidateKind,
    pub insert_text: String,
    pub accept_text: String,
    pub source: CandidateSource,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum CandidateKind {
    History,
    Command,
    File,
    Directory,
    Option,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum CandidateSource {
    History,
    Command,
    Filesystem,
    Help,
}