Struct Css 

pub struct Css { /* private fields */ }

A reusable CSS parser.

Building one installs the grammar on a new engine, so keep an instance around rather than making a fresh one per document — tests/perf.rs pins that reuse is worth it. parse does this for you for the default options.

use tabnas_css::{Css, Options};

let css = Css::with_options(Options { lowercase_properties: true, ..Options::default() });
let ast = css.parse("A { COLOR: Red }").unwrap();
assert!(ast.to_json().contains(r#""property":"color""#));

Implementations

impl Css

pub fn new() -> Css

A parser with the default options (lowercase_properties: false, position: false).

pub fn with_options(options: Options) -> Css

A parser with the given options.

Examples found in repository

examples/parse.rs (line 44)

fn main() {
    let mut options = Options::default();
    let mut lines = false;
    for arg in std::env::args().skip(1) {
        match arg.as_str() {
            "--position" => options.position = true,
            "--lowercase-properties" => options.lowercase_properties = true,
            "--lines" => lines = true,
            other => {
                eprintln!("parse: unknown argument {other:?}");
                eprintln!("usage: parse [--position] [--lowercase-properties] [--lines]");
                std::process::exit(2);
            }
        }
    }

    let mut input = String::new();
    if std::io::stdin().read_to_string(&mut input).is_err() {
        eprintln!("parse: stdin is not valid UTF-8");
        std::process::exit(2);
    }

    let css = Css::with_options(options);
    if lines {
        // Split on '\n' only: `str::lines` also strips a trailing '\r',
        // which would quietly drop the very characters a carriage-return
        // probe is there to test.
        let mut rows: Vec<&str> = input.split('\n').collect();
        if Some(&"") == rows.last() {
            rows.pop();
        }
        for line in rows {
            println!("{}", report(&css, &decode(line)));
        }
    } else {
        println!("{}", report(&css, &input));
    }
}

pub fn options(&self) -> Options

The options this parser was built with.

pub fn tabnas(&self) -> &Tabnas

The engine this parser runs: jsonic with the plugin installed. Its own parse returns the tree form plugin describes.

pub fn parse(&self, src: &str) -> Result<Value, Error>

Parse a CSS document into its AST.

A zero-length source yields an empty stylesheet, as reworkcss does. Any non-empty source — even one that is only whitespace, or only a comment — also yields a stylesheet node.

Examples found in repository

examples/parse.rs (line 62)

fn report(css: &Css, src: &str) -> String {
    match css.parse(src) {
        Ok(ast) => ast.to_json(),
        Err(err) => format!("ERROR:{}", err.code),
    }
}

Trait Implementations

impl Debug for Css

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

Formats the value using the given formatter.

impl Default for Css

fn default() -> Css

Returns the “default value” for a type.