cssparser 0.7.2

Rust implementation of CSS Syntax Level 3

Crate cssparser [] [src]

Implementation of CSS Syntax Module Level 3 for Rust.

Input

Everything is based on Parser objects, which borrow a &str input. If you have bytes (from a file, the network, or something), see the decode_stylesheet_bytes function.

Conventions for parsing functions

  • Take (at least) a input: &mut cssparser::Parser parameter
  • Return Result<_, ()>
  • When returning Ok(_), the function must have consume exactly the amount of input that represents the parsed value.
  • When returning Err(()), any amount of input may have been consumed.

As a consequence, when calling another parsing function, either:

  • Any Err(()) return value must be propagated. This happens by definition for tail calls, and can otherwise be done with the try! macro.
  • Or the call must be wrapped in a Parser::try call. try takes a closure that takes a Parser and returns a Result, calls it once, and returns itself that same result. If the result is Err, it restores the position inside the input to the one saved before calling the closure.

Examples:

// 'none' | <image>
fn parse_background_image(context: &ParserContext, input: &mut Parser)
                                    -> Result<Option<Image>, ()> {
    if input.try(|input| input.expect_ident_matching("none")).is_ok() {
        Ok(None)
    } else {
        Image::parse(context, input).map(Some)  // tail call
    }
}
// [ <length> | <percentage> ] [ <length> | <percentage> ]?
fn parse_border_spacing(_context: &ParserContext, input: &mut Parser)
                          -> Result<(LengthOrPercentage, LengthOrPercentage), ()> {
    let first = try!(LengthOrPercentage::parse);
    let second = input.try(LengthOrPercentage::parse).unwrap_or(first);
    (first, second)
}

Modules

Delimiter

Delimiters constants.

Macros

match_ignore_ascii_case

This macro is equivalent to a match expression on an &str value, but matching is case-insensitive in the ASCII range.

Structs

CssStringWriter

A fmt::Write adapter that escapes text for writing as a double-quoted CSS string. Quotes are not included.

DeclarationListParser

Provides an iterator for declaration list parsing.

Delimiters

A set of characters, to be used with the Parser::parse_until* methods.

NumericValue

The numeric value of Number and Dimension tokens.

Parser

A CSS parser that borrows its &str input, yields Tokens, and keeps track of nested blocks and functions.

PercentageValue

The numeric value of Percentage tokens.

RGBA

A color with red, green, blue, and alpha components.

RuleListParser

Provides an iterator for rule list parsing.

SourceLocation

The line and column number for a given position within the input.

SourcePosition

A capture of the internal state of a Parser (including the position within the input), obtained from the Parser::position method.

TokenSerializationType

A category of token. See the needs_separator_when_before method.

Enums

AtRuleType

The return value for AtRuleParser::parse_prelude. Indicates whether the at-rule is expected to have a { /* ... */ } block or end with a ; semicolon.

Color

A value.

Token

One of the pieces the CSS input is broken into.

Traits

AtRuleParser

A trait to provide various parsing of at-rules.

DeclarationParser

A trait to provide various parsing of declaration values.

QualifiedRuleParser

A trait to provide various parsing of qualified rules.

ToCss

Trait for things the can serialize themselves in CSS syntax.

Functions

decode_stylesheet_bytes

Determine the character encoding of a CSS stylesheet and decode it.

parse_color_keyword

Return the named color with the given name.

parse_important

Parse !important.

parse_nth

Parse the An+B notation, as found in the :nth-child() selector. The input is typically the arguments of a function, in which case the caller needs to check if the arguments’ parser is exhausted. Return Ok((A, B)), or Err(()) for a syntax error.

parse_one_declaration

Parse a single declaration, such as an ( /* ... */ ) parenthesis in an @supports prelude.

parse_one_rule

Parse a single rule, such as for CSSOM’s CSSStyleSheet.insertRule.

serialize_identifier

Write a CSS identifier, escaping characters as necessary.

serialize_string

Write a double-quoted CSS string token, escaping content as necessary.