flowey_lib_common/
cfg_cargo_common_flags.rs

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
// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Centralized configuration for setting "global" cargo command flags, such as
//! `--locked`, `--verbose`, etc...
//!
//! This node can then be depended on by nodes which do fine-grained ops with
//! cargo (e.g: `cargo build`, `cargo doc`, `cargo test`, etc...) to avoid
//! duping the same flag config all over the place.

use flowey::node::prelude::*;

#[derive(Serialize, Deserialize)]
pub struct Flags {
    pub locked: bool,
    pub verbose: bool,
}

flowey_request! {
    pub enum Request {
        SetLocked(bool),
        SetVerbose(ReadVar<bool>),
        GetFlags(WriteVar<Flags>),
    }
}

new_flow_node!(struct Node);

impl FlowNode for Node {
    type Request = Request;

    fn imports(ctx: &mut ImportCtx<'_>) {
        ctx.import::<crate::install_rust::Node>();
    }

    fn emit(requests: Vec<Self::Request>, ctx: &mut NodeCtx<'_>) -> anyhow::Result<()> {
        let mut set_locked = None;
        let mut set_verbose = None;
        let mut get_flags = Vec::new();

        for req in requests {
            match req {
                Request::SetLocked(v) => same_across_all_reqs("SetLocked", &mut set_locked, v)?,
                Request::SetVerbose(v) => {
                    same_across_all_reqs_backing_var("SetVerbose", &mut set_verbose, v)?
                }
                Request::GetFlags(v) => get_flags.push(v),
            }
        }

        let set_locked =
            set_locked.ok_or(anyhow::anyhow!("Missing essential request: SetLocked"))?;
        let set_verbose =
            set_verbose.ok_or(anyhow::anyhow!("Missing essential request: SetVerbose"))?;
        let get_flags = get_flags;

        // -- end of req processing -- //

        if get_flags.is_empty() {
            return Ok(());
        }

        ctx.emit_minor_rust_step("report common cargo flags", |ctx| {
            let get_flags = get_flags.claim(ctx);
            let set_verbose = set_verbose.claim(ctx);

            move |rt| {
                let set_verbose = rt.read(set_verbose);
                for var in get_flags {
                    rt.write(
                        var,
                        &Flags {
                            locked: set_locked,
                            verbose: set_verbose,
                        },
                    );
                }
            }
        });

        Ok(())
    }
}