proto_cli 0.60.0

A multi-language version manager, a unified toolchain.
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

use crate::components::CodeBlock;
use crate::session::{ProtoSession, SessionResult};
use clap::Args;
use iocraft::prelude::*;
use proto_core::{PartialProtoConfig, ProtoConfig, ProtoLock};
use serde::Serialize;
use starbase_console::ui::*;
use starbase_utils::toml;
use std::collections::BTreeMap;
use std::path::PathBuf;
use tracing::instrument;

#[derive(Args, Clone, Debug)]
pub struct DebugConfigArgs {
    #[arg(long, help = "Dump raw configuration objects")]
    raw: bool,
}

#[derive(Serialize)]
struct DebugConfigOutput<'a> {
    config: &'a ProtoConfig,
    files: BTreeMap<&'a PathBuf, &'a PartialProtoConfig>,
    locks: BTreeMap<PathBuf, ProtoLock>,
}

#[instrument(skip(session))]
pub async fn config(session: ProtoSession, args: DebugConfigArgs) -> SessionResult {
    let env = &session.env;
    let manager = env.load_file_manager()?;
    let config = env.load_config()?;

    if args.raw {
        dbg!(manager);
        dbg!(config);

        return Ok(None);
    }

    if session.is_json_format() {
        let mut locks = BTreeMap::default();

        for entry in &manager.entries {
            if entry.locked
                && let Some(lock) = manager.get_lock(&entry.path)?
            {
                locks.insert(lock.path.clone(), (*lock).clone());
            }
        }

        session.console.write_json_for_format(DebugConfigOutput {
            config,
            files: manager
                .get_config_files()
                .into_iter()
                .rev()
                .map(|file| (&file.path, &file.config))
                .collect::<BTreeMap<_, _>>(),
            locks,
        })?;

        return Ok(None);
    }

    for entry in manager.entries.iter().rev() {
        for file in &entry.configs {
            if file.exists {
                let code = toml::format(&file.config, true)?;

                session.console.render(element! {
                    Container {
                        Section(
                            title: file.path.to_string_lossy(),
                            title_color: style_to_color(Style::Path)
                        )
                        CodeBlock(code, format: "toml")
                    }
                })?;
            }
        }

        if entry.locked
            && let Some(lock) = manager.get_lock(&entry.path)?
        {
            let code = toml::format(&*lock, true)?;

            session.console.render(element! {
                Container {
                    Section(
                        title: lock.path.to_string_lossy(),
                        title_color: style_to_color(Style::Path)
                    )
                    CodeBlock(code, format: "toml")
                }
            })?;
        }
    }

    let code = toml::format(config, true)?;

    session.console.render(element! {
        Container {
            Section(
                title: "Final configuration",
                title_color: style_to_color(Style::Shell), // pink brand
            )
            CodeBlock(code, format: "toml")
        }
    })?;

    Ok(None)
}