Trait cssparser::AtRuleParser

pub trait AtRuleParser {
    type Prelude;
    type AtRule;
    fn parse_prelude(&mut self,
                     name: &str,
                     input: &mut Parser)
                     -> Result<AtRuleType<Self::Prelude, Self::AtRule>, ()> { ... }
    fn parse_block(&mut self,
                   prelude: Self::Prelude,
                   input: &mut Parser)
                   -> Result<Self::AtRule, ()> { ... }
    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.

Provided Methods

fn parse_prelude(&mut self,
                 name: &str,
                 input: &mut Parser)
                 -> Result<AtRuleType<Self::Prelude, Self::AtRule>, ()>

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(&mut self,
               prelude: Self::Prelude,
               input: &mut Parser)
               -> Result<Self::AtRule, ()>

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