Struct RendererInternals 

pub struct RendererInternals;

Unit struct containing renderer functions. Helpful because free functions are annoying.

Implementations

impl RendererInternals

pub fn render_struct_definition( md: &mut String, name: &str, s: &Struct, krate: &Crate, type_renderer: &TypeRenderer<'_>, )

Render a struct definition code block to markdown.

Produces a heading with the struct name and generics, followed by a Rust code block showing the struct definition.

Arguments

• md - Output markdown string
• name - The struct name (may differ from item.name for re-exports)
• s - The struct data from rustdoc
• krate - The crate containing field definitions
• type_renderer - Type renderer for generics and field types

pub fn render_struct_fields<F>( md: &mut String, fields: &[Id], krate: &Crate, type_renderer: &TypeRenderer<'_>, process_docs: F, )

where F: Fn(&Item) -> Option<String>,

Render documented struct fields to markdown.

Produces a “Fields” section with each documented field as a bullet point showing the field name, type, and documentation.

Arguments

• md - Output markdown string
• fields - Field IDs from the struct
• krate - Crate containing field definitions
• type_renderer - Type renderer for field types
• process_docs - Closure to process documentation with intra-doc link resolution

pub fn render_enum_definition( md: &mut String, name: &str, e: &Enum, krate: &Crate, type_renderer: &TypeRenderer<'_>, )

Render an enum definition code block to markdown.

Produces a heading with the enum name and generics, followed by a Rust code block showing the enum definition with all variants.

Arguments

• md - Output markdown string
• name - The enum name (may differ from item.name for re-exports)
• e - The enum data from rustdoc
• krate - The crate containing variant definitions
• type_renderer - Type renderer for generics and variant types

pub fn render_enum_variant( md: &mut String, variant: &Item, krate: &Crate, type_renderer: &TypeRenderer<'_>, )

Render a single enum variant within the definition code block.

Handles all three variant kinds: plain, tuple, and struct variants.

pub fn render_enum_variants_docs<F>( md: &mut String, variants: &[Id], krate: &Crate, process_docs: F, )

where F: Fn(&Item) -> Option<String>,

Render documented enum variants to markdown.

Produces a “Variants” section with each documented variant as a bullet point.

Arguments

• md - Output markdown string
• variants - Variant IDs from the enum
• krate - Crate containing variant definitions
• process_docs - Closure to process documentation with intra-doc link resolution

pub fn render_function_definition( md: &mut String, name: &str, f: &Function, type_renderer: &TypeRenderer<'_>, )

Render a function definition to markdown.

Produces a heading with the function name, followed by a Rust code block showing the full signature with modifiers (const, async, unsafe).

Arguments

• md - Output markdown string
• name - The function name
• f - The function data from rustdoc
• type_renderer - Type renderer for parameter and return types

pub fn render_constant_definition( md: &mut String, name: &str, type_: &Type, const_: &Constant, type_renderer: &TypeRenderer<'_>, )

Render a constant definition to markdown.

Produces a heading with the constant name, followed by a Rust code block showing const NAME: Type = value;.

Arguments

• md - Output markdown string
• name - The constant name
• type_ - The constant’s type
• const_ - The constant data including value
• type_renderer - Type renderer for the type

pub fn render_type_alias_definition( md: &mut String, name: &str, ta: &TypeAlias, type_renderer: &TypeRenderer<'_>, )

Render a type alias definition to markdown.

Produces a heading with the alias name and generics, followed by a Rust code block showing type Name<T> = TargetType;.

Arguments

• md - Output markdown string
• name - The type alias name
• ta - The type alias data from rustdoc
• type_renderer - Type renderer for generics and the aliased type

pub fn render_macro_heading(md: &mut String, name: &str)

Render a macro definition to markdown.

Produces a heading with the macro name and ! suffix. Note: We don’t show macro rules since rustdoc JSON doesn’t provide them.

Arguments

• md - Output markdown string
• name - The macro name

pub fn render_impl_items<F, L>( md: &mut String, impl_block: &Impl, krate: &Crate, type_renderer: &TypeRenderer<'_>, process_docs: &Option<F>, create_type_link: &Option<L>, parent_type_name: Option<&str>, impl_ctx: ImplContext<'_>, full_method_docs: bool, )

where F: Fn(&Item) -> Option<String>, L: Fn(Id) -> Option<String>,

Render the items within an impl block.

This renders all methods, associated constants, and associated types within an impl block as bullet points.

Arguments

• md - Output markdown string
• impl_block - The impl block to render items from
• krate - The crate containing item definitions
• type_renderer - Type renderer for types
• process_docs - Optional closure to process documentation
• create_type_link - Optional closure to create links for types (id -> Option<markdown_link>)
• parent_type_name - Optional type name for generating method anchors
• impl_ctx - Context for anchor generation (inherent vs trait impl)

pub fn append_docs(md: &mut String, docs: Option<String>)

Append processed documentation to markdown.

Helper function to add documentation with consistent formatting.

pub fn render_collapsible_start(summary: &str) -> String

Render the opening of a collapsible <details> block with a summary.

Produces HTML that creates a collapsible section in markdown. Use with [render_collapsible_end] to close the block.

Arguments

• summary - The text to display in the summary line (clickable header)

Example

use cargo_docs_md::generator::render_shared::RendererInternals;

let start = RendererInternals::render_collapsible_start("Derived Traits (9 implementations)");
assert!(start.contains("<details>"));
assert!(start.contains("<summary>Derived Traits (9 implementations)</summary>"));

pub const fn render_collapsible_end() -> &'static str

Render the closing of a collapsible <details> block.

Returns a static string to close a block opened with [render_collapsible_start].

Example

use cargo_docs_md::generator::render_shared::RendererInternals;

assert_eq!(RendererInternals::render_collapsible_end(), "\n</details>\n\n");

pub fn impl_sort_key( impl_block: &Impl, type_renderer: &TypeRenderer<'_>, ) -> String

Generate a sort key for an impl block for deterministic ordering.

Combines trait name, generic params, and for-type to create a unique key.

pub fn render_source_location( span: Option<&Span>, source_path_config: Option<&SourcePathConfig>, ) -> String

Render a source location reference for an item.

Produces a small italicized line showing the source file and line range. If source_path_config is provided, generates a clickable markdown link relative to the current file’s location.

Arguments

• span - The source span from the item
• source_path_config - Optional configuration for path transformation

Returns

A formatted markdown string with the source location, or empty string if span is None.

Example Output (without config)

*Defined in `/home/user/.cargo/registry/src/.../serde-1.0.228/src/lib.rs:10-25`*

Example Output (with config, depth=2)

*Defined in [`serde-1.0.228/src/lib.rs:10-25`](../../.source_xxx/serde-1.0.228/src/lib.rs#L10-L25)*

pub fn render_union_definition( md: &mut String, name: &str, u: &Union, krate: &Crate, type_renderer: &TypeRenderer<'_>, )

Render a union definition code block to markdown.

Produces a heading with the union name and generics, followed by a Rust code block showing the union definition with all fields.

Arguments

• md - Output markdown string
• name - The union name (may differ from item.name for re-exports)
• u - The union data from rustdoc
• krate - The crate containing field definitions
• type_renderer - Type renderer for generics and field types

pub fn render_union_fields<F>( md: &mut String, fields: &[Id], krate: &Crate, type_renderer: &TypeRenderer<'_>, process_docs: F, )

where F: Fn(&Item) -> Option<String>,

Render union fields documentation.

Creates a “Fields” section with each field’s name, type, and documentation. Only renders if at least one field has documentation.

Arguments

• md - Output markdown string
• fields - Field IDs from the union
• krate - The crate containing field definitions
• type_renderer - Type renderer for field types
• process_docs - Callback to process documentation strings

pub fn render_static_definition( md: &mut String, name: &str, s: &Static, type_renderer: &TypeRenderer<'_>, )

Render a static definition code block to markdown.

Produces a heading with the static name, followed by a Rust code block showing the static definition.

Arguments

• md - Output markdown string
• name - The static name (may differ from item.name for re-exports)
• s - The static data from rustdoc
• type_renderer - Type renderer for the static’s type