@prospective.co/procss 0.1.8

package/src/ast/selector/selector_term.rs

@@ -0,0 +1,325 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use nom::branch::alt;
+use nom::bytes::complete::tag;
+use nom::combinator::opt;
+use nom::error::ParseError;
+use nom::multi::many0;
+use nom::sequence::{delimited, preceded, tuple};
+use nom::{IResult, Parser};
+
+use super::attribute::SelectorAttr;
+use crate::ast::token::*;
+use crate::parser::*;
+use crate::render::*;
+
+/// A pseudo-selector component of a `Selector`, including optional argument
+/// selector (parenthesis delimited).
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct Pseudo<'a> {
+    property: &'a str,
+    value: Option<SelectorTerm<'a, Option<&'a str>>>,
+}
+
+impl<'a> ParseCss<'a> for Pseudo<'a> {
+    fn parse<E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Self, E> {
+        let (input, property) = preceded(tuple((tag(":"), opt(tag(":")))), parse_symbol)(input)?;
+        let (input, value) = opt(delimited(tag("("), SelectorTerm::parse, tag(")")))(input)?;
+        Ok((input, Pseudo { property, value }))
+    }
+}
+
+impl<'a> RenderCss for Pseudo<'a> {
+    fn render(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, ":{}", self.property)?;
+        if let Some(x) = self.value.as_ref() {
+            write!(f, "(")?;
+            x.render(f)?;
+            write!(f, ")")?;
+        }
+
+        Ok(())
+    }
+}
+
+enum SelType<'a> {
+    Class(&'a str),
+    Id(&'a str),
+    Pseudo(Pseudo<'a>),
+    Attr(SelectorAttr<'a>),
+}
+
+/// A single compound CSS selector, parameterized over it's `tag` field such
+/// that the uniqu wildcard and self selectors can re-use the same struct and
+/// some tag-irrelevent functions can be shared between impls.
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
+pub struct SelectorTerm<'a, T> {
+    pub id: Option<&'a str>,
+    pub class: Vec<&'a str>,
+    pub tag: T,
+    pub attribute: Vec<SelectorAttr<'a>>,
+    pub pseudo: Vec<Pseudo<'a>>,
+}
+
+impl<'a, T: Clone> SelectorTerm<'a, T> {
+    /// Create a new `Selector`.
+    fn new(tag: T, qualifiers: &[SelType<'a>]) -> SelectorTerm<'a, T> {
+        let mut class = vec![];
+        let mut id: Option<&str> = None;
+        let mut attribute = vec![];
+        let mut pseudo = vec![];
+        for x in qualifiers {
+            match x {
+                SelType::Class(x) => class.push(*x),
+                SelType::Id(x) => id = Some(x),
+                SelType::Pseudo(x) => pseudo.push(x.clone()),
+                SelType::Attr(x) => attribute.push(x.clone()),
+            }
+        }
+
+        SelectorTerm {
+            id,
+            class,
+            tag,
+            attribute,
+            pseudo,
+        }
+    }
+
+    /// Join to another "self" selector.
+    /// TODO Joining two selectors with populated `id` fields will discard the
+    /// parent's `id`.
+    pub fn join(&self, other: &SelectorTerm<'a, ()>) -> Self {
+        let mut class = self.class.clone();
+        let mut attribute = self.attribute.clone();
+        let mut pseudo = self.pseudo.clone();
+        let id = other.id.or(self.id);
+        class.append(&mut other.class.clone());
+        attribute.append(&mut other.attribute.clone());
+        pseudo.append(&mut other.pseudo.clone());
+        SelectorTerm {
+            id,
+            class,
+            tag: self.tag.clone(),
+            attribute,
+            pseudo,
+        }
+    }
+}
+
+impl<'a, T: RenderCss> RenderCss for SelectorTerm<'a, T> {
+    fn render(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.tag.render(f)?;
+        if let Some(tag) = &self.id {
+            write!(f, "#{}", tag)?;
+        }
+
+        for class in &self.class {
+            write!(f, ".{}", class)?;
+        }
+
+        if !self.attribute.is_empty() {
+            write!(f, "[")?;
+            let mut first = true;
+            for SelectorAttr { name, value } in &self.attribute {
+                if !first {
+                    write!(f, ",")?;
+                }
+
+                write!(f, "{}", name)?;
+                if let Some(val) = value {
+                    write!(f, "={}", val)?;
+                }
+
+                first = false;
+            }
+
+            write!(f, "]")?;
+        }
+
+        for class in &self.pseudo {
+            class.render(f)?;
+        }
+
+        Ok(())
+    }
+}
+
+// TODO multiple ids dont work correctly, we discard all but last
+
+impl<'a> ParseCss<'a> for SelectorTerm<'a, Option<&'a str>> {
+    fn parse<E>(input: &'a str) -> IResult<&'a str, Self, E>
+    where
+        E: ParseError<&'a str>,
+    {
+        let (rest, (tag, qualifiers)) = tuple((
+            opt(parse_symbol),
+            many0(alt((
+                preceded(tag("."), parse_symbol.map(SelType::Class)),
+                preceded(tag("#"), parse_symbol.map(SelType::Id)),
+                Pseudo::parse.map(SelType::Pseudo),
+                SelectorAttr::parse.map(SelType::Attr),
+            ))),
+        ))(input)?;
+
+        if tag.is_none() && qualifiers.is_empty() {
+            return nom::IResult::Err(nom::Err::Error(ParseError::from_error_kind(
+                rest,
+                nom::error::ErrorKind::Verify,
+            )));
+        }
+
+        Ok((rest, SelectorTerm::new(tag, &qualifiers)))
+    }
+}
+
+impl<'a> ParseCss<'a> for SelectorTerm<'a, ()> {
+    fn parse<E>(input: &'a str) -> IResult<&'a str, Self, E>
+    where
+        E: ParseError<&'a str>,
+    {
+        let (rest, (_, qualifiers)) = tuple((
+            tag("&"),
+            many0(alt((
+                preceded(tag("."), parse_symbol.map(SelType::Class)),
+                preceded(tag("#"), parse_symbol.map(SelType::Id)),
+                Pseudo::parse.map(SelType::Pseudo),
+                SelectorAttr::parse.map(SelType::Attr),
+            ))),
+        ))(input)?;
+
+        Ok((rest, SelectorTerm::new((), &qualifiers)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::assert_matches::assert_matches;
+
+    use super::*;
+
+    #[test]
+    fn test_tag() {
+        assert_matches!(
+            SelectorTerm::parse::<()>("--column-selector--background"),
+            Ok(("", SelectorTerm {
+                tag: Some("--column-selector--background"),
+                ..
+            }))
+        )
+    }
+
+    #[test]
+    fn test_class() {
+        assert_matches!(
+            SelectorTerm::<Option<&str>>::parse::<()>(".column-selector--background"),
+            Ok(("", SelectorTerm {
+                class,
+                ..
+            })) if class == vec!["column-selector--background"]
+        )
+    }
+
+    #[test]
+    fn test_classes() {
+        assert_matches!(
+            SelectorTerm::<Option<&str>>::parse::<()>(".column-selector.column-selector--background"),
+            Ok(("", SelectorTerm {
+                class,
+                ..
+            })) if class == vec!["column-selector", "column-selector--background"]
+        )
+    }
+
+    #[test]
+    fn test_attribute() {
+        assert_matches!(
+            SelectorTerm::<Option<&str>>::parse::<()>("[name=test]"),
+            Ok(("", SelectorTerm {
+                attribute,
+                ..
+            })) if attribute == vec![SelectorAttr{ name: "name", value: Some("test") }]
+        )
+    }
+
+    #[test]
+    fn test_id() {
+        assert_matches!(
+            SelectorTerm::<Option<&str>>::parse::<()>("#column-selector--background"),
+            Ok(("", SelectorTerm {
+                id: Some("column-selector--background"),
+                ..
+            }))
+        )
+    }
+
+    #[test]
+    fn test_id_class_tag() {
+        assert_matches!(
+            SelectorTerm::<Option<&str>>::parse::<()>("div#column-selector.column-selector.column-selector--background"),
+            Ok(("", SelectorTerm {
+                id: Some("column-selector"),
+                class,
+                tag: Some("div"),
+                ..
+            }))if class == vec!["column-selector", "column-selector--background"]
+        )
+    }
+
+    #[test]
+    fn test_pesudo() {
+        assert_matches!(
+            SelectorTerm::parse::<()>("div:hover"),
+            Ok(("", SelectorTerm {
+                tag: Some("div"),
+                pseudo,
+                ..
+            })) if pseudo.len() == 1 && matches!(pseudo[0], Pseudo{property: "hover", value: None })
+        )
+    }
+
+    #[test]
+    fn test_parameterized_pesudo() {
+        assert_matches!(
+            SelectorTerm::parse::<()>("div:not(.test)"),
+            Ok(("", SelectorTerm {
+                tag: Some("div"),
+                pseudo,
+                ..
+            })) if pseudo.len() == 1 && matches!(pseudo[0], Pseudo{ property: "not", value: Some(_) })
+        )
+    }
+
+    #[test]
+    fn test_parameterized_pesudo_nth_child() {
+        assert_matches!(
+            SelectorTerm::parse::<()>("div:nth-child(2)"),
+            Ok(("", SelectorTerm {
+                tag: Some("div"),
+                pseudo,
+                ..
+            })) if pseudo.len() == 1 && matches!(pseudo[0], Pseudo{ property: "nth-child", value: Some(_) })
+        )
+    }
+
+    #[test]
+    fn test_parameterized_pesudo_renders_correctly() {
+        assert_matches!(
+            SelectorTerm::<Option<&str>>::parse::<nom::error::VerboseError<&str>>(
+                "div:nth-child(2)"
+            )
+            .map(|x| x.as_css_string())
+            .as_deref(),
+            Ok("div:nth-child(2)")
+        )
+    }
+}

package/src/ast/token/mod.rs

@@ -0,0 +1,18 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+mod space;
+mod string;
+mod symbol;
+
+pub(crate) use space::*;
+pub(crate) use string::*;
+pub(crate) use symbol::*;

package/src/ast/token/space.rs

@@ -0,0 +1,157 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use nom::branch::alt;
+use nom::bytes::complete::{is_not, tag};
+use nom::character::complete::{anychar, multispace1};
+use nom::error::ParseError;
+use nom::multi::{many0, many1, many_till};
+use nom::sequence::preceded;
+use nom::IResult;
+
+/// An "extension" trait for [`str`] which is used frequently to determine
+/// whether whitepsace can be removed during [`crate::render::RenderCss`]
+pub trait NeedsWhitespaceStringExt {
+    /// Does this string needs a leading whitespace character?
+    fn needs_pre_ws(&self) -> bool;
+
+    /// Does this string needs a trailing whitespace character?
+    fn needs_post_ws(&self) -> bool;
+}
+
+impl NeedsWhitespaceStringExt for str {
+    fn needs_pre_ws(&self) -> bool {
+        self.chars()
+            .next()
+            .map(|x| x.is_ascii_alphanumeric() || x == '-' || x == '_' || x == '%' || x == '+')
+            .unwrap_or_default()
+    }
+
+    fn needs_post_ws(&self) -> bool {
+        self.chars()
+            .last()
+            .map(|x| x.is_ascii_alphanumeric() || x == '-' || x == '_' || x == '%' || x == '+')
+            .unwrap_or_default()
+    }
+}
+
+/// Render `s` trimming all intermediate whitespace to a single character along
+/// the way.
+pub fn trim_whitespace(s: &str, f: &mut std::fmt::Formatter<'_>) {
+    let mut last_alpha = false;
+    s.split_whitespace().for_each(|w| {
+        if last_alpha && w.needs_pre_ws() {
+            write!(f, " ").unwrap();
+        }
+
+        last_alpha = w.needs_post_ws();
+        write!(f, "{}", w).unwrap();
+    });
+}
+
+// pub fn trim_whitespace(s: &str, f: &mut std::fmt::Formatter<'_>) {
+//     let mut flag = false;
+//     s.split_whitespace().for_each(|w| {
+//         if flag {
+//             write!(f, " ").unwrap();
+//         }
+
+//         flag = flag || !w.is_empty();
+//         write!(f, "{}", w).unwrap();
+//     });
+// }
+
+fn parse_comment<'a, E>(input: &'a str) -> IResult<&'a str, (), E>
+where
+    E: ParseError<&'a str>,
+{
+    ignore(preceded(tag("//"), many0(is_not("\r\n"))))(input)
+}
+
+fn parse_multi_comment<'a, E>(input: &'a str) -> IResult<&'a str, (), E>
+where
+    E: ParseError<&'a str>,
+{
+    ignore(preceded(tag("/*"), many_till(anychar, tag("*/"))))(input)
+}
+
+fn ignore<'a, T, E, F>(mut f: F) -> impl FnMut(&'a str) -> IResult<&'a str, (), E>
+where
+    F: FnMut(&'a str) -> IResult<&'a str, T, E>,
+{
+    move |input| {
+        let (input, _) = f(input)?;
+        Ok((input, ()))
+    }
+}
+
+/// Parses 0 or more whitespace characters, including comments.
+pub fn comment0<'a, E>(input: &'a str) -> IResult<&'a str, (), E>
+where
+    E: ParseError<&'a str>,
+{
+    let (input, _) = many0(alt((
+        ignore(multispace1),
+        parse_comment,
+        parse_multi_comment,
+    )))(input)?;
+    Ok((input, ()))
+}
+
+/// Parses 1 or more whitespace characters, including comments.
+pub fn comment1<'a, E>(input: &'a str) -> IResult<&'_ str, (), E>
+where
+    E: ParseError<&'a str>,
+{
+    ignore(many1(alt((
+        ignore(multispace1),
+        parse_comment,
+        parse_multi_comment,
+    ))))(input)
+}
+
+/// Parses 0 or more whitespace characters, including comments and semicolons.
+pub fn sep0<'a, E>(input: &'a str) -> IResult<&'_ str, (), E>
+where
+    E: ParseError<&'a str>,
+{
+    ignore(many0(alt((comment1, ignore(tag(";"))))))(input)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::assert_matches::assert_matches;
+
+    use super::*;
+
+    #[test]
+    fn test_multiline_comment() {
+        assert_matches!(
+            comment0::<()>(
+                "
+    /* 
+     * test
+     */"
+            ),
+            Ok(("", ()))
+        )
+    }
+
+    #[test]
+    fn test_forward_slash() {
+        assert_matches!(comment0::<()>("// test"), Ok(("", ())))
+    }
+
+    #[test]
+    fn test_semicolons() {
+        assert_matches!(comment0::<()>("/* test; test */"), Ok(("", ())))
+    }
+}

package/src/ast/token/string.rs

@@ -0,0 +1,59 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use nom::branch::alt;
+use nom::bytes::complete::is_not;
+use nom::character::complete::char;
+use nom::combinator::{map, recognize, verify};
+use nom::error::{ErrorKind, ParseError};
+use nom::multi::fold_many0;
+use nom::sequence::{delimited, preceded};
+use nom::IResult;
+
+fn parse_escaped_char(input: &str) -> IResult<&str, &str> {
+    recognize(preceded(char('\\'), is_not(" \r\t\n\"")))(input)
+}
+
+fn parse_literal(input: &str) -> IResult<&str, &str> {
+    let not_quote_slash = is_not("\"\\");
+    verify(not_quote_slash, |s: &str| !s.is_empty())(input)
+}
+
+enum StringFragment {
+    Literal(usize),
+    EscapedChar(usize),
+}
+
+impl StringFragment {
+    fn len(&self) -> usize {
+        match self {
+            StringFragment::Literal(s) => *s,
+            StringFragment::EscapedChar(s) => *s,
+        }
+    }
+}
+
+fn parse_fragment(input: &str) -> IResult<&str, StringFragment> {
+    alt((
+        map(parse_literal, |x| StringFragment::Literal(x.len())),
+        map(parse_escaped_char, |x| StringFragment::EscapedChar(x.len())),
+    ))(input)
+}
+
+pub fn parse_string_literal<'a, E: ParseError<&'a str>>(
+) -> impl Fn(&'a str) -> IResult<&'a str, &'a str, E> {
+    move |input| {
+        let build_string = fold_many0(parse_fragment, || 2, |len, frag| frag.len() + len);
+        let offset = delimited(char('"'), build_string, char('"'));
+        let res = map(offset, |x| &input[..x])(input);
+        res.map_err(|_| nom::Err::Error(E::from_error_kind(input, ErrorKind::AlphaNumeric)))
+    }
+}

package/src/ast/token/symbol.rs

@@ -0,0 +1,32 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use nom::branch::alt;
+use nom::bytes::complete::tag;
+use nom::character::complete::alphanumeric1;
+use nom::combinator::recognize;
+use nom::error::ParseError;
+use nom::multi::many1;
+use nom::IResult;
+
+pub fn parse_symbol<'a, E>(input: &'a str) -> IResult<&'a str, &'a str, E>
+where
+    E: ParseError<&'a str>,
+{
+    let mut parser = recognize(many1(alt((
+        alphanumeric1,
+        tag("-"),
+        tag("_"),
+        tag("*"),
+        tag("%"),
+    ))));
+    parser(input)
+}