Proc macro for css

examples/benchmarks/src/benchmarks.rs

@@ -1,17 +1,37 @@
-use stylist::ast::Sheet;
-use stylist::Style;
+use stylist::{
+    ast::{sheet, Sheet},
+    Style,
+};
 
 use crate::utils::now;
 
 pub fn bench_parse_simple() -> f64 {
     let start_time = now();
-    for _ in 0..1_000_000 {
+    for _ in 0..10_000_000 {
         let _sheet: Sheet = "color:red;".parse().expect("Failed to parse stylesheet.");
     }
 
     now() - start_time
 }
 
+pub fn bench_macro_simple() -> f64 {
+    let start_time = now();
+    for _ in 0..10_000_000 {
+        let _sheet: Sheet = sheet!("color:red;");
+    }
+
+    now() - start_time
+}
+
+pub fn bench_macro_inline_simple() -> f64 {
+    let start_time = now();
+    for _ in 0..10_000_000 {
+        let _sheet: Sheet = sheet!(color:red;);
+    }
+
+    now() - start_time
+}
+
 pub fn bench_parse_simple_no_cache() -> f64 {
     let start_time = now();
     for i in 0..100_000 {
@@ -25,8 +45,42 @@ pub fn bench_parse_simple_no_cache() -> f64 {
 
 pub fn bench_parse_complex() -> f64 {
     let start_time = now();
-    for _ in 0..100_000 {
-        let _sheet: Sheet = r#"
+    for i in 0..1_000_000 {
+        let _sheet: Sheet = format!(
+            r#"
+            color:red;
+
+            .class-name-a {{
+                background: red;
+
+                display: flex;
+                flex-direction: column;
+                justify-content: center;
+                align-items: center;
+            }}
+
+            @media screen and (max-width: {i}px;) {{
+                font-size: 0.9rem;
+
+                .class-name-b {{
+                    flex-direction: row;
+                }}
+            }}
+        "#,
+            i = i / 1000
+        )
+        .parse()
+        .expect("Failed to parse stylesheet.");
+    }
+
+    now() - start_time
+}
+
+pub fn bench_macro_complex() -> f64 {
+    let start_time = now();
+    for i in 0..1_000_000 {
+        let _sheet: Sheet = sheet!(
+            r#"
             color:red;
 
             .class-name-a {
@@ -38,16 +92,44 @@ pub fn bench_parse_complex() -> f64 {
                 align-items: center;
             }
 
-            @media screen and (max-width: 500px;) {
+            @media screen and (max-width: ${i}px;) {
                 font-size: 0.9rem;
 
                 .class-name-b {
                     flex-direction: row;
                 }
             }
-        "#
-        .parse()
-        .expect("Failed to parse stylesheet.");
+        "#,
+            i = (i / 1000).to_string()
+        );
+    }
+
+    now() - start_time
+}
+
+pub fn bench_macro_inline_complex() -> f64 {
+    let start_time = now();
+    for i in 0..1_000_000 {
+        let _sheet: Sheet = sheet!(
+            color: red;
+
+            .class-name-a {
+                background: red;
+
+                display: flex;
+                flex-direction: column;
+                justify-content: center;
+                align-items: center;
+            }
+
+            @media screen and (max-width: ${i / 1000}px;) {
+                font-size: 0.9rem;
+
+                .class-name-b {
+                    flex-direction: row;
+                }
+            }
+        );
     }
 
     now() - start_time

examples/benchmarks/src/main.rs

@@ -1,6 +1,5 @@
 use gloo::timers::callback::Timeout;
-use stylist::yew::Global;
-use stylist::{StyleSource, YieldStyle};
+use stylist::{yew::Global, StyleSource, YieldStyle};
 use yew::prelude::*;
 
 use log::Level;
@@ -22,8 +21,12 @@ static GLOBAL_STYLE: &str = r#"
 
 pub enum BenchMsg {
     ParseSimpleFinish(f64),
+    MacroSimpleFinish(f64),
+    MacroInlineSimpleFinish(f64),
     ParseSimpleNoCacheFinish(f64),
     ParseComplexFinish(f64),
+    MacroComplexFinish(f64),
+    MacroInlineComplexFinish(f64),
     ParseComplexNoCacheFinish(f64),
     CachedLookupFinish(f64),
     CachedLookupBigSheetFinish(f64),
@@ -35,8 +38,12 @@ pub struct Benchmarks {
     finished: bool,
 
     parse_simple: Option<f64>,
+    macro_simple: Option<f64>,
+    macro_inline_simple: Option<f64>,
     parse_simple_no_cache: Option<f64>,
     parse_complex: Option<f64>,
+    macro_complex: Option<f64>,
+    macro_inline_complex: Option<f64>,
     parse_complex_no_cache: Option<f64>,
 
     cached_lookup: Option<f64>,
@@ -54,8 +61,12 @@ impl Component for Benchmarks {
             link,
             finished: false,
             parse_simple: None,
+            macro_simple: None,
+            macro_inline_simple: None,
             parse_simple_no_cache: None,
             parse_complex: None,
+            macro_complex: None,
+            macro_inline_complex: None,
             parse_complex_no_cache: None,
             cached_lookup: None,
             cached_lookup_big_sheet: None,
@@ -76,6 +87,22 @@ impl Component for Benchmarks {
         match msg {
             BenchMsg::ParseSimpleFinish(m) => {
                 self.parse_simple = Some(m);
+                let cb = self
+                    .link
+                    .callback(|_| BenchMsg::MacroSimpleFinish(benchmarks::bench_macro_simple()));
+
+                Timeout::new(100, move || cb.emit(())).forget();
+            }
+            BenchMsg::MacroSimpleFinish(m) => {
+                self.macro_simple = Some(m);
+                let cb = self.link.callback(|_| {
+                    BenchMsg::MacroInlineSimpleFinish(benchmarks::bench_macro_inline_simple())
+                });
+
+                Timeout::new(100, move || cb.emit(())).forget();
+            }
+            BenchMsg::MacroInlineSimpleFinish(m) => {
+                self.macro_inline_simple = Some(m);
                 let cb = self.link.callback(|_| {
                     BenchMsg::ParseSimpleNoCacheFinish(benchmarks::bench_parse_simple_no_cache())
                 });
@@ -94,6 +121,24 @@ impl Component for Benchmarks {
             BenchMsg::ParseComplexFinish(m) => {
                 self.parse_complex = Some(m);
 
+                let cb = self
+                    .link
+                    .callback(|_| BenchMsg::MacroComplexFinish(benchmarks::bench_macro_complex()));
+
+                Timeout::new(100, move || cb.emit(())).forget();
+            }
+            BenchMsg::MacroComplexFinish(m) => {
+                self.macro_complex = Some(m);
+
+                let cb = self.link.callback(|_| {
+                    BenchMsg::MacroInlineComplexFinish(benchmarks::bench_macro_inline_complex())
+                });
+
+                Timeout::new(100, move || cb.emit(())).forget();
+            }
+            BenchMsg::MacroInlineComplexFinish(m) => {
+                self.macro_inline_complex = Some(m);
+
                 let cb = self.link.callback(|_| {
                     BenchMsg::ParseComplexNoCacheFinish(benchmarks::bench_parse_complex_no_cache())
                 });
@@ -165,17 +210,33 @@ impl Component for Benchmarks {
                     </thead>
                     <tbody>
                         <tr>
-                            <th>{"Parse Simple (1,000,000 iterations): "}</th>
+                            <th>{"Parse Simple (10,000,000 iterations): "}</th>
                             <th>{self.parse_simple.map(|m| {format!("{:.0}ms", m)}).unwrap_or_else(|| "".to_string())}</th>
                         </tr>
+                        <tr>
+                            <th>{"Macro Simple (10,000,000 iterations): "}</th>
+                            <th>{self.macro_simple.map(|m| {format!("{:.0}ms", m)}).unwrap_or_else(|| "".to_string())}</th>
+                        </tr>
+                        <tr>
+                            <th>{"Macro Inline Simple (10,000,000 iterations): "}</th>
+                            <th>{self.macro_inline_simple.map(|m| {format!("{:.0}ms", m)}).unwrap_or_else(|| "".to_string())}</th>
+                        </tr>
                         <tr>
                             <th>{"Parse Simple, No Cache (100,000 iterations): "}</th>
                             <th>{self.parse_simple_no_cache.map(|m| {format!("{:.0}ms", m)}).unwrap_or_else(|| "".to_string())}</th>
                         </tr>
                         <tr>
-                            <th>{"Parse Complex (100,000 iterations): "}</th>
+                            <th>{"Parse Complex (1,000,000 iterations): "}</th>
                             <th>{self.parse_complex.map(|m| {format!("{:.0}ms", m)}).unwrap_or_else(|| "".to_string())}</th>
                         </tr>
+                        <tr>
+                            <th>{"Macro Complex (1,000,000 iterations): "}</th>
+                            <th>{self.macro_complex.map(|m| {format!("{:.0}ms", m)}).unwrap_or_else(|| "".to_string())}</th>
+                        </tr>
+                        <tr>
+                            <th>{"Macro Inline Complex (1,000,000 iterations): "}</th>
+                            <th>{self.macro_inline_complex.map(|m| {format!("{:.0}ms", m)}).unwrap_or_else(|| "".to_string())}</th>
+                        </tr>
                         <tr>
                             <th>{"Parse Complex, No Cache (100,000 iterations): "}</th>
                             <th>{self.parse_complex_no_cache.map(|m| {format!("{:.0}ms", m)}).unwrap_or_else(|| "".to_string())}</th>

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

@@ -39,7 +39,7 @@ mod tests {
                 .into(),
             }),
             ScopeContent::Block(Block {
-                condition: vec![".inner".into()].into(),
+                condition: vec![vec![".inner".into()].into()].into(),
                 style_attributes: vec![StyleAttribute {
                     key: "background-color".into(),
                     value: vec!["red".into()].into(),
@@ -96,7 +96,7 @@ width: 200px;
                     .into(),
                 }),
                 RuleContent::Block(Block {
-                    condition: vec![".inner".into()].into(),
+                    condition: vec![vec![".inner".into()].into()].into(),
                     style_attributes: vec![StyleAttribute {
                         key: "background-color".into(),
                         value: vec!["red".into()].into(),

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

@@ -1,5 +1,4 @@
-use std::borrow::Cow;
-use std::fmt;
+use std::{borrow::Cow, fmt};
 
 use super::{StringFragment, ToStyleStr};
 use crate::Result;
@@ -57,10 +56,10 @@ impl ToStyleStr for Selector {
     }
 }
 
-impl<T: Into<Cow<'static, str>>> From<T> for Selector {
+impl<T: Into<Cow<'static, [StringFragment]>>> From<T> for Selector {
     fn from(s: T) -> Self {
         Self {
-            fragments: vec![s.into().into()].into(),
+            fragments: s.into(),
         }
     }
 }
@@ -71,7 +70,7 @@ mod tests {
 
     #[test]
     fn test_selector_gen_simple() -> Result<()> {
-        let s: Selector = ".abc".into();
+        let s: Selector = vec![".abc".into()].into();
 
         assert_eq!(
             s.to_style_str(Some("stylist-abcdefgh"))?,
@@ -83,7 +82,7 @@ mod tests {
 
     #[test]
     fn test_selector_pseduo() -> Result<()> {
-        let s: Selector = ":hover".into();
+        let s: Selector = vec![":hover".into()].into();
 
         assert_eq!(
             s.to_style_str(Some("stylist-abcdefgh"))?,
@@ -95,7 +94,7 @@ mod tests {
 
     #[test]
     fn test_selector_root_pseduo() -> Result<()> {
-        let s: Selector = ":root.big".into();
+        let s: Selector = vec![":root.big".into()].into();
 
         assert_eq!(
             s.to_style_str(Some("stylist-abcdefgh"))?,
@@ -107,7 +106,7 @@ mod tests {
 
     #[test]
     fn test_selector_gen_current() -> Result<()> {
-        let s: Selector = "&.big".into();
+        let s: Selector = vec!["&.big".into()].into();
 
         assert_eq!(
             s.to_style_str(Some("stylist-abcdefgh"))?,