@prospective.co/procss 0.1.8

package/src/ast/selector/attribute.rs

@@ -0,0 +1,90 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   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::bytes::complete::{is_not, tag};
+use nom::combinator::opt;
+use nom::error::ParseError;
+use nom::sequence::{preceded, tuple};
+use nom::IResult;
+
+use crate::ast::token::*;
+use crate::parser::*;
+
+/// A selector which matches attributes, optionally against their value as well.
+/// TODO doesn't support comma-separated multiple selectors.
+///
+/// # Example
+///
+/// ```css
+/// div[name=test] {}
+/// div[disabled,data-value="red"] {}
+/// ```
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct SelectorAttr<'a> {
+    pub name: &'a str,
+    pub value: Option<&'a str>,
+}
+
+impl<'a> ParseCss<'a> for SelectorAttr<'a> {
+    fn parse<E>(input: &'a str) -> IResult<&'a str, Self, E>
+    where
+        E: ParseError<&'a str>,
+    {
+        let (rest, (_, name, value, _)) = tuple((
+            tag("["),
+            parse_symbol,
+            opt(preceded(tag("="), is_not("]"))),
+            tag("]"),
+        ))(input)?;
+        Ok((rest, SelectorAttr { name, value }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::assert_matches::assert_matches;
+
+    use super::*;
+
+    #[test]
+    fn test_bool() {
+        assert_matches!(
+            SelectorAttr::parse::<()>("[disabled]"),
+            Ok(("", SelectorAttr {
+                name: "disabled",
+                value: None
+            }))
+        )
+    }
+
+    #[test]
+    fn test_value_quotes() {
+        assert_matches!(
+            SelectorAttr::parse::<()>("[data-value=\"red\"]"),
+            Ok(("", SelectorAttr {
+                name: "data-value",
+                value: Some("\"red\"")
+            }))
+        )
+    }
+
+    #[ignore]
+    #[test]
+    fn test_multiple() {
+        assert_matches!(
+            SelectorAttr::parse::<()>("[disabled,data-value=\"red\"]"),
+            Ok(("", SelectorAttr {
+                name: "data-value",
+                value: Some("\"red\"")
+            }))
+        )
+    }
+}

package/src/ast/selector/combinator.rs

@@ -0,0 +1,58 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   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::error::ParseError;
+use nom::sequence::delimited;
+use nom::{IResult, Parser};
+
+use crate::ast::token::*;
+use crate::parser::*;
+use crate::render::*;
+
+/// A selector combinator, used to combine a list of selectors.
+#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
+pub enum Combinator {
+    Null,
+    Sibling,
+    AdjSibling,
+    Desc,
+}
+
+impl RenderCss for Combinator {
+    fn render(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Combinator::Null => write!(f, " "),
+            Combinator::Sibling => write!(f, "~"),
+            Combinator::AdjSibling => write!(f, "+"),
+            Combinator::Desc => write!(f, ">"),
+        }
+    }
+}
+
+impl<'a> ParseCss<'a> for Combinator {
+    fn parse<E>(input: &'a str) -> IResult<&'a str, Self, E>
+    where
+        E: ParseError<&'a str>,
+    {
+        delimited(
+            comment0,
+            alt((
+                tag("+").map(|_| Combinator::AdjSibling),
+                tag(">").map(|_| Combinator::Desc),
+                tag("~").map(|_| Combinator::Sibling),
+                comment0.map(|_| Combinator::Null),
+            )),
+            comment0,
+        )(input)
+    }
+}

package/src/ast/selector/mod.rs

@@ -0,0 +1,115 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   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 attribute;
+mod combinator;
+mod selector_path;
+mod selector_term;
+
+use std::ops::Deref;
+
+use nom::bytes::complete::tag;
+use nom::error::ParseError;
+use nom::multi::many0;
+use nom::sequence::{delimited, preceded};
+use nom::IResult;
+
+pub use self::attribute::SelectorAttr;
+pub use self::combinator::Combinator;
+pub use self::selector_path::SelectorPath;
+pub use self::selector_term::SelectorTerm;
+use super::token::comment0;
+use crate::parser::*;
+use crate::transform::TransformCss;
+use crate::utils::*;
+
+/// A set of selector alternatives separated by `,`, for example `div, span`.
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct Selector<'a>(MinVec<SelectorPath<'a>, 1>);
+
+impl<'a> Default for Selector<'a> {
+    fn default() -> Self {
+        //Selector::parse::<()>("&").unwrap().1
+        Selector(MinVec::new(
+            [SelectorPath::PartialCons(
+                SelectorTerm {
+                    tag: (),
+                    ..SelectorTerm::default()
+                },
+                vec![],
+            )],
+            vec![],
+        ))
+    }
+}
+
+impl<'a> Deref for Selector<'a> {
+    type Target = MinVec<SelectorPath<'a>, 1>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<'a> ParseCss<'a> for Selector<'a> {
+    fn parse<E>(input: &'a str) -> IResult<&'a str, Self, E>
+    where
+        E: ParseError<&'a str>,
+    {
+        let (input, selector) = SelectorPath::parse(input)?;
+        let (input, extra) = many0(preceded(
+            delimited(comment0, tag(","), comment0),
+            SelectorPath::parse,
+        ))(input)?;
+
+        Ok((input, Selector(MinVec::new([selector], extra))))
+    }
+}
+
+impl<'a> TransformCss<SelectorPath<'a>> for Selector<'a> {
+    fn transform_each<F: FnMut(&mut SelectorPath<'a>)>(&mut self, f: &mut F) {
+        for list in self.0.iter_mut() {
+            f(list)
+        }
+    }
+}
+
+impl<'a> Selector<'a> {
+    /// Create a new `SelectorGroup` from an `Iterator`, which will fail if
+    /// there aren't enough elements.  This should asserted by the caller.
+    fn new(mut iter: impl Iterator<Item = SelectorPath<'a>>) -> Option<Self> {
+        Some(Selector(MinVec::new([iter.next()?], iter.collect())))
+    }
+
+    /// `SelectorGroup` uses the underlying `join()` method of the
+    /// `SelectorList`, combined via the product of the two
+    /// `SelectorGroup`'s items.  For example:
+    ///
+    /// ```css
+    /// div, span {
+    ///     .opened, :hover {
+    ///         color: red;
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// becomes
+    ///
+    /// ```css
+    /// div .opened, div :hover, span .opened, span :hover {
+    ///     color: red;
+    /// }
+    /// ```
+    pub fn join(&self, other: &Selector<'a>) -> Selector<'a> {
+        let iter = self.0.iter().flat_map(|x| other.iter().map(|y| x.join(y)));
+        Self::new(iter).unwrap()
+    }
+}

package/src/ast/selector/selector_path.rs

@@ -0,0 +1,230 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   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::error::ParseError;
+use nom::multi::many0;
+use nom::sequence::tuple;
+use nom::IResult;
+
+use super::combinator::*;
+use super::selector_term::*;
+use crate::parser::*;
+use crate::render::*;
+
+/// A linked-list-like data structure representing CSS selector lists, which are
+/// selectors separated by combinators like `>`, `+` or most commonly just
+/// whitespace.  When the first selector in a `SelectorList` is the special
+/// selector `&`, as special case `PartialCons` elimantes `tag` as a field from
+/// this first Selector, preventing the `SelectorList` from being serialized
+/// before being flattened.
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub enum SelectorPath<'a> {
+    Cons(
+        SelectorTerm<'a, Option<&'a str>>,
+        Vec<(Combinator, SelectorTerm<'a, Option<&'a str>>)>,
+    ),
+    PartialCons(
+        SelectorTerm<'a, ()>,
+        Vec<(Combinator, SelectorTerm<'a, Option<&'a str>>)>,
+    ),
+}
+
+use SelectorPath::*;
+
+impl<'a> SelectorPath<'a> {
+    /// Utility method for cons-ing a `Selector` to the head of a
+    /// `SelectorList`.
+    fn cons(
+        &self,
+        selector: &SelectorTerm<'a, ()>,
+        tail: Vec<(Combinator, SelectorTerm<'a, Option<&'a str>>)>,
+    ) -> Self {
+        match self {
+            //Nil => Nil,
+            Cons(x, _) => Cons(x.join(selector), tail),
+            PartialCons(x, _) => PartialCons(x.join(selector), tail),
+        }
+    }
+
+    /// Utility method for accessing the tail of a `SelectorList`.
+    fn tail(&self) -> Vec<(Combinator, SelectorTerm<'a, Option<&'a str>>)> {
+        match self {
+            // Nil => vec![],
+            Cons(_, tail) => tail.clone(),
+            PartialCons(_, tail) => tail.clone(),
+        }
+    }
+
+    /// Append two `SelectorList`, properly merging `&` references along the
+    /// way.  For example:
+    ///
+    /// ```css
+    /// div {               
+    ///     &.enabled {  
+    ///         color: red;
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// becomes
+    ///
+    /// ```css
+    /// div.enabled {
+    ///     color: red;
+    /// }
+    /// ```
+    pub fn join(&self, other: &Self) -> Self {
+        match (&self, other) {
+            (head, Cons(selector, tail)) => {
+                let mut new_tail = head.tail();
+                new_tail.push((Combinator::Null, selector.clone()));
+                new_tail.append(&mut tail.clone());
+                head.cons(&SelectorTerm::default(), new_tail)
+            }
+            (head, PartialCons(selector2, tail2)) => {
+                let mut new_tail = head.tail();
+                match new_tail.pop() {
+                    Some((c, last)) => {
+                        new_tail.push((c, last.join(selector2)));
+                        new_tail.extend(tail2.iter().cloned());
+                        head.cons(&SelectorTerm::default(), new_tail)
+                    }
+                    None => {
+                        new_tail.append(&mut tail2.clone());
+                        head.cons(selector2, new_tail)
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl<'a> RenderCss for SelectorPath<'a> {
+    fn render(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self {
+            Cons(selector, rest) => {
+                selector.render(f)?;
+                rest.render(f)?;
+            }
+            PartialCons(selector, rest) => {
+                write!(f, "&")?;
+                selector.render(f)?;
+                rest.render(f)?;
+            }
+        };
+
+        Ok(())
+    }
+}
+
+impl<'a> ParseCss<'a> for SelectorPath<'a> {
+    fn parse<E>(input: &'a str) -> IResult<&'a str, Self, E>
+    where
+        E: ParseError<&'a str>,
+    {
+        alt((parse_selector_self_list, parse_selector_list))(input)
+    }
+}
+
+/// Parse a selector list without a leading `&` tag, see note on
+/// `parse_selector_self_list`.
+fn parse_selector_list<'a, E>(input: &'a str) -> IResult<&'a str, SelectorPath<'a>, E>
+where
+    E: ParseError<&'a str>,
+{
+    let (rest, x) = SelectorTerm::parse(input)?;
+    let (rest, combinators) = many0(tuple((Combinator::parse, SelectorTerm::parse)))(rest)?;
+    Ok((rest, Cons(x, combinators)))
+}
+
+/// Parse a selector list starting with the `&` special tag via the
+/// `Selector<()>` impl for the `Parser` trait, which is chosen here by the
+/// compiler due to type inference, from the return binding later used as an
+/// argument to the `PartialCons` variant constructor.
+fn parse_selector_self_list<'a, E>(input: &'a str) -> IResult<&'a str, SelectorPath<'a>, E>
+where
+    E: ParseError<&'a str>,
+{
+    let (rest, x) = SelectorTerm::parse(input)?;
+    let (rest, combinators) = many0(tuple((Combinator::parse, SelectorTerm::parse)))(rest)?;
+    Ok((rest, PartialCons(x, combinators)))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::assert_matches::assert_matches;
+
+    use super::*;
+
+    #[test]
+    fn test_null() {
+        assert_matches!(
+            SelectorPath::parse::<()>("div img"),
+            Ok((
+                "",
+                SelectorPath::Cons(
+                    SelectorTerm {
+                        tag: Some("div"),
+                        ..
+                    },
+                    xs
+                )
+            )) if xs.len() == 1 && xs[0].1.tag == Some("img")
+        )
+    }
+
+    #[test]
+    fn test_desc() {
+        assert_matches!(
+            SelectorPath::parse::<()>("div > img"),
+            Ok((
+                "",
+                SelectorPath::Cons(
+                    SelectorTerm {
+                        tag: Some("div"),
+                        ..
+                    },
+                    xs
+                )
+            )) if xs.len() == 1 && xs[0].1.tag == Some("img")
+        )
+    }
+
+    #[test]
+    fn test_self() {
+        assert_matches!(
+            SelectorPath::parse::<()>("& > img"),
+            Ok((
+                "",
+                SelectorPath::PartialCons(
+                    _,
+                    xs
+                )
+            )) if xs.len() == 1 && xs[0].1.tag == Some("img")
+        )
+    }
+
+    #[ignore]
+    #[test]
+    fn test_inner_self() {
+        assert_matches!(
+            SelectorPath::parse::<()>("@nest div & img"),
+            Ok((
+                "",
+                SelectorPath::PartialCons(
+                    _,
+                    xs
+                )
+            )) if xs.len() == 1 && xs[0].1.tag == Some("img")
+        )
+    }
+}