accepted 0.3.2

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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use std::fmt;
use std::process;

use serde_derive::Deserialize;

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

impl Command {
    pub fn new(args: &[String]) -> Option<Self> {
        args.split_first().map(|(fst, rest)| Self {
            program: fst.clone(),
            args: rest.to_vec(),
        })
    }
    pub fn command(&self) -> process::Command {
        let mut res = process::Command::new(&self.program);
        res.args(self.args.iter());
        res
    }
    pub fn summary<P: AsRef<std::path::Path>>(
        &self,
        path: P,
    ) -> Result<String, shellexpand::LookupError<std::env::VarError>> {
        crate::env::set_env(path);
        let prog = shellexpand::full(&self.program)?;
        let args = self
            .args
            .iter()
            .map(shellexpand::full)
            .collect::<Result<Vec<_>, _>>()?;

        Ok(format!("{} {}", prog, args.join(" ")))
    }
}

impl fmt::Display for Command {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", &self.program)?;
        for a in &self.args {
            write!(f, " {}", a)?;
        }
        Ok(())
    }
}

#[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;

    // TODO Those generate impls from macro

    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;
    }

    pub struct TestCommand;
    impl Key for TestCommand {
        type Value = Command;
    }

    pub struct TabNineCommand;
    impl Key for TabNineCommand {
        type Value = Command;
    }

    pub struct Theme;
    impl Key for Theme {
        type Value = String;
    }

    pub struct HardTab;
    impl Key for HardTab {
        type Value = bool;
    }
}