Struct outline::parser::html::HtmlParser

pub struct HtmlParser {
    pub code_tag: String,
    pub language_attribute: String,
    pub name_attribute: String,
    pub block_class: String,
    pub language_class: String,
    pub comments_as_aside: bool,
    pub default_language: Option<String>,
    pub comment_start: String,
    pub interpolation_start: String,
    pub interpolation_end: String,
    pub macro_start: String,
    pub macro_end: String,
}

The config for parsing an HTML document

Fields

code_tag: String

The tag that code is written in when parsing. When printing, the code is always rendered in <pre><code></code></pre>, as is recommended by W3C.

Default: code

language_attribute: String

The attribute to put the language name when rendering the documentation.

Default: data-language

When parsing, the language is always read from the language attribute (this value is ignored).

name_attribute: String

The attribute to add to the code_tag with the code block’s name .

Default: data-name

When parsing, the name is always read from the name attribute (this value is ignored)

block_class: String

A class to add to the <pre> container for any parsed blocks of code when rendering.

language_class: String

The class to add to the <code> block when rendering. The string {} is replaced with the language that this block is in.

Default: language-{}

comments_as_aside: bool

Parsed comments are stripped from the code and written to an <aside></aside> block after the code when printing. If false, the comments are just written back into the code.

Default: false

default_language: Option<String>

The language to set if there was no automatically detected language. Optional

comment_start: String

The sequence to identify a comment which should be omitted from the compiled code, and may be rendered as an <aside> if comments_as_aside is set.

Default: //

interpolation_start: String

The sequence to identify the start of a meta variable interpolation.

Default: @{

interpolation_end: String

The sequence to identify the end of a meta variable interpolation.

Default: }

macro_start: String

The sequence to identify the start of a macro invocation.

Default: ==>

macro_end: String

The sequence to identify the end of a macro invocation.

Default: .

Implementations

impl HtmlParser

pub fn for_language(language: String) -> Self

Creates a default parser with a fallback language

pub fn default_language(&self, language: Option<String>) -> Self

Sets the default language of this parser (or does nothing if None is passed)

Trait Implementations

impl Clone for HtmlParser

fn clone(&self) -> HtmlParser

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HtmlParser

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

Formats the value using the given formatter.

impl Default for HtmlParser

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for HtmlParser

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Parser for HtmlParser

type Error = HtmlError

The type of error for this parser

fn parse<'a>(&self, input: &'a str) -> Result<Document<'a>, Self::Error>

Parses the text part of the document. Should delegate the code section on a line-by-line basis to the built in code parser.

fn parse_name<'a>(
    &self,
    input: &'a str
) -> Result<(String, Vec<&'a str>), ParseError>

Parses a macro name, returning the name and the extracted variables

fn parse_line<'a>(
    &self,
    line_number: usize,
    input: &'a str
) -> Result<Line<'a>, ParseError>

Parses a line as code, returning the parsed Line object

impl ParserConfig for HtmlParser

fn comment_start(&self) -> &str

The token to denote the start of a comment that should be rendered in the documentation. This may be specified as the actual line comment symbol used by the source language to exclude all comments from the transpiled file, or it can be a completely separate symbol to allow for some comments to be left untouched even in the output files.

fn interpolation_start(&self) -> &str

The token to denote the start of a meta-variable interpolation

fn interpolation_end(&self) -> &str

The token to denote the end of a meta-variable interpolation

fn macro_start(&self) -> &str

The token to denote the start of a macro invocation

fn macro_end(&self) -> &str

The token to denote the end of a macro invocation

impl Printer for HtmlParser

fn print_text_block<'a>(&self, block: &TextBlock<'a>) -> String

Prints a text block

fn print_code_block<'a>(&self, block: &CodeBlock<'a>) -> String

Prints a code block

fn print_name(&self, name: String, vars: &[&str]) -> String

Fills a name with its placeholders

fn print_line<'a>(&self, line: &Line<'a>, print_comments: bool) -> String

Prints a line of a code block