shlane 0.2.0

A fastlane-like automation tool written in Rust with Rhai scripting support
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

//! `shlane action list` and `shlane action show`.

use crate::actions::Registry;
use crate::error::{Result, ShlaneError};

pub fn list(registry: &Registry) {
    let width = registry
        .iter()
        .map(|action| action.name().chars().count())
        .max()
        .unwrap_or(4);

    println!("{} action(s)\n", registry.len());
    for action in registry.iter() {
        println!("  {:<width$}  {}", action.name(), action.description());
    }
    println!("\nDetails: shlane action show <name>");
}

pub fn show(registry: &Registry, name: &str) -> Result<()> {
    let Some(action) = registry.find(name) else {
        return Err(ShlaneError::Action {
            action: name.to_string(),
            message: format!("no such action (try: {})", registry.names().join(", ")),
        });
    };

    println!("{}  {}\n", action.name(), action.description());

    let schema = action.schema();
    if schema.is_empty() {
        println!("  takes no arguments");
    } else {
        println!("  arguments:");
        for spec in &schema {
            let mut notes = Vec::new();
            if spec.required {
                notes.push("required".to_string());
            }
            if let Some(default) = &spec.default {
                notes.push(format!("default: {default}"));
            }
            if spec.sensitive {
                notes.push("masked in output".to_string());
            }
            let notes = if notes.is_empty() {
                String::new()
            } else {
                format!(" ({})", notes.join(", "))
            };
            println!("    {}{notes}\n      {}", spec.name, spec.description);
        }
    }

    let required: Vec<&crate::actions::ArgSpec> =
        schema.iter().filter(|spec| spec.required).collect();
    println!("\n  steps:\n    - action: {}", action.name());
    if !required.is_empty() {
        println!("      with:");
        for spec in required {
            println!("        {}: ...", spec.name);
        }
    }
    Ok(())
}