accepted 0.2.0

A text editor to be ACCEPTED.
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

use std::ffi::OsString;
use std::process;

use serde_derive::Deserialize;

#[derive(Debug)]
pub struct Command {
    pub program: OsString,
    pub args: Vec<OsString>,
}

impl Command {
    pub fn new(args: &[String]) -> Option<Self> {
        args.split_first().map(|(fst, rest)| Self {
            program: OsString::from(fst),
            args: rest.iter().map(OsString::from).collect(),
        })
    }
    pub fn command(&self) -> process::Command {
        let mut res = process::Command::new(&self.program);
        res.args(self.args.iter());
        res
    }
}

#[derive(Deserialize, Debug, Clone)]
pub enum CompilerType {
    #[serde(rename = "rustc")]
    Rustc,
    #[serde(rename = "gcc")]
    Gcc,
}

#[derive(Deserialize, Debug, Clone)]
pub struct CompilerConfig {
    pub command: Vec<String>,
    pub optimize_option: Vec<String>,
    #[serde(rename = "type")]
    pub output_type: Option<CompilerType>,
}

//

pub mod keys {
    use std::collections::BTreeMap;

    use typemap::Key;

    use crate::config::types::Command;
    use crate::config::types::CompilerConfig;

    pub struct ANSIColor;

    impl Key for ANSIColor {
        type Value = bool;
    }

    pub struct Snippets;

    impl Key for Snippets {
        type Value = BTreeMap<String, String>;
    }

    pub struct IndentWidth;

    impl Key for IndentWidth {
        type Value = usize;
    }

    pub struct LSP;

    impl Key for LSP {
        type Value = Command;
    }

    pub struct Formatter;

    impl Key for Formatter {
        type Value = Command;
    }

    pub struct SyntaxExtension;

    impl Key for SyntaxExtension {
        type Value = String;
    }

    pub struct Compiler;

    impl Key for Compiler {
        type Value = CompilerConfig;
    }
}