crabenv 0.0.5

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

use anyhow::Result;

use crate::models::{Project, VarSource, Workspace};

pub mod dotenv;
pub mod python;
pub mod rust;
pub mod typescript;

pub trait WorkspaceAdapter {
    fn name(&self) -> &'static str;
    fn collect(&self, project: &Project, workspace: &Workspace) -> Result<Vec<VarSource>>;
}

impl WorkspaceAdapter for RustAdapter {
    fn name(&self) -> &'static str {
        "rust"
    }

    fn collect(&self, _project: &Project, workspace: &Workspace) -> Result<Vec<VarSource>> {
        rust::collect_schema(workspace)
    }
}

pub trait ProjectAdapter {
    fn name(&self) -> &'static str;
    fn collect(&self, project: &Project) -> Result<Vec<VarSource>>;
}

struct DotenvExampleAdapter;
struct DotenvLocalAdapter;
struct DotenvRootLocalAdapter;
struct TypeScriptPrivateAdapter;
struct TypeScriptPublicAdapter;
struct PythonAdapter;
struct RustAdapter;

impl WorkspaceAdapter for DotenvExampleAdapter {
    fn name(&self) -> &'static str {
        "dotenv-example"
    }

    fn collect(&self, _project: &Project, workspace: &Workspace) -> Result<Vec<VarSource>> {
        dotenv::collect_example(workspace)
    }
}

impl WorkspaceAdapter for DotenvLocalAdapter {
    fn name(&self) -> &'static str {
        "dotenv-local"
    }

    fn collect(&self, project: &Project, workspace: &Workspace) -> Result<Vec<VarSource>> {
        dotenv::collect_local(project, workspace)
    }
}

impl ProjectAdapter for DotenvRootLocalAdapter {
    fn name(&self) -> &'static str {
        "dotenv-root-local"
    }

    fn collect(&self, project: &Project) -> Result<Vec<VarSource>> {
        dotenv::collect_root_local(project)
    }
}

impl WorkspaceAdapter for TypeScriptPrivateAdapter {
    fn name(&self) -> &'static str {
        "typescript-private"
    }

    fn collect(&self, _project: &Project, workspace: &Workspace) -> Result<Vec<VarSource>> {
        typescript::collect_private_schema(workspace)
    }
}

impl WorkspaceAdapter for TypeScriptPublicAdapter {
    fn name(&self) -> &'static str {
        "typescript-public"
    }

    fn collect(&self, _project: &Project, workspace: &Workspace) -> Result<Vec<VarSource>> {
        typescript::collect_public_schema(workspace)
    }
}

impl WorkspaceAdapter for PythonAdapter {
    fn name(&self) -> &'static str {
        "python"
    }

    fn collect(&self, _project: &Project, workspace: &Workspace) -> Result<Vec<VarSource>> {
        python::collect_schema(workspace)
    }
}

pub fn workspace_adapters() -> Vec<Box<dyn WorkspaceAdapter>> {
    vec![
        Box::new(DotenvExampleAdapter),
        Box::new(DotenvLocalAdapter),
        Box::new(TypeScriptPrivateAdapter),
        Box::new(TypeScriptPublicAdapter),
        Box::new(PythonAdapter),
        Box::new(RustAdapter),
    ]
}

pub fn project_adapters() -> Vec<Box<dyn ProjectAdapter>> {
    vec![Box::new(DotenvRootLocalAdapter)]
}

pub fn workspace_has_owned_env_files(workspace: &Workspace) -> bool {
    dotenv::example_path(workspace).exists()
        || typescript::private_schema_path(workspace).exists()
        || typescript::public_schema_path(workspace).exists()
        || typescript::should_use_plain_schema(workspace)
        || python::find_env_file(&workspace.root).is_some()
        || rust::config_path(workspace).exists()
}