balise-cli 0.1.0-alpha.3

The Balise command-line tool, one version per Balise release; run it through `balise`
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

//! The project the CLI works on: found from the current folder upwards.

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

use balise_core::config::load::{self, Files, Mode};
use balise_core::config::{Config, Environment};
use balise_core::error_codes::CLI0010;

use crate::Failure;

/// The project around `dir`: the first folder upwards with `Cargo.toml` and `balise.toml`.
pub fn root(dir: &Path) -> Option<PathBuf> {
    dir.ancestors()
        .find(|dir| dir.join("Cargo.toml").is_file() && dir.join("balise.toml").is_file())
        .map(Path::to_path_buf)
}

/// The project around `dir`, or `CLI0010` for `command`.
pub fn require(dir: &Path, command: &str) -> Result<PathBuf, Failure> {
    root(dir).ok_or_else(|| {
        Failure::problem(
            CLI0010,
            &[("command", command), ("path", &dir.display().to_string())],
            &[],
        )
    })
}

/// The package's name in `Cargo.toml`: the name of the app's binary.
pub fn package_name(root: &Path) -> Option<String> {
    let manifest = std::fs::read_to_string(root.join("Cargo.toml")).ok()?;
    let mut in_package = false;
    for line in manifest.lines().map(str::trim) {
        if line.starts_with('[') {
            in_package = line == "[package]";
        } else if in_package && let Some(value) = line.strip_prefix("name") {
            let value = value.trim_start().strip_prefix('=')?.trim();
            return Some(value.trim_matches('"').to_string());
        }
    }
    None
}

/// Where cargo writes what it builds.
pub fn target_dir(root: &Path) -> PathBuf {
    match std::env::var_os("CARGO_TARGET_DIR") {
        Some(dir) => root.join(dir),
        None => root.join("target"),
    }
}

/// The project's dev configuration, read as the app reads it with these environment
/// variables. Balise's defaults when it cannot be read: the app reports why when it starts.
pub fn config(root: &Path, variables: &[(String, String)]) -> Config {
    let read = |name: &str| -> &'static str {
        let text = std::fs::read_to_string(root.join(name)).unwrap_or_default();
        Box::leak(text.into_boxed_str())
    };
    let files = Files {
        config: read("balise.toml"),
        budgets: read("budgets.toml"),
        crate_name: "app",
        root: "",
    };
    let dev = Environment::Dev;
    match load::load(&files, dev, dev, variables, Mode::Start) {
        Ok(loaded) => loaded.config,
        Err(_) => Config::defaults(dev),
    }
}