Chore: add in style crate, and abort any styligng

packages/core-macro/src/styles/calc.rs

@@ -0,0 +1,264 @@
+//! The `calc` functionality.
+use crate::LengthPercentage;
+use ::{
+    proc_macro2::TokenStream,
+    quote::{quote, ToTokens},
+    std::fmt,
+    syn::{
+        custom_keyword, parenthesized,
+        parse::{Parse, ParseStream},
+        Token,
+    },
+};
+
+/// Values that can be a calculaion (currently restricted to length & percentages)
+#[derive(Debug, Clone, PartialEq)]
+pub enum Calc {
+    Calculated(CalcSum),
+    Normal(LengthPercentage),
+}
+
+impl fmt::Display for Calc {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Calc::Calculated(inner) => write!(f, "calc({})", inner),
+            Calc::Normal(inner) => write!(f, "{}", inner),
+        }
+    }
+}
+
+impl Parse for Calc {
+    fn parse(s: ParseStream) -> syn::Result<Self> {
+        custom_keyword!(calc);
+        if s.peek(calc) {
+            s.parse::<calc>()?;
+            let content;
+            parenthesized!(content in s);
+            Ok(Calc::Calculated(content.parse()?))
+        } else {
+            Ok(Calc::Normal(s.parse()?))
+        }
+    }
+}
+
+impl ToTokens for Calc {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        tokens.extend(match self {
+            Calc::Calculated(inner) => quote!(style::Calc::Calculated(#inner)),
+            Calc::Normal(inner) => quote!(style::Calc::Normal(#inner)),
+        });
+    }
+}
+
+#[test]
+fn test_calc() {
+    for (input, output) in vec![
+        ("calc(10% - 20\"em\")", "calc(10% - 20em)"),
+        ("calc(100% + 5px)", "calc(100% + 5px)"),
+        ("calc(100% - 60px)", "calc(100% - 60px)"),
+    ] {
+        assert_eq!(&syn::parse_str::<Calc>(input).unwrap().to_string(), output);
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct CalcSum {
+    pub first: CalcProduct,
+    pub rest: Vec<SumOp>,
+}
+
+impl fmt::Display for CalcSum {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.first)?;
+        for op in self.rest.iter() {
+            write!(f, "{}", op)?;
+        }
+        Ok(())
+    }
+}
+
+impl Parse for CalcSum {
+    fn parse(s: ParseStream) -> syn::Result<Self> {
+        let first: CalcProduct = s.parse()?;
+        let mut rest: Vec<SumOp> = vec![];
+        while SumOp::peek(s) {
+            rest.push(s.parse()?);
+        }
+        Ok(CalcSum { first, rest })
+    }
+}
+
+impl ToTokens for CalcSum {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let first = &self.first;
+        let rest = self.rest.iter();
+        tokens.extend(quote! {
+            style::calc::CalcSum {
+                first: #first,
+                rest: vec![#(#rest,)*]
+            }
+        });
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum SumOp {
+    Add(CalcProduct),
+    Sub(CalcProduct),
+}
+
+impl SumOp {
+    fn peek(s: ParseStream) -> bool {
+        s.peek(Token![+]) || s.peek(Token![-])
+    }
+}
+
+impl fmt::Display for SumOp {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            SumOp::Add(inner) => write!(f, " + {}", inner),
+            SumOp::Sub(inner) => write!(f, " - {}", inner),
+        }
+    }
+}
+
+impl Parse for SumOp {
+    fn parse(s: ParseStream) -> syn::Result<Self> {
+        let lookahead = s.lookahead1();
+        if lookahead.peek(Token![+]) {
+            s.parse::<Token![+]>()?;
+            Ok(SumOp::Add(s.parse()?))
+        } else if lookahead.peek(Token![-]) {
+            s.parse::<Token![-]>()?;
+            Ok(SumOp::Sub(s.parse()?))
+        } else {
+            Err(lookahead.error())
+        }
+    }
+}
+
+impl ToTokens for SumOp {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        tokens.extend(match self {
+            SumOp::Add(inner) => quote!(style::SumOp::Add(#inner)),
+            SumOp::Sub(inner) => quote!(style::SumOp::Sub(#inner)),
+        });
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct CalcProduct {
+    pub first: CalcValue,
+    pub rest: Vec<ProductOp>,
+}
+
+impl fmt::Display for CalcProduct {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.first)?;
+        for op in self.rest.iter() {
+            write!(f, "{}", op)?;
+        }
+        Ok(())
+    }
+}
+
+impl Parse for CalcProduct {
+    fn parse(s: ParseStream) -> syn::Result<Self> {
+        let first: CalcValue = s.parse()?;
+        let mut rest: Vec<ProductOp> = vec![];
+        while ProductOp::peek(s) {
+            rest.push(s.parse()?);
+        }
+        Ok(CalcProduct { first, rest })
+    }
+}
+
+impl ToTokens for CalcProduct {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let first = &self.first;
+        let rest = self.rest.iter();
+        tokens.extend(quote! {
+            style::calc::CalcProduct {
+                first: #first,
+                rest: vec![#(#rest,)*]
+            }
+        });
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ProductOp {
+    Mul(CalcValue),
+    // todo Div(Number),
+}
+
+impl ProductOp {
+    pub fn peek(s: ParseStream) -> bool {
+        s.peek(Token![*]) // || s.peek(Token[/])
+    }
+}
+
+impl fmt::Display for ProductOp {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            ProductOp::Mul(inner) => write!(f, "*{}", inner),
+            //ProductOp::Div(inner) => write!(f, "/{}", inner),
+        }
+    }
+}
+
+impl Parse for ProductOp {
+    fn parse(s: ParseStream) -> syn::Result<Self> {
+        let lookahead = s.lookahead1();
+        if lookahead.peek(Token![*]) {
+            s.parse::<Token![*]>()?;
+            Ok(ProductOp::Mul(s.parse()?))
+        /*
+        } else if lookahead.peek(Token![/]) {
+            s.parse::<Token![/]>()?;
+            Ok(ProductOp::Div(s.parse()?))
+        */
+        } else {
+            Err(lookahead.error())
+        }
+    }
+}
+
+impl ToTokens for ProductOp {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        tokens.extend(match self {
+            ProductOp::Mul(inner) => quote!(style::ProductOp::Mul(#inner)),
+            //ProductOp::Div(inner) => quote!(style::ProductOp::Div(#inner)),
+        });
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum CalcValue {
+    LengthPercentage(LengthPercentage),
+    // todo more variants
+}
+
+impl Parse for CalcValue {
+    fn parse(s: ParseStream) -> syn::Result<Self> {
+        Ok(CalcValue::LengthPercentage(s.parse()?))
+    }
+}
+
+impl fmt::Display for CalcValue {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            CalcValue::LengthPercentage(inner) => write!(f, "{}", inner),
+        }
+    }
+}
+
+impl ToTokens for CalcValue {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        tokens.extend(match self {
+            CalcValue::LengthPercentage(inner) => {
+                quote!(style::CalcValue::LengthPercentage(#inner))
+            }
+        });
+    }
+}