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
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

//! `balise routes`: every route, with its handler and limits, as the app serves them.

use std::time::Duration;

use balise_core::json::Value;
use balise_core::text::{format_duration, format_size};

use crate::args::Parsed;
use crate::style::Painter;
use crate::value::{get, number};
use crate::{Command, Context, Failure, Report, app, project};

pub const COMMAND: Command = Command {
    name: "routes",
    summary: "List the routes, with their handler, where it is, and their limits.",
    arguments: "",
    options: &[],
    for_agents: true,
    exclusive: &[],
    run,
};

fn run(_: &Parsed, context: &mut Context) -> Result<Report, Failure> {
    let root = project::require(&context.cwd, "routes")?;
    let answer = app::ask(context, &root, "routes", &["routes"])?;
    let value = answer.json("routes")?;
    let p = Painter(context.color);
    let routes = match get(&value, "routes") {
        Some(Value::Array(routes)) => routes.as_slice(),
        _ => &[],
    };
    let rows: Vec<[String; 4]> = routes
        .iter()
        .map(|route| {
            let text = |key| get(route, key).and_then(as_text).unwrap_or_default();
            [
                text("method").to_string(),
                text("path").to_string(),
                text("handler").to_string(),
                format!("{}  {}", text("location"), limits(route)),
            ]
        })
        .collect();
    let width = |i: usize| {
        rows.iter()
            .map(|row| row[i].chars().count())
            .max()
            .unwrap_or(0)
    };
    let (w0, w1, w2) = (width(0), width(1), width(2));
    let mut lines: Vec<String> = rows
        .iter()
        .map(|[method, path, handler, rest]| {
            format!(
                "{}  {}  {handler:<w2$}  {}",
                p.bold(&format!("{method:<w0$}")),
                p.command(&format!("{path:<w1$}")),
                p.dim(rest)
            )
        })
        .collect();
    let base = get(&value, "base").and_then(as_text).unwrap_or_default();
    lines.push(String::new());
    lines.push(match routes.len() {
        0 => "No routes: a route is an `async fn` with `#[get(\"/path\")]`, in a module declared in `main.rs`.".to_string(),
        1 => format!("1 route under {base}"),
        n => format!("{n} routes under {base}"),
    });
    if let Some(note) = answer.note {
        lines.push(format!("note: {note}"));
    }
    Ok(Report {
        text: lines.join("\n").trim_start().to_string(),
        data: value,
        exit: 0,
    })
}

/// The limits of a route, on one line: body size, timeout, page sizes.
pub fn limits(route: &Value) -> String {
    let mut parts = vec![
        format!("body {}", format_size(number(route, "body_size"))),
        format_duration(Duration::from_millis(number(route, "timeout_ms") as u64)),
    ];
    if let Some(page) = get(route, "page").filter(|page| **page != Value::Null) {
        parts.push(format!(
            "page {}/{}",
            number(page, "default"),
            number(page, "max")
        ));
    }
    parts.join(" ยท ")
}

pub fn as_text(value: &Value) -> Option<&str> {
    match value {
        Value::String(text) => Some(text),
        _ => None,
    }
}