ch-rds 0.1.12

Runtime resource loading and local service orchestration
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151

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

use anyhow::{Context, Result, anyhow};
use ch_config::environment::{EnvFiles, EnvLoad};

/// Filesystem layout discovered for the running application.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Project {
    root: PathBuf,
}

impl Project {
    /// Discovers the application root from the working directory or executable.
    pub fn discover() -> Result<Self> {
        let current_dir =
            env::current_dir().context("failed to determine the working directory")?;
        if let Some(project) = Self::find_from(&current_dir) {
            return Ok(project);
        }

        let executable = env::current_exe().context("failed to determine the executable path")?;
        Self::find_from(&executable).ok_or_else(|| {
            anyhow!(
                "failed to discover the application root from {} or {}",
                current_dir.display(),
                executable.display()
            )
        })
    }

    /// Discovers an application root from a caller-provided path.
    pub fn discover_from(start: impl AsRef<Path>) -> Result<Self> {
        Self::find_from(start.as_ref()).ok_or_else(|| {
            anyhow!(
                "failed to discover an application root from {}",
                start.as_ref().display()
            )
        })
    }

    /// Returns the application root.
    pub fn root(&self) -> &Path {
        &self.root
    }

    /// Resolves a path relative to the application root.
    pub fn path(&self, path: impl AsRef<Path>) -> PathBuf {
        self.root.join(path)
    }

    pub(crate) fn load_environment(&self) -> Result<EnvLoad> {
        let selected = env::var_os("ENV_FILE")
            .filter(|path| !path.is_empty())
            .map(PathBuf::from)
            .map(|path| {
                if path.is_absolute() {
                    path
                } else {
                    self.path(path)
                }
            });
        let files = match selected {
            Some(path) => EnvFiles {
                base: Some(path),
                override_file: None,
            },
            None => EnvFiles {
                base: Some(self.path(".env")),
                override_file: Some(self.path(".env.local")),
            },
        };

        files.load().map_err(Into::into)
    }

    fn find_from(start: &Path) -> Option<Self> {
        let start = discovery_root(start);
        let ancestors = start.ancestors().collect::<Vec<_>>();
        let root = ancestors
            .iter()
            .copied()
            .find(|candidate| is_application_root(candidate))
            .or_else(|| {
                ancestors
                    .iter()
                    .copied()
                    .find(|candidate| candidate.join("Cargo.toml").is_file())
            })?;

        Some(Self {
            root: root.to_path_buf(),
        })
    }
}

pub(crate) fn discovery_root(start: &Path) -> &Path {
    match (start.is_file(), start.parent()) {
        (true, Some(parent)) => parent,
        _ => start,
    }
}

fn is_application_root(path: &Path) -> bool {
    path.join("web").is_dir()
        || path.join("services.env").is_file()
        || (path.join("Cargo.toml").is_file() && path.join("app").is_dir())
}

#[cfg(test)]
mod tests {
    use std::fs;

    use tempfile::tempdir;

    use super::*;

    #[test]
    fn discovers_the_project_above_an_app_source_directory() {
        let temporary = tempdir().expect("temporary directory should be created");
        let root = temporary.path().join("example");
        let source = root.join("app/src");
        fs::create_dir_all(root.join("web")).expect("web directory should be created");
        fs::create_dir_all(&source).expect("source directory should be created");
        fs::write(root.join("Cargo.toml"), "[workspace]\n")
            .expect("workspace manifest should be written");
        fs::write(root.join("app/Cargo.toml"), "[package]\nname='example'\n")
            .expect("app manifest should be written");

        let project = Project::discover_from(&source).expect("project should be discovered");

        assert_eq!(project.root(), root);
        assert_eq!(
            project.path("web/build/client"),
            root.join("web/build/client")
        );
    }

    #[test]
    fn discovers_a_packaged_runtime_from_its_web_directory() {
        let temporary = tempdir().expect("temporary directory should be created");
        let root = temporary.path().join("runtime");
        fs::create_dir_all(root.join("web/build/client"))
            .expect("runtime client directory should be created");

        let project = Project::discover_from(root.join("server"))
            .expect("runtime project should be discovered");

        assert_eq!(project.root(), root);
    }
}