Implement some features missing for literal syntax

Trunk.toml

@@ -12,3 +12,6 @@ ignore = [
   "examples/yew-theme-agent/target/",
   "examples/yew-theme-yewdux/target/",
 ]
+
+[tools]
+wasm_bindgen = "0.2.77"

examples/benchmarks/Cargo.toml

@@ -9,7 +9,7 @@ log = "0.4.14"
 console_log = { version = "0.2.0", features = ["color"] }
 yew = "0.18.0"
 stylist = { path = "../../packages/stylist", features = ["yew_integration"] }
-web-sys = { version = "0.3.53", features = [
+web-sys = { version = "0.3.54", features = [
     "Window",
     "Performance",
 ] }

examples/yew-integration/Cargo.toml

@@ -11,11 +11,11 @@ yew = "0.18.0"
 stylist = { path = "../../packages/stylist", features = ["yew_integration"] }
 
 [dev-dependencies]
-wasm-bindgen-test = "0.3.26"
-wasm-bindgen = "0.2"
+wasm-bindgen-test = "0.3.27"
+wasm-bindgen = "0.2.77"
 
 [dev-dependencies.web-sys]
-version = "0.3.53"
+version = "0.3.54"
 features = [
     "Window",
     "Document",

examples/yew-shadow/Cargo.toml

@@ -12,7 +12,7 @@ stylist = { path = "../../packages/stylist", features = ["yew_integration"] }
 once_cell = "1.8.0"
 
 [dependencies.web-sys]
-version = "0.3.53"
+version = "0.3.54"
 features = [
     "Window",
     "Document",

examples/yew-theme-yewdux/Cargo.toml

@@ -13,11 +13,11 @@ stylist = { path = "../../packages/stylist", features = ["yew_integration"] }
 yewdux = "0.6.2"
 
 [dev-dependencies]
-wasm-bindgen-test = "0.3.26"
-wasm-bindgen = "0.2"
+wasm-bindgen-test = "0.3.27"
+wasm-bindgen = "0.2.77"
 
 [dev-dependencies.web-sys]
-version = "0.3.53"
+version = "0.3.54"
 features = [
     "Window",
     "Document",

packages/stylist-core/Cargo.toml

@@ -22,16 +22,16 @@ resolver = "2"
 
 [dependencies]
 nom = { version = "7.0.0", optional = true }
-thiserror = "1.0.26"
-wasm-bindgen = "0.2.76"
+thiserror = "1.0.29"
+wasm-bindgen = "0.2.77"
 once_cell = "1.8.0"
 
 [dev-dependencies]
 log = "0.4.14"
 env_logger = "0.9.0"
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
-wasm-bindgen-test = "0.3.26"
+wasm-bindgen-test = "0.3.27"
 
 [features]
 parser = ["nom"]

packages/stylist-core/src/ast/block.rs

@@ -1,8 +1,6 @@
 use std::borrow::Cow;
-use std::fmt;
 
-use super::{Selector, StyleAttribute, ToStyleStr};
-use crate::Result;
+use super::{RuleBlockContent, Selector, StyleContext, ToStyleStr};
 
 /// A block is a set of css properties that apply to elements that
 /// match the condition. The CSS standard calls these "Qualified rules".
@@ -20,35 +18,39 @@ pub struct Block {
     /// If the value is set as [`&[]`], it signals to substitute with the classname generated for the
     /// [`Sheet`](super::Sheet) in which this is contained.
     pub condition: Cow<'static, [Selector]>,
-    pub style_attributes: Cow<'static, [StyleAttribute]>,
+    pub content: Cow<'static, [RuleBlockContent]>,
 }
 
-impl ToStyleStr for Block {
-    fn write_style<W: fmt::Write>(&self, w: &mut W, class_name: Option<&str>) -> Result<()> {
-        if !self.condition.is_empty() {
-            for (index, sel) in self.condition.iter().enumerate() {
-                sel.write_style(w, class_name)?;
-                if index < self.condition.len() - 1 {
-                    write!(w, ",")?;
-                }
-                write!(w, " ")?;
-            }
-        } else if let Some(m) = class_name {
-            write!(w, ".{} ", m)?;
-        } else {
-            // Generates global style for dangling block.
-            write!(w, "html ")?;
+impl Block {
+    fn cond_str(&self, ctx: &mut StyleContext<'_>) -> Option<String> {
+        if self.condition.is_empty() {
+            return None;
         }
 
-        writeln!(w, "{{")?;
+        let mut cond = "".to_string();
 
-        for attr in self.style_attributes.iter() {
-            attr.write_style(w, class_name)?;
-            writeln!(w)?;
+        for (index, sel) in self.condition.iter().enumerate() {
+            sel.write_style(&mut cond, ctx);
+            if index < self.condition.len() - 1 {
+                cond.push_str(", ");
+            }
         }
 
-        write!(w, "}}")?;
+        Some(cond)
+    }
+}
+
+impl ToStyleStr for Block {
+    fn write_style(&self, w: &mut String, ctx: &mut StyleContext<'_>) {
+        // TODO: nested block, which is not supported at the moment.
+        let cond_s = self.cond_str(ctx);
+
+        let mut block_ctx = ctx.with_block_condition(cond_s);
+
+        for attr in self.content.iter() {
+            attr.write_style(w, &mut block_ctx);
+        }
 
-        Ok(())
+        block_ctx.finish(w);
     }
 }

packages/stylist-core/src/ast/context.rs

@@ -0,0 +1,174 @@
+use std::borrow::Cow;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+/// A context to faciliate [`ToStyleStr`](super::ToStyleStr).
+#[derive(Debug)]
+pub struct StyleContext<'a> {
+    pub class_name: Option<&'a str>,
+    parent_ctx: Option<&'a StyleContext<'a>>,
+
+    rules: Vec<Cow<'a, str>>,
+    selectors: Vec<Cow<'a, str>>,
+
+    is_open: AtomicBool,
+}
+
+impl<'a> StyleContext<'a> {
+    pub fn new(class_name: Option<&'a str>) -> Self {
+        Self {
+            parent_ctx: None,
+            class_name,
+            rules: Vec::new(),
+            selectors: Vec::new(),
+
+            is_open: AtomicBool::new(false),
+        }
+    }
+
+    fn is_open(&self) -> bool {
+        self.is_open.load(Ordering::Relaxed)
+    }
+
+    fn set_open(&self, value: bool) {
+        self.is_open.store(value, Ordering::Relaxed);
+    }
+
+    // We close until we can find a parent that has nothing differs from current path.
+    fn close_until_common_parent(&self, w: &mut String) {
+        while let Some(m) = self.open_parent() {
+            if self.differ_conditions().is_empty() {
+                break;
+            }
+            m.finish(w);
+        }
+    }
+
+    fn open_parent(&self) -> Option<&StyleContext<'a>> {
+        self.parent_ctx.and_then(|m| {
+            if m.is_open() {
+                Some(m)
+            } else {
+                m.open_parent()
+            }
+        })
+    }
+
+    fn conditions(&self) -> Vec<&str> {
+        self.rules
+            .iter()
+            .chain(self.selectors.iter())
+            .map(|m| m.as_ref())
+            .collect()
+    }
+
+    fn common_conditions(&self) -> Vec<&str> {
+        match self.open_parent() {
+            Some(m) => self
+                .conditions()
+                .into_iter()
+                .zip(m.conditions())
+                .filter_map(|(m1, m2)| if m1 == m2 { Some(m1) } else { None })
+                .collect(),
+            None => Vec::new(),
+        }
+    }
+
+    /// Calculate the layers that current context differs from the parent context
+    fn unique_conditions(&self) -> Vec<&str> {
+        self.conditions()
+            .into_iter()
+            .skip(self.common_conditions().len())
+            .collect()
+    }
+
+    /// Calculate the layers that parent context differs from current context
+    fn differ_conditions(&self) -> Vec<&str> {
+        match self.open_parent() {
+            Some(m) => m
+                .conditions()
+                .into_iter()
+                .skip(self.common_conditions().len())
+                .collect(),
+            None => Vec::new(),
+        }
+    }
+
+    fn write_padding_impl(&self, w: &mut String, no: usize) {
+        for _ in 0..no {
+            w.push_str("    ");
+        }
+    }
+
+    fn write_min_padding(&self, w: &mut String) {
+        self.write_padding_impl(w, self.common_conditions().len())
+    }
+
+    pub fn finish(&self, w: &mut String) {
+        if self.is_open() {
+            for i in (0..self.unique_conditions().len()).rev() {
+                self.write_min_padding(w);
+                self.write_padding_impl(w, i);
+                w.push_str("}\n");
+            }
+        }
+        self.set_open(false);
+    }
+
+    pub fn start(&self, w: &mut String) {
+        if !self.is_open() {
+            self.close_until_common_parent(w);
+
+            for (index, cond) in self.unique_conditions().iter().enumerate() {
+                self.write_min_padding(w);
+                self.write_padding_impl(w, index);
+                w.push_str(cond);
+                w.push_str(" {\n");
+            }
+        }
+        self.set_open(true);
+    }
+
+    pub fn write_padding(&self, w: &mut String) {
+        self.write_padding_impl(w, self.conditions().len());
+    }
+
+    pub fn with_block_condition<S>(&'a self, cond: Option<S>) -> Self
+    where
+        S: Into<Cow<'a, str>>,
+    {
+        let mut selectors = self.selectors.clone();
+
+        if let Some(m) = cond {
+            selectors.push(m.into());
+        } else if self.selectors.is_empty() {
+            selectors.push(
+                self.class_name
+                    .map(|m| format!(".{}", m).into())
+                    .unwrap_or_else(|| "html".into()),
+            )
+        }
+
+        Self {
+            parent_ctx: Some(self),
+            class_name: self.class_name,
+            rules: self.rules.clone(),
+            selectors,
+
+            is_open: AtomicBool::new(false),
+        }
+    }
+
+    pub fn with_rule_condition<S: Into<Cow<'a, str>>>(&'a self, cond: S) -> Self {
+        let mut rules = self.rules.clone();
+        rules.push(cond.into());
+
+        Self {
+            parent_ctx: Some(self),
+            class_name: self.class_name,
+            rules,
+            selectors: self.selectors.clone(),
+
+            is_open: AtomicBool::new(false),
+        }
+    }
+}