Enum HtmlError 

pub enum HtmlError {
    RegexCompilationError(Error),
    FrontMatterExtractionError(String),
    HeaderFormattingError(String),
    SelectorParseError(String, String),
    MinificationError(String),
    MarkdownConversion {
        message: String,
        source: Option<Error>,
    },
    Seo {
        kind: SeoErrorKind,
        message: String,
        element: Option<String>,
    },
    Accessibility {
        kind: ErrorKind,
        message: String,
        wcag_guideline: Option<String>,
    },
    MissingHtmlElement(String),
    InvalidStructuredData(String),
    Io(Error),
    InvalidInput(String),
    InvalidFrontMatterFormat(String),
    InputTooLarge(usize),
    InvalidHeaderFormat(String),
    Utf8ConversionError(FromUtf8Error),
    ParsingError(String),
    TemplateRendering {
        message: String,
        source: Box<dyn Error + Send + Sync>,
    },
    ValidationError(String),
    UnexpectedError(String),
}

Enum to represent various errors that can occur during HTML generation, processing, or optimization.

Examples

use html_generator::error::HtmlError;

let err = HtmlError::InvalidInput("empty document".into());
assert!(err.to_string().contains("Invalid input"));

Variants

RegexCompilationError(Error)

Error that occurs when a regular expression fails to compile.

This variant contains the underlying error from the regex crate.

FrontMatterExtractionError(String)

Error indicating failure in extracting front matter from the input content.

This variant is used when there is an issue parsing the front matter of a document. The associated string provides details about the error.

HeaderFormattingError(String)

Error indicating a failure in formatting an HTML header.

This variant is used when the header cannot be formatted correctly. The associated string provides more details.

SelectorParseError(String, String)

Error that occurs when parsing a selector fails.

This variant is used when a CSS or HTML selector cannot be parsed. The first string is the selector, and the second string provides additional context.

MinificationError(String)

Error indicating failure to minify HTML content.

This variant is used when there is an issue during the HTML minification process. The associated string provides details.

MarkdownConversion

Error that occurs during the conversion of Markdown to HTML.

This variant is used when the Markdown conversion process encounters an issue. The associated string provides more information.

Fields

message: String

The error message

source: Option<Error>

The source error, if available

Seo

SEO-related errors.

Fields

kind: SeoErrorKind

The kind of SEO error

message: String

The error message

element: Option<String>

The problematic element, if available

Accessibility

Accessibility-related errors.

Fields

kind: ErrorKind

The kind of accessibility error

message: String

The error message

wcag_guideline: Option<String>

The relevant WCAG guideline, if available

MissingHtmlElement(String)

Error indicating that a required HTML element is missing.

This variant is used when a necessary HTML element (like a title tag) is not found.

InvalidStructuredData(String)

Error that occurs when structured data is invalid.

This variant is used when JSON-LD or other structured data does not meet the expected format or requirements.

Io(Error)

Input/Output errors

This variant is used when an IO operation fails (e.g., reading or writing files).

InvalidInput(String)

Error indicating an invalid input.

This variant is used when the input content is invalid or does not meet the expected criteria.

InvalidFrontMatterFormat(String)

Error indicating an invalid front matter format.

This variant is used when the front matter of a document does not follow the expected format.

InputTooLarge(usize)

Error indicating an input that is too large.

This variant is used when the input content exceeds a certain size limit.

InvalidHeaderFormat(String)

Error indicating an invalid header format.

This variant is used when an HTML header does not conform to the expected format.

Utf8ConversionError(FromUtf8Error)

Error that occurs when converting from UTF-8 fails.

This variant wraps errors that occur when converting a byte sequence to a UTF-8 string.

ParsingError(String)

Error indicating a failure during parsing.

This variant is used for general parsing errors where the specific source of the issue isn’t covered by other variants.

TemplateRendering

Errors that occur during template rendering.

Fields

message: String

The error message

source: Box<dyn Error + Send + Sync>

The source error, if available

ValidationError(String)

Error indicating a validation failure.

This variant is used when a validation step fails, such as schema validation or data integrity checks.

UnexpectedError(String)

A catch-all error for unexpected failures.

This variant is used for errors that do not fit into other categories.

Implementations

impl HtmlError

pub fn invalid_input(message: impl Into<String>, _input: Option<String>) -> Self

Creates a new InvalidInput error.

Examples

use html_generator::error::HtmlError;

let err = HtmlError::invalid_input("empty document", None);
assert!(matches!(err, HtmlError::InvalidInput(_)));

pub fn input_too_large(size: usize) -> Self

Creates a new InputTooLarge error.

Examples

use html_generator::error::HtmlError;

let err = HtmlError::input_too_large(1_048_576);
assert!(matches!(err, HtmlError::InputTooLarge(1_048_576)));

pub fn seo( kind: SeoErrorKind, message: impl Into<String>, element: Option<String>, ) -> Self

Creates a new Seo error.

Examples

use html_generator::error::{HtmlError, SeoErrorKind};

let err = HtmlError::seo(SeoErrorKind::MissingTitle, "no <h1>", None);
assert!(matches!(err, HtmlError::Seo { .. }));

pub fn accessibility( kind: ErrorKind, message: impl Into<String>, wcag_guideline: Option<String>, ) -> Self

Creates a new Accessibility error.

Examples

use html_generator::error::{ErrorKind, HtmlError};

let err = HtmlError::accessibility(
    ErrorKind::MissingAriaAttributes,
    "button without aria-label",
    Some("WCAG 4.1.2".into()),
);
assert!(matches!(err, HtmlError::Accessibility { .. }));

pub fn markdown_conversion( message: impl Into<String>, source: Option<Error>, ) -> Self

Creates a new MarkdownConversion error.

Examples

use html_generator::error::HtmlError;

let err = HtmlError::markdown_conversion("comrak failed", None);
assert!(matches!(err, HtmlError::MarkdownConversion { .. }));

Trait Implementations

impl Debug for HtmlError

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

Formats the value using the given formatter.

impl Display for HtmlError

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

Formats the value using the given formatter.

impl Error for HtmlError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for HtmlError

Converts an accessibility error into the library-wide crate::error::HtmlError so callers can use ? across module boundaries without an explicit .map_err.

The mapping is lossy on purpose: it collapses structured data such as HTML fragments and WCAG conformance levels into the crate::error::HtmlError::Accessibility variant’s message string. If you need the full structured error, match on the originating Error directly before converting.

Examples

use html_generator::accessibility::Error;
use html_generator::error::HtmlError;

let acc_err = Error::InvalidAriaAttribute {
    attribute: "aria-foo".to_string(),
    message: "not a recognised attribute".to_string(),
};
let html_err: HtmlError = acc_err.into();
assert!(matches!(html_err, HtmlError::Accessibility { .. }));

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<Error> for HtmlError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for HtmlError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<FromUtf8Error> for HtmlError

fn from(source: FromUtf8Error) -> Self

Converts to this type from the input type.