Enum Error

#[non_exhaustive]
pub enum Error {
    ContentTooLarge {
        size: usize,
        max: usize,
    },
    NestingTooDeep {
        depth: usize,
        max: usize,
    },
    YamlParseError {
        source: Arc<Error>,
    },
    TomlParseError(Error),
    JsonParseError(Arc<Error>),
    InvalidFormat,
    ConversionError(String),
    ParseError(String),
    UnsupportedFormat {
        line: usize,
    },
    NoFrontmatterFound,
    InvalidJson,
    InvalidUrl(String),
    InvalidToml,
    InvalidYaml,
    InvalidLanguage(String),
    JsonDepthLimitExceeded,
    ExtractionError(String),
    SerdeError {
        source: Arc<Error>,
    },
    ValidationError(String),
    Other(String),
}

Represents errors that can occur during front matter operations.

This enumeration uses the thiserror crate to provide structured error messages, improving the ease of debugging and handling errors encountered in front matter processing.

Each variant represents a specific type of error that may occur during front matter operations, with appropriate context and error details.

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.

ContentTooLarge

Content exceeds the maximum allowed size.

This error occurs when the content size is larger than the configured maximum limit.

Fields

• size - The actual size of the content
• max - The maximum allowed size

Fields

size: usize

The actual size of the content

max: usize

The maximum allowed size

NestingTooDeep

Nesting depth exceeds the maximum allowed.

This error occurs when the structure’s nesting depth is greater than the configured maximum depth.

Fields

depth: usize

The actual nesting depth

max: usize

The maximum allowed depth

YamlParseError

Error occurred whilst parsing YAML content.

This error occurs when the YAML parser encounters invalid syntax or structure.

Fields

source: Arc<Error>

The original error from the YAML parser

TomlParseError(Error)

Error occurred whilst parsing TOML content.

This error occurs when the TOML parser encounters invalid syntax or structure.

JsonParseError(Arc<Error>)

Error occurred whilst parsing JSON content.

This error occurs when the JSON parser encounters invalid syntax or structure.

InvalidFormat

The front matter format is invalid or unsupported.

This error occurs when the front matter format cannot be determined or is not supported by the library.

ConversionError(String)

Error occurred during conversion between formats.

This error occurs when converting front matter from one format to another fails.

ParseError(String)

Generic error during parsing.

This error occurs when a parsing operation fails with a generic error.

UnsupportedFormat

Unsupported or unknown front matter format was detected.

This error occurs when an unsupported front matter format is encountered at a specific line.

Fields

line: usize

The line number where the unsupported format was encountered

NoFrontmatterFound

No front matter content was found.

This error occurs when attempting to extract front matter from content that does not contain any front matter section.

InvalidJson

Invalid JSON front matter.

This error occurs when the JSON front matter is malformed or invalid.

InvalidUrl(String)

Invalid URL format.

This error occurs when an invalid URL is encountered in the front matter.

InvalidToml

Invalid TOML front matter.

This error occurs when the TOML front matter is malformed or invalid.

InvalidYaml

Invalid YAML front matter.

This error occurs when the YAML front matter is malformed or invalid.

InvalidLanguage(String)

Invalid language code.

This error occurs when an invalid language code is encountered in the front matter.

JsonDepthLimitExceeded

JSON front matter exceeds maximum nesting depth.

This error occurs when the JSON front matter structure exceeds the maximum allowed nesting depth.

ExtractionError(String)

Error during front matter extraction.

This error occurs when there is a problem extracting front matter from the content.

SerdeError

Serialization or deserialization error.

This error occurs when there is a problem serializing or deserializing content.

Fields

source: Arc<Error>

The original error from the serde library

ValidationError(String)

Input validation error.

This error occurs when the input fails validation checks.

Other(String)

Generic error with a custom message.

This error occurs when a generic error is encountered with a custom message.

Implementations

impl Error

pub const fn category(&self) -> Category

Returns the category of the error.

Returns

Returns the Category that best describes this error.

pub fn generic_parse_error(message: &str) -> Self

Creates a generic parse error with a custom message.

Arguments

• message - A string slice containing the error message.

Examples

use frontmatter_gen::error::Error;

let error = Error::generic_parse_error("Invalid syntax");
assert!(matches!(error, Error::ParseError(_)));

pub const fn unsupported_format(line: usize) -> Self

Creates an unsupported format error for a specific line.

Arguments

• line - The line number where the unsupported format was detected.

Examples

use frontmatter_gen::error::Error;

let error = Error::unsupported_format(42);
assert!(matches!(error, Error::UnsupportedFormat { line: 42 }));

pub fn validation_error(message: &str) -> Self

Creates a validation error with a custom message.

Arguments

• message - A string slice containing the validation error message.

Examples

use frontmatter_gen::error::Error;

let error = Error::validation_error("Invalid character in title");
assert!(matches!(error, Error::ValidationError(_)));

pub fn with_context(self, context: &Context) -> Self

Adds context to an error.

Arguments

• context - Additional context information about the error.

Examples

use frontmatter_gen::error::{Error, Context};

let context = Context {
    line: Some(42),
    column: Some(10),
    snippet: Some("invalid content".to_string()),
};

let error = Error::ParseError("Invalid syntax".to_string())
    .with_context(&context);

Trait Implementations

impl Clone for Error

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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<EngineError> for Error

Converts an EngineError into an Error.

This allows engine errors to be converted into front matter errors when needed, preserving the error context and message.

Examples

use frontmatter_gen::error::{EngineError, Error};
use std::io;

let engine_error = EngineError::ContentError("content processing failed".to_string());
let frontmatter_error: Error = engine_error.into();
assert!(matches!(frontmatter_error, Error::ParseError(_)));

fn from(err: EngineError) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

Converts an IO error (std::io::Error) into a front matter Error.

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<Error> for String

Converts a front matter Error into a string.

fn from(err: Error) -> Self

Converts to this type from the input type.