p5 0.10.0

A tui client for Pulumi
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

use crate::{
    AppState,
    actions::{StackAction, WorkspaceAction},
    state::{Loadable, OperationOptions, ProgramOperation, StackContext},
};

pub fn parse_command_to_action(
    command: &str,
    state: &AppState,
) -> crate::Result<Option<crate::AppAction>> {
    let command = command.trim().to_lowercase();

    let parts = command.split_whitespace().collect::<Vec<&str>>();
    if parts.is_empty() {
        return Ok(None);
    }
    match parts[0] {
        "workspaces" => Ok(Some(crate::AppAction::PushContext(
            crate::AppContext::WorkspaceList,
        ))),
        "workspace" => {
            if parts.len() < 2 {
                return Ok(Some(crate::AppAction::ToastError(
                    "Usage: workspace <path>".to_string(),
                )));
            }
            let path = parts[1].to_string();

            Ok(Some(crate::AppAction::WorkspaceAction(
                WorkspaceAction::SelectWorkspace(path),
            )))
        }
        "stack" => {
            if parts.len() < 2 {
                return Ok(Some(crate::AppAction::ToastError(
                    "Usage: stack <name>".to_string(),
                )));
            }
            let name = parts[1].to_string();

            if let Loadable::Loaded(workspace) = &state.workspace() {
                Ok(Some(crate::AppAction::WorkspaceAction(
                    WorkspaceAction::SelectStack(workspace.clone(), name),
                )))
            } else {
                Ok(Some(crate::AppAction::ToastError(
                    "No workspace selected".to_string(),
                )))
            }
        }
        "outputs" => Ok(Some(crate::AppAction::PushContext(
            crate::AppContext::Stack(StackContext::Outputs),
        ))),
        "config" => Ok(Some(crate::AppAction::PushContext(
            crate::AppContext::Stack(StackContext::Config),
        ))),
        "resources" => Ok(Some(crate::AppAction::PushContext(
            crate::AppContext::Stack(StackContext::Resources),
        ))),
        "preview" => {
            if let Loadable::Loaded(stack) = &state.stack() {
                Ok(Some(crate::AppAction::StackAction(
                    StackAction::RunProgram(
                        ProgramOperation::Update,
                        stack.clone(),
                        OperationOptions::default().preview_only(),
                    ),
                )))
            } else {
                Ok(Some(crate::AppAction::ToastError(
                    "No stack selected".to_string(),
                )))
            }
        }
        "update" => {
            if let Loadable::Loaded(stack) = &state.stack() {
                Ok(Some(crate::AppAction::StackAction(
                    StackAction::RunProgram(
                        ProgramOperation::Update,
                        stack.clone(),
                        OperationOptions::default(),
                    ),
                )))
            } else {
                Ok(Some(crate::AppAction::ToastError(
                    "No stack selected".to_string(),
                )))
            }
        }
        "refresh" => {
            if let Loadable::Loaded(stack) = &state.stack() {
                Ok(Some(crate::AppAction::StackAction(
                    StackAction::RunProgram(
                        ProgramOperation::Refresh,
                        stack.clone(),
                        OperationOptions::default(),
                    ),
                )))
            } else {
                Ok(Some(crate::AppAction::ToastError(
                    "No stack selected".to_string(),
                )))
            }
        }
        "destroy" => {
            if let Loadable::Loaded(stack) = &state.stack() {
                Ok(Some(crate::AppAction::StackAction(
                    StackAction::RunProgram(
                        ProgramOperation::Destroy,
                        stack.clone(),
                        OperationOptions::default(),
                    ),
                )))
            } else {
                Ok(Some(crate::AppAction::ToastError(
                    "No stack selected".to_string(),
                )))
            }
        }
        command => Ok(Some(crate::AppAction::ToastError(format!(
            "Unknown command: '{}'",
            command
        )))),
    }
}