Trait cssparser::AtRuleParser

pub trait AtRuleParser<'i> {
    type Prelude;
    type AtRule;
    type Error: 'i;
    fn parse_prelude<'t>(
        &mut self, 
        name: CompactCowStr<'i>, 
        input: &mut Parser<'i, 't>
    ) -> Result<AtRuleType<Self::Prelude, Self::AtRule>, ParseError<'i, Self::Error>> { ... }
    fn parse_block<'t>(
        &mut self, 
        prelude: Self::Prelude, 
        input: &mut Parser<'i, 't>
    ) -> Result<Self::AtRule, ParseError<'i, Self::Error>> { ... }
    fn rule_without_block(&mut self, prelude: Self::Prelude) -> Self::AtRule { ... }
}

A trait to provide various parsing of at-rules.

For example, there could be different implementations for top-level at-rules (@media, @font-face, …) and for page-margin rules inside @page.

Default implementations that reject all at-rules are provided, so that impl AtRuleParser<(), ()> for ... {} can be used for using DeclarationListParser to parse a declartions list with only qualified rules.

Associated Types

type Prelude

The intermediate representation of an at-rule prelude.

type AtRule

The finished representation of an at-rule.

type Error: 'i

The error type that is included in the ParseError value that can be returned.

Provided Methods

fn parse_prelude<'t>(
    &mut self,
    name: CompactCowStr<'i>,
    input: &mut Parser<'i, 't>
) -> Result<AtRuleType<Self::Prelude, Self::AtRule>, ParseError<'i, Self::Error>>

Parse the prelude of an at-rule with the given name.

Return the representation of the prelude and the type of at-rule, or Err(()) to ignore the entire at-rule as invalid.

See AtRuleType’s documentation for the return value.

The prelude is the part after the at-keyword and before the ; semicolon or { /* ... */ } block.

At-rule name matching should be case-insensitive in the ASCII range. This can be done with std::ascii::Ascii::eq_ignore_ascii_case, or with the match_ignore_ascii_case! macro.

The given input is a "delimited" parser that ends wherever the prelude should end. (Before the next semicolon, the next {, or the end of the current block.)

fn parse_block<'t>(
    &mut self,
    prelude: Self::Prelude,
    input: &mut Parser<'i, 't>
) -> Result<Self::AtRule, ParseError<'i, Self::Error>>

Parse the content of a { /* ... */ } block for the body of the at-rule.

Return the finished representation of the at-rule as returned by RuleListParser::next or DeclarationListParser::next, or Err(()) to ignore the entire at-rule as invalid.

This is only called when parse_prelude returned WithBlock or OptionalBlock, and a block was indeed found following the prelude.

fn rule_without_block(&mut self, prelude: Self::Prelude) -> Self::AtRule

An OptionalBlock prelude was followed by ;.

Convert the prelude into the finished representation of the at-rule as returned by RuleListParser::next or DeclarationListParser::next.

Implementors