Enum InlineMacro 

#[non_exhaustive]
pub enum InlineMacro<'a> {
    Footnote(Footnote<'a>),
    Icon(Icon<'a>),
    Image(Box<Image<'a>>),
    Keyboard(Keyboard<'a>),
    Button(Button<'a>),
    Menu(Menu<'a>),
    Url(Url<'a>),
    Link(Link<'a>),
    Mailto(Mailto<'a>),
    Autolink(Autolink<'a>),
    CrossReference(CrossReference<'a>),
    Pass(Pass<'a>),
    Stem(Stem<'a>),
    IndexTerm(IndexTerm<'a>),
}

An inline macro - a functional element that produces inline content.

Unlike a struct with name/target/attributes fields, InlineMacro is an enum where each variant represents a specific macro type with its own specialized fields.

Variants Overview

Variant	AsciiDoc Syntax	Description
Link	link:url[text]	Explicit link with optional text
Url	\https://... or link:	URL reference
Mailto	mailto:addr[text]	Email link
Autolink	<\https://...>	Auto-detected URL
CrossReference	<<id>> or xref:id[]	Internal document reference
Image	image:file.png[alt]	Inline image
Icon	icon:name[]	Icon reference (font or image)
Footnote	footnote:[text]	Footnote reference
Keyboard	kbd:[Ctrl+C]	Keyboard shortcut
Button	btn:[OK]	UI button label
Menu	menu:File[Save]	Menu navigation path
Pass	pass:[content]	Passthrough (no processing)
Stem	stem:[formula]	Math notation
IndexTerm	((term)) or (((term)))	Index term (visible or hidden)

Example

fn extract_link_target(node: &InlineNode) -> Option<String> {
    match node {
        InlineNode::Macro(InlineMacro::Link(link)) => Some(link.target.to_string()),
        InlineNode::Macro(InlineMacro::Url(url)) => Some(url.target.to_string()),
        InlineNode::Macro(InlineMacro::CrossReference(xref)) => Some(xref.target.to_string()),
        _ => None,
    }
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Footnote(Footnote<'a>)

Footnote reference: footnote:[content] or footnote:id[content]

Icon(Icon<'a>)

Icon macro: icon:name[attributes]

Image(Box<Image<'a>>)

Inline image: image:path[alt,width,height]

Keyboard(Keyboard<'a>)

Keyboard shortcut: kbd:[Ctrl+C]

Button(Button<'a>)

UI button: btn:[Label]

Menu(Menu<'a>)

Menu path: menu:TopLevel[Item > Subitem]

Url(Url<'a>)

URL with optional text: parsed from link: macro or bare URLs

Link(Link<'a>)

Explicit link macro: link:target[text]

Mailto(Mailto<'a>)

Email link: mailto:address[text]

Autolink(Autolink<'a>)

Auto-detected URL: <\https://example.com>

CrossReference(CrossReference<'a>)

Cross-reference: <<id,text>> or xref:id[text]

Pass(Pass<'a>)

Inline passthrough: pass:[content] - not serialized to ASG

Stem(Stem<'a>)

Inline math: stem:[formula] or latexmath:[...] / asciimath:[...]

IndexTerm(IndexTerm<'a>)

Index term: ((term)) (visible) or (((term))) (hidden)

Implementations

impl InlineMacro<'_>

pub fn location(&self) -> &Location

Returns the source location of this inline macro.

Trait Implementations

impl<'a> Clone for InlineMacro<'a>

fn clone(&self) -> InlineMacro<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for InlineMacro<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for InlineMacro<'a>

fn eq(&self, other: &InlineMacro<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for InlineMacro<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> StructuralPartialEq for InlineMacro<'a>