cmn-hypha 0.3.0

CMN CLI tool — spawn, grow, release, taste, bond, and absorb spores on the Code Mycelial Network
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

#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
#![allow(dead_code)]

use std::path::PathBuf;
use std::process::Command;

use tempfile::TempDir;

pub(crate) struct TestEnv {
    _temp: TempDir,
    pub(crate) dir: PathBuf,
}

impl TestEnv {
    pub(crate) fn new() -> Self {
        let temp = TempDir::new().expect("Failed to create temp dir");
        let dir = temp.path().to_path_buf();
        Self { _temp: temp, dir }
    }

    pub(crate) fn hypha(&self, args: &[&str]) -> std::process::Output {
        Command::new(env!("CARGO_BIN_EXE_hypha"))
            .args(args)
            .env("CMN_HOME", &self.dir)
            .output()
            .expect("Failed to run hypha")
    }

    pub(crate) fn hypha_in_dir(&self, args: &[&str], cwd: &PathBuf) -> std::process::Output {
        Command::new(env!("CARGO_BIN_EXE_hypha"))
            .args(args)
            .current_dir(cwd)
            .env("CMN_HOME", &self.dir)
            .output()
            .expect("Failed to run hypha")
    }

    pub(crate) fn site_dir(&self, domain: &str) -> PathBuf {
        self.dir.join("mycelium").join(domain)
    }

    #[allow(dead_code)]
    pub(crate) fn hypha_with_env(
        &self,
        args: &[&str],
        env_vars: &[(&str, &str)],
    ) -> std::process::Output {
        let mut cmd = Command::new(env!("CARGO_BIN_EXE_hypha"));
        cmd.args(args).env("CMN_HOME", &self.dir);
        for (key, value) in env_vars {
            cmd.env(key, value);
        }
        cmd.output().expect("Failed to run hypha")
    }
}

pub(crate) fn combined_text(output: &std::process::Output) -> String {
    format!(
        "{}{}",
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    )
}

pub(crate) fn parse_json_last_line(text: &str) -> serde_json::Value {
    let parsed = text
        .lines()
        .rev()
        .find_map(|line| serde_json::from_str::<serde_json::Value>(line).ok());
    assert!(parsed.is_some(), "failed to parse JSONL output: {}", text);
    parsed.expect("checked by assertion above")
}