envorigin 1.11.0

Explain where environment variables come from — Docker Compose, GitHub Actions, GitLab CI, CircleCI
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

//! Auto-detection of the project's config format for the top-level
//! commands (`audit` / `scan` / `explain` / `graph`) when the user does
//! not name a target file. The precedence mirrors the GitHub Action
//! wrapper's `target` input: compose → actions → gitlab → circleci →
//! dotenv, so `envorigin audit` in any repo just works.

use std::path::{Path, PathBuf};

/// Which backend a project's config belongs to, plus the detected file.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Target {
    Compose { file: PathBuf },
    Actions { file: PathBuf },
    Gitlab { file: PathBuf },
    Circleci { file: PathBuf },
    Dotenv { file: PathBuf },
}

impl Target {
    /// Human-readable backend name, for "detected X format" notices.
    pub fn kind_name(&self) -> &'static str {
        match self {
            Target::Compose { .. } => "compose",
            Target::Actions { .. } => "GitHub Actions",
            Target::Gitlab { .. } => "GitLab CI",
            Target::Circleci { .. } => "CircleCI",
            Target::Dotenv { .. } => "dotenv",
        }
    }

    /// The config file this target resolves to.
    pub fn file(&self) -> &Path {
        match self {
            Target::Compose { file }
            | Target::Actions { file }
            | Target::Gitlab { file }
            | Target::Circleci { file }
            | Target::Dotenv { file } => file,
        }
    }
}

/// File names Compose accepts, in the order they should win.
const COMPOSE_CANDIDATES: [&str; 4] = [
    "compose.yaml",
    "compose.yml",
    "docker-compose.yml",
    "docker-compose.yaml",
];

/// Detect the project type inside `dir`. Returns `None` when nothing
/// recognizable is there.
pub fn detect_in(dir: &Path) -> Option<Target> {
    for name in COMPOSE_CANDIDATES {
        let candidate = dir.join(name);
        if candidate.is_file() {
            return Some(Target::Compose { file: candidate });
        }
    }
    // Actions: any workflow file, sorted so the result is deterministic.
    let workflows = dir.join(".github/workflows");
    if let Ok(entries) = std::fs::read_dir(&workflows) {
        let mut files: Vec<PathBuf> = entries
            .filter_map(Result::ok)
            .map(|entry| entry.path())
            .filter(|path| {
                path.extension()
                    .map(|extension| extension == "yml" || extension == "yaml")
                    .unwrap_or(false)
            })
            .collect();
        files.sort();
        if let Some(file) = files.first() {
            return Some(Target::Actions { file: file.clone() });
        }
    }
    let gitlab = dir.join(".gitlab-ci.yml");
    if gitlab.is_file() {
        return Some(Target::Gitlab { file: gitlab });
    }
    let circleci = dir.join(".circleci/config.yml");
    if circleci.is_file() {
        return Some(Target::Circleci { file: circleci });
    }
    let dotenv = dir.join(".env");
    if dotenv.is_file() {
        return Some(Target::Dotenv { file: dotenv });
    }
    None
}

/// The directory a project directory argument resolves to. Files are
/// used as-is; directories are walked by [`detect_in`].
pub fn target_from_path(path: &Path) -> Option<Target> {
    if path.is_file() {
        return Some(Target::Compose {
            file: path.to_path_buf(),
        });
    }
    if path.is_dir() {
        return detect_in(path);
    }
    None
}