Function render_plaintext

crates/flowtrace-cli/src/explain.rs:261–358

kubectl-style plaintext rendering.

(root: &str, rest: &[&str], rs: &RootSchema, obj: &SchemaObject)

/// kubectl-style plaintext rendering.
fn render_plaintext(root: &str, rest: &[&str], rs: &RootSchema, obj: &SchemaObject) -> String {
    let mut out = String::new();
    let full_path = if rest.is_empty() {
        root.to_string()
    } else {
        format!("{}.{}", root, rest.join("."))
    };
    out.push_str(&format!("KIND:        {}\n", root));
    out.push_str(&format!("FIELD PATH:  {}\n", full_path));
    if let Some(ty) = describe_type(obj) {
        out.push_str(&format!("TYPE:        {}\n", ty));
    }
    out.push('\n');

    let desc = obj
        .metadata
        .as_ref()
        .and_then(|m| m.description.as_deref())
        .unwrap_or("(no description)");
    out.push_str("DESCRIPTION:\n");
    for line in wrap(desc, 78) {
        out.push_str(&format!("  {}\n", line));
    }
    out.push('\n');

    // For container types (arrays, maps), transparently unwrap to the element
    // type and render its fields/variants. So `reply.evidence` (array of
    // Evidence) renders the Evidence variants; `state.steps`
    // (map<string, StepState>) renders the StepState fields.
    let target = unwrap_container(rs, obj);

    // Fields (if it's an object).
    if let Some(props) = target.object.as_ref() {
        if !props.properties.is_empty() {
            out.push_str("FIELDS:\n");
            let required: std::collections::HashSet<&String> = props.required.iter().collect();
            for (name, schema) in &props.properties {
                if let Schema::Object(po) = schema {
                    let resolved = resolve(rs, po);
                    // Prefer the field's own type label (may carry the ref name
                    // via allOf/anyOf wrapping); fall back to the resolved type.
                    let ty = describe_type(po)
                        .or_else(|| describe_type(resolved))
                        .unwrap_or_else(|| "<unknown>".into());
                    let req_mark = if required.contains(name) { " (required)" } else { "" };
                    out.push_str(&format!("  {} <{}>{}\n", name, ty, req_mark));
                    let pdesc = po
                        .metadata
                        .as_ref()
                        .and_then(|m| m.description.as_deref())
                        .or_else(|| resolved.metadata.as_ref().and_then(|m| m.description.as_deref()))
                        .unwrap_or("");
                    if !pdesc.is_empty() {
                        for line in wrap(pdesc, 76) {
                            out.push_str(&format!("    {}\n", line));
                        }
                    }
                    out.push('\n');