shape/

display.rs

use std::fmt::Debug;
use std::fmt::Display;
use std::fmt::Write as _;

use super::helpers::quote_string;
use super::Shape;
use super::ShapeCase;
use crate::helpers::quote_non_identifier;
use crate::name::Name;

const UNIT_OF_INDENTATION: &str = "  ";
const WRAP_COLUMN: usize = 60;

impl Shape {
    /// Returns a string representation of the [`Shape`], including any attached
    /// errors as `(err "message")` suffix.
    ///
    /// Please note: this display format does not imply an input syntax or
    /// parser for the shape language. To create new [`Shape`] elements, use the
    /// various `Shape::*` helper functions.
    #[must_use]
    pub fn pretty_print(&self) -> String {
        self.pretty_print_at_depth(0)
    }

    fn pretty_print_at_depth(&self, depth: usize) -> String {
        let pretty_shape = self.pretty_print_recursive(depth, Shape::pretty_print_at_depth);
        self.append_error_suffix(pretty_shape)
    }

    /// Returns a string representation of the [`Shape`] without any error
    /// annotations. This is the most concise representation.
    #[must_use]
    pub fn pretty_print_without_errors(&self) -> String {
        self.pretty_print_without_errors_at_depth(0)
    }

    fn pretty_print_without_errors_at_depth(&self, depth: usize) -> String {
        self.pretty_print_recursive(depth, Shape::pretty_print_without_errors_at_depth)
    }

    /// Returns a string representation of the [`Shape`] with [`Name`] metadata
    /// included as `<shape> (aka <name1>, <name2>)` and error metadata as
    /// `(err "message")`. Errors are shown first, then names.
    #[must_use]
    pub fn pretty_print_with_names(&self) -> String {
        self.pretty_print_with_names_at_depth(0)
    }

    fn pretty_print_with_names_at_depth(&self, depth: usize) -> String {
        let pretty_shape =
            self.pretty_print_recursive(depth, Shape::pretty_print_with_names_at_depth);

        let mut result = pretty_shape;

        // Append errors first
        result = self.append_error_suffix(result);

        // Then append names
        if self.names().count() > 0 {
            let joined = self
                .names()
                .map(Name::to_string)
                .collect::<Vec<_>>()
                .join(", ");
            // Since the (aka ...) annotation trails multiline array and object
            // shapes, it often fits neatly into the otherwise mostly empty line
            // just after the closing ] or }.
            result = format!("{result} (aka {joined})");
        }

        result
    }

    /// Helper to append `(err "msg1", "msg2")` suffix if shape has its own errors.
    fn append_error_suffix(&self, pretty_shape: String) -> String {
        let error_messages: Vec<_> = self
            .own_errors()
            .map(|e| quote_string(&e.message))
            .collect();
        if error_messages.is_empty() {
            return pretty_shape;
        }
        format!("{pretty_shape} (err {})", error_messages.join(", "))
    }

    #[allow(clippy::too_many_lines)]
    fn pretty_print_recursive(
        &self,
        depth: usize,
        print: impl Fn(&Shape, usize) -> String,
    ) -> String {
        fn print_flexible_wrapper(
            prefix: &str,
            pretty_children: impl IntoIterator<Item = String>,
            suffix: &str,
            depth: usize,
        ) -> String {
            let pretty_children = pretty_children.into_iter().collect::<Vec<_>>();

            // We may want to print the one-line version with some padding
            // inside the prefix/suffix, but we don't want that for the
            // multiline version, so we strip any padding before proceeding.
            let trimmed_prefix = prefix.trim();
            let trimmed_suffix = suffix.trim();

            if pretty_children.is_empty() {
                // If prefix was "{ " and suffix was " }", this prints "{}"
                // without the spaces when pretty_children is empty.
                return format!("{trimmed_prefix}{trimmed_suffix}");
            }

            if let (1, Some(only)) = (pretty_children.len(), pretty_children.first()) {
                // If there is only one child, always print it without
                // leading/trailing line breaks (though `prefix` and `suffix`
                // may include padding spaces, and `only` may print with its own
                // internal line breaks).
                return format!("{prefix}{only}{suffix}");
            }

            if pretty_children
                .iter()
                .all(|pretty| pretty.lines().count() <= 1)
            {
                // If all the children are single-line, and they fit within
                // WRAP_COLUMN columns, we may be able to print them all on one
                // line. Note we are using the untrimmed prefix and suffix,
                // since this is a place where padding spaces may be desired.
                //
                // By corollary, if the shape has any multiline children, the
                // whole shape needs to be printed with line breaks. We never
                // want to print mixed inline/multiline expressions, as in
                //
                //   [a, {
                //     blah: 1
                //   }, b, c, {
                //     whatever: true
                //   }]
                //
                // A human might be able to make this style readable, but
                // machine formatters that allow this hybrid line style tend to
                // produce unreadable monstrosities.
                let one_line = format!("{prefix}{}{suffix}", pretty_children.join(", "));
                if one_line.len() <= WRAP_COLUMN {
                    return one_line;
                }
                // If trying to print all the children on one line would exceed
                // WRAP_COLUMN columns, proceed to multi-line printing...
            }

            let mut result = format!("{trimmed_prefix}\n");
            let child_indent = UNIT_OF_INDENTATION.repeat(depth + 1);

            for pretty in &pretty_children {
                let _ = writeln!(result, "{child_indent}{pretty},");
            }

            let suffix_indent = UNIT_OF_INDENTATION.repeat(depth);
            let _ = write!(result, "{suffix_indent}{trimmed_suffix}");

            result
        }

        match self.case() {
            ShapeCase::Bool(Some(b)) => b.to_string(),
            ShapeCase::Bool(None) => "Bool".to_string(),
            ShapeCase::String(Some(s)) => quote_string(s.as_str()),
            ShapeCase::String(None) => "String".to_string(),
            ShapeCase::Int(Some(i)) => i.to_string(),
            ShapeCase::Int(None) => "Int".to_string(),
            ShapeCase::Float => "Float".to_string(),
            ShapeCase::Null => "null".to_string(), // No typo: JSON null is lowercase.

            ShapeCase::Unknown => "Unknown".to_string(),

            // There may be some argument for using lower-case "none" here,
            // since None is not a reserved/built-in GraphQL type name like
            // Bool, String, Int, and Float are, so someone could define a
            // custom GraphQL None type that would collide with this Shape name.
            ShapeCase::None => "None".to_string(),

            ShapeCase::Array { prefix, tail } => {
                let mut pretty_prefix = prefix
                    .iter()
                    .map(|shape| print(shape, depth + 1))
                    .collect::<Vec<_>>();

                if !tail.is_none() {
                    // Condense the tail indicator so the structural prefix
                    // stays readable. `...` alone marks the common
                    // open-`Unknown` tail; otherwise prepend `...` to the
                    // tail's own pretty-print, which already carries any
                    // errors / names the tail shape has. A prefix-free open
                    // array (formerly the canonical `List<S>` form) thus
                    // renders as `[...S]`, or just `[...]` when S is Unknown.
                    let pretty_tail_inner = print(tail, depth + 1);
                    let rest_marker = if pretty_tail_inner == "Unknown" {
                        "...".to_string()
                    } else {
                        format!("...{pretty_tail_inner}")
                    };
                    pretty_prefix.push(rest_marker);
                }

                print_flexible_wrapper("[", pretty_prefix, "]", depth)
            }

            ShapeCase::Object { fields, rest } => {
                let mut sorted_properties = fields
                    .iter()
                    .map(|(key, value)| (key, print(value, depth + 1)))
                    .collect::<Vec<_>>();
                sorted_properties.sort_by_key(|(key, _)| key.as_str());

                let mut pretty_properties = sorted_properties
                    .into_iter()
                    .map(|(key, value)| format!("{}: {value}", quote_non_identifier(key)))
                    .collect::<Vec<_>>();

                // Named fields get padded braces (`{ a: Int }`); a bare
                // rest-only object prints tight (`{...S}`), so remember
                // whether any real fields were present before we push the
                // rest marker below.
                let has_fields = !pretty_properties.is_empty();

                if !rest.is_none() {
                    // Condense the rest indicator so the structural fields
                    // stay readable. `...` alone marks the common
                    // open-`Unknown` rest; otherwise prepend `...` to the
                    // rest's own pretty-print, which already carries any
                    // errors / names the rest shape has. A field-free open
                    // object (formerly the canonical `Dict<S>` form) thus
                    // renders as `{...S}`, or just `{...}` when S is Unknown.
                    let pretty_rest_inner = print(rest, depth + 1);
                    let rest_marker = if pretty_rest_inner == "Unknown" {
                        "...".to_string()
                    } else {
                        format!("...{pretty_rest_inner}")
                    };
                    pretty_properties.push(rest_marker);
                }

                // When there are named fields and the object prints on a
                // single line, the opening and closing braces carry this
                // extra space of padding. If the object is broken onto
                // multiple lines, `print_flexible_wrapper` trims it. A bare
                // rest-only object (`{...S}`) uses tight braces with no
                // padding.
                let (prefix, suffix) = if has_fields { ("{ ", " }") } else { ("{", "}") };

                print_flexible_wrapper(prefix, pretty_properties, suffix, depth)
            }

            ShapeCase::One(shapes) => {
                let pretty = print_flexible_wrapper(
                    "One<",
                    shapes
                        .iter()
                        .map(|child_shape| print(child_shape, depth + 1)),
                    ">",
                    depth,
                );

                // The empty `One<>` union represents an unsatisfiable shape
                // like TypeScript's `never` type, so that's how we print it.
                if pretty == "One<>" {
                    "Never".to_string()
                } else {
                    pretty
                }
            }

            ShapeCase::All(shapes) => print_flexible_wrapper(
                "All<",
                shapes
                    .iter()
                    .map(|child_shape| print(child_shape, depth + 1)),
                ">",
                depth,
            ),

            ShapeCase::Name(name, _weak) => name.to_string(),
        }
    }
}

impl Debug for Shape {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Shape({})", self.pretty_print_with_names())
    }
}

impl Display for Shape {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.pretty_print())
    }
}