crabenv 0.0.1

The simplest, opinionated way to keep .env files, schemas, and examples aligned.
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

use std::collections::{BTreeMap, BTreeSet};
use std::path::PathBuf;

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum WorkspaceKind {
    App,
    Package,
}

#[derive(Clone, Debug)]
pub struct Workspace {
    pub root: PathBuf,
    pub rel: PathBuf,
    pub kind: WorkspaceKind,
    pub framework: String,
}

#[derive(Debug)]
pub struct Project {
    pub root: PathBuf,
    pub is_monorepo: bool,
    pub workspaces: Vec<Workspace>,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum Scope {
    Private,
    Public,
    Unknown,
}

impl Scope {
    pub fn as_str(&self) -> &'static str {
        match self {
            Scope::Private => "private",
            Scope::Public => "public",
            Scope::Unknown => "unknown",
        }
    }
}

#[derive(Clone, Debug)]
pub enum SourceKind {
    EnvExample,
    EnvLocal,
    TsSchema,
    PythonSchema,
    RustSchema,
}

impl SourceKind {
    pub fn surface(&self) -> EnvSurface {
        match self {
            SourceKind::TsSchema | SourceKind::PythonSchema | SourceKind::RustSchema => {
                EnvSurface::Schema
            }
            SourceKind::EnvExample => EnvSurface::Template,
            SourceKind::EnvLocal => EnvSurface::Local,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
pub enum EnvSurface {
    Schema,
    Template,
    Local,
    Sinks,
}

impl EnvSurface {
    pub fn as_str(&self) -> &'static str {
        match self {
            EnvSurface::Schema => "schema",
            EnvSurface::Template => "template",
            EnvSurface::Local => "local",
            EnvSurface::Sinks => "sinks",
        }
    }
}

#[derive(Clone, Debug)]
pub struct VarSource {
    pub name: String,
    pub owner: PathBuf,
    pub scope: Scope,
    pub kind: SourceKind,
    pub value_type: Option<String>,
    pub required: Option<bool>,
    pub default_value: Option<String>,
    pub description: Option<String>,
    pub value: Option<String>,
    pub path: PathBuf,
    pub line: usize,
}

#[derive(Clone, Debug)]
pub struct EnvRecord {
    pub name: String,
    pub owner: PathBuf,
    pub scope: Scope,
    pub value_type: Option<String>,
    pub required: Option<bool>,
    pub default_value: Option<String>,
    pub description: Option<String>,
    pub example_value: Option<String>,
    pub local_present: bool,
    pub surfaces: BTreeSet<EnvSurface>,
    pub surface_sources: BTreeMap<EnvSurface, BTreeSet<String>>,
    pub sources: BTreeSet<String>,
}

#[derive(Clone, Debug)]
pub struct DotenvEntry {
    pub key: String,
    pub value: String,
}

#[derive(Clone, Debug)]
pub struct Issue {
    pub severity: Severity,
    pub message: String,
    pub fix: Option<Fix>,
}

#[derive(Clone, Debug)]
pub enum Severity {
    Info,
    Warn,
    Error,
}

impl Severity {
    pub fn as_str(&self) -> &'static str {
        match self {
            Severity::Info => "info",
            Severity::Warn => "warn",
            Severity::Error => "error",
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum Fix {
    BackfillExample { app: PathBuf, name: String },
    CreateLocalEnv,
}

#[derive(Clone, Debug)]
pub struct VarMutation {
    pub variable: String,
    pub description: Option<String>,
    pub example: Option<String>,
    pub optional: bool,
    pub default_value: Option<String>,
    pub numeric: bool,
    pub number: bool,
    pub boolean: bool,
    pub enum_values: Option<String>,
    pub test_regex: Option<String>,
    pub test_regex_message: Option<String>,
}

#[derive(Clone, Debug)]
pub struct CopyPlan {
    pub writes: Vec<FileWritePlan>,
}

#[derive(Clone, Debug)]
pub struct FileWritePlan {
    pub path: PathBuf,
    pub contents: String,
}