Struct term_transcript::svg::SerializedInteraction

#[non_exhaustive]
pub struct SerializedInteraction<'a> {
    pub input: &'a UserInput,
    pub output_html: String,
    pub exit_status: Option<i32>,
    pub failure: bool,
    /* private fields */
}

Available on crate feature svg only.

Serializable version of Interaction.

HTML output

An interaction contains rendered HTML for the output with styles applied to the relevant segments as <span>s. The styles are signalled using classes and inline styles:

• fg0–fg15 classes specify the foreground color being 0th–15th base terminal color. fg0–fg7 are ordinary colors, and fg8–fg15 are intense variations.
• Likewise, bg0–bg15 classes specify the background color as one of the base terminal colors.
• Remaining indexed colors and 24-bit colors have a definite value, and thus are signalled via an inline style (e.g., color: #c0ffee or background: #c0ffee).
• bold, italic, underline, dimmed classes correspond to the corresponding text styles.
• Hard breaks, if they are enabled, are represented by <b class="hard-br"><br/></b>.

The rendered HTML is assumed to be included into a container that preserves whitespace, i.e., has white-space CSS property set to pre. An example of such container is <pre>.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

input: &'a UserInput

User’s input.

output_html: String

Terminal output in the HTML format.

exit_status: Option<i32>

Exit status of the latest executed program, or None if it cannot be determined.

failure: bool

Was execution unsuccessful judging by the ExitStatus?

Trait Implementations

impl<'a> Debug for SerializedInteraction<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Serialize for SerializedInteraction<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.