extern crate cssparser;

fn main() {
    const CSS: &'static str = "html { border: 1px solid; }\nbody { display: block; }";
    let x: Vec<_> = cssparser::RuleListParser::new_for_stylesheet(&mut cssparser::Parser::new(CSS), MyParser).collect();
    println!("{:?}", x);
    // [Ok(("html", "border: 1px solid;")), Ok(("body", "display: block;"))]
}

struct MyParser;

impl cssparser::QualifiedRuleParser for MyParser {
    type Prelude = String;
    type QualifiedRule = (String, String);

    fn parse_prelude(&mut self, input: &mut cssparser::Parser) -> Result<Self::Prelude, ()> {
        input.parse_until_before(cssparser::Delimiter::CurlyBracketBlock, to_str_without_comments)
    }

    fn parse_block(&mut self, prelude: Self::Prelude, input: &mut cssparser::Parser) -> Result<Self::QualifiedRule, ()> {
        to_str_without_comments(input).map(|x| (prelude, x))
    }
}

impl cssparser::AtRuleParser for MyParser {
    type Prelude = ();
    type AtRule = (String, String);
}

fn to_str_without_comments(input: &mut cssparser::Parser) -> Result<String, ()> {
    use cssparser::ToCss;
    use cssparser::Token::*;

    let mut s = String::new();
    let mut insert_whitespace = false;

    while let Ok(t) = input.next_including_whitespace_and_comments() {
        match t {
            WhiteSpace(_) | Comment(_) => insert_whitespace = true,
            t => {
                if insert_whitespace {
                    if s.len() > 0 { s.push(' ') }
                    insert_whitespace = false;
                }
                try!(t.to_css(&mut s).map_err(|_| ()));
            }
        }
    }

    Ok(s)
}