From c514a38d3595d75f707b6a37773e7a4de72268da Mon Sep 17 00:00:00 2001 From: Yiffy Dev Date: Sat, 2 Nov 2024 01:52:22 +0500 Subject: [PATCH] refactor: use single unified syntax shim type instead of many --- sabry_build/src/buildmagic.rs | 2 +- sabry_intrnl/src/compiler/mod.rs | 31 +----------- sabry_intrnl/src/scoper/hash.rs | 6 +-- sabry_intrnl/src/scoper/mod.rs | 10 ++-- sabry_intrnl/src/syntax/mod.rs | 22 ++++++--- sabry_intrnl/src/syntax/ostrta.rs | 64 +++++++++++++++++++++++++ sabry_procmacro_impl/src/impls/mod.rs | 53 ++++---------------- sabry_procmacro_impl/src/impls/sassy.rs | 2 +- sabry_procmacro_impl/src/impls/styly.rs | 4 +- 9 files changed, 102 insertions(+), 92 deletions(-) create mode 100644 sabry_intrnl/src/syntax/ostrta.rs diff --git a/sabry_build/src/buildmagic.rs b/sabry_build/src/buildmagic.rs index 0e66c96..7faa138 100644 --- a/sabry_build/src/buildmagic.rs +++ b/sabry_build/src/buildmagic.rs @@ -186,7 +186,7 @@ impl SabryBuilder { } let css = self.css_compiler.compile_module( - scope.original_scope.adapter().syntax.into(), + scope.original_scope.adapter().syntax, &scope.hashed_code, )?; self.state diff --git a/sabry_intrnl/src/compiler/mod.rs b/sabry_intrnl/src/compiler/mod.rs index 882a8bf..4fcd129 100644 --- a/sabry_intrnl/src/compiler/mod.rs +++ b/sabry_intrnl/src/compiler/mod.rs @@ -7,7 +7,7 @@ use lightningcss::{ targets::Targets, }; -use crate::config::SabryConfig; +use crate::{config::SabryConfig, syntax::ostrta::OneSyntaxToRuleThemAll}; /// Convenience wrapper on Grass and Lightningcss pub struct CompilerAdapter { @@ -21,7 +21,7 @@ impl CompilerAdapter { pub fn compile_module( &self, - syntax: CompilerSyntax, + syntax: OneSyntaxToRuleThemAll, code: &str, ) -> Result { let options = grass::Options::from(&self.config).input_syntax(syntax.into()); @@ -131,30 +131,3 @@ impl Debug for SabryCompilerError { write!(f, "{explain}") } } - -/// Unification wrapper over all the Syntax enums -#[derive(Clone, Copy)] -pub enum CompilerSyntax { - Sass, - Scss, -} - -impl From for CompilerSyntax { - fn from(value: raffia::Syntax) -> Self { - match value { - raffia::Syntax::Sass => Self::Sass, - raffia::Syntax::Scss => Self::Scss, - // TODO: fallbacky error-prone - _ => Self::Scss, - } - } -} - -impl From for grass::InputSyntax { - fn from(value: CompilerSyntax) -> Self { - match value { - CompilerSyntax::Scss => Self::Scss, - CompilerSyntax::Sass => Self::Sass, - } - } -} diff --git a/sabry_intrnl/src/scoper/hash.rs b/sabry_intrnl/src/scoper/hash.rs index 4188a39..e40819f 100644 --- a/sabry_intrnl/src/scoper/hash.rs +++ b/sabry_intrnl/src/scoper/hash.rs @@ -69,7 +69,7 @@ impl ScopeHash { mod test { use syn::Ident; - use crate::{config::SabryHashConfig, scoper::ArbitraryScope}; + use crate::{config::SabryHashConfig, scoper::ArbitraryScope, syntax::ostrta::OneSyntaxToRuleThemAll}; use super::ScopeHash; @@ -78,7 +78,7 @@ mod test { let source = ".cls1{color:red; &-dark{color: black} #id1 {color:green;} div {color:blue;}} .cls3#id2{color: black;}"; let scope1 = ArbitraryScope::from_source( - raffia::Syntax::Scss, + OneSyntaxToRuleThemAll::Scss, syn::parse_str::("lasifudm").unwrap(), source, ) @@ -86,7 +86,7 @@ mod test { let hash1 = ScopeHash::new(&scope1, &SabryHashConfig::default()); let scope2 = ArbitraryScope::from_source( - raffia::Syntax::Scss, + OneSyntaxToRuleThemAll::Scss, syn::parse_str::("lasifudm").unwrap(), source, ) diff --git a/sabry_intrnl/src/scoper/mod.rs b/sabry_intrnl/src/scoper/mod.rs index d89f7b0..934d646 100644 --- a/sabry_intrnl/src/scoper/mod.rs +++ b/sabry_intrnl/src/scoper/mod.rs @@ -5,7 +5,7 @@ use hash::ScopeHash; use raffia::Spanned; use regex::Regex; -use crate::{config::SabryHashConfig, syntax::StylesheetAdapter}; +use crate::{config::SabryHashConfig, syntax::{ostrta::OneSyntaxToRuleThemAll, StylesheetAdapter}}; pub mod hash; @@ -35,7 +35,7 @@ pub struct ArbitraryScope<'s> { impl<'s> ArbitraryScope<'s> { /// Parse given source code with given syntax and assign given name pub fn from_source( - syntax: raffia::Syntax, + syntax: OneSyntaxToRuleThemAll, name: syn::Ident, source: &'s str, ) -> Result { @@ -375,7 +375,7 @@ mod test { use crate::{ config::SabryHashConfig, - scoper::{hash::ScopeHash, HashedScope}, + scoper::{hash::ScopeHash, HashedScope}, syntax::ostrta::OneSyntaxToRuleThemAll, }; use super::ArbitraryScope; @@ -415,7 +415,7 @@ mod test { } let scope = ArbitraryScope::from_source( - raffia::Syntax::Scss, + OneSyntaxToRuleThemAll::Scss, syn::parse_str("scope1").unwrap(), code, ) @@ -463,7 +463,7 @@ mod test { let hash_cfg = SabryHashConfig::default(); let scope = ArbitraryScope::from_source( - raffia::Syntax::Scss, + OneSyntaxToRuleThemAll::Scss, syn::parse_str::("scope2oiej").unwrap(), code, ) diff --git a/sabry_intrnl/src/syntax/mod.rs b/sabry_intrnl/src/syntax/mod.rs index a52d7d6..ba85336 100644 --- a/sabry_intrnl/src/syntax/mod.rs +++ b/sabry_intrnl/src/syntax/mod.rs @@ -1,24 +1,30 @@ +use ostrta::OneSyntaxToRuleThemAll; use raffia::{ ast::{ ClassSelector, CompoundSelector, IdSelector, NestingSelector, SimpleSelector, Statement, Stylesheet, TypeSelector, }, - ParserBuilder, Syntax, + ParserBuilder, }; +pub mod ostrta; + /// Convenience wrapper for [Stylesheet] pub struct StylesheetAdapter<'s> { - pub syntax: Syntax, + pub syntax: OneSyntaxToRuleThemAll, source: &'s str, stylesheet: Stylesheet<'s>, } impl<'s> StylesheetAdapter<'s> { - pub fn new(source: &'s str, syntax: Syntax) -> Result { + pub fn new( + source: &'s str, + syntax: OneSyntaxToRuleThemAll, + ) -> Result { Ok(Self { stylesheet: ParserBuilder::new(source) .ignore_comments() - .syntax(syntax) + .syntax(syntax.into()) .build() .parse()?, syntax, @@ -103,6 +109,8 @@ mod test { use raffia::Spanned; + use crate::syntax::ostrta::OneSyntaxToRuleThemAll; + use super::StylesheetAdapter; #[test] @@ -157,7 +165,7 @@ div#id2 let expect_tags = HashSet::from(["ul", "div", "span"]); //scss - let adp = StylesheetAdapter::new(source_scss, raffia::Syntax::Scss).unwrap(); + let adp = StylesheetAdapter::new(source_scss, OneSyntaxToRuleThemAll::Scss).unwrap(); let classes = adp .class_selectors() @@ -183,7 +191,7 @@ div#id2 assert_eq!(expect_tags, tags); //sass - let adp = StylesheetAdapter::new(source_sass, raffia::Syntax::Sass).unwrap(); + let adp = StylesheetAdapter::new(source_sass, OneSyntaxToRuleThemAll::Sass).unwrap(); let classes = adp .class_selectors() @@ -215,7 +223,7 @@ div#id2 let newname = "cls203-jg7ihgjhftyfhjh"; let expect = ".cls1{color:red; .cls203-jg7ihgjhftyfhjh{color:green;}}"; - let adp = StylesheetAdapter::new(scss, raffia::Syntax::Scss).unwrap(); + let adp = StylesheetAdapter::new(scss, OneSyntaxToRuleThemAll::Scss).unwrap(); let classes = adp.class_selectors(); let target_class = classes[0].clone(); diff --git a/sabry_intrnl/src/syntax/ostrta.rs b/sabry_intrnl/src/syntax/ostrta.rs new file mode 100644 index 0000000..1edbf1c --- /dev/null +++ b/sabry_intrnl/src/syntax/ostrta.rs @@ -0,0 +1,64 @@ +/// Convenience unification entrypoint +/// to make friends with all the different syntax-consumers +#[derive(Debug, Clone, Copy)] +pub enum OneSyntaxToRuleThemAll { + Sass, + Scss +} + +impl Default for OneSyntaxToRuleThemAll { + fn default() -> Self { + Self::Scss + } +} + +impl TryFrom<&str> for OneSyntaxToRuleThemAll { + type Error = (); + fn try_from(value: &str) -> Result { + match value { + "sass" => Ok(Self::Sass), + "scss" => Ok(Self::Scss), + _ => Err(()) + } + } +} + +impl TryFrom for OneSyntaxToRuleThemAll { + type Error = (); + fn try_from(value: raffia::Syntax) -> Result { + match value { + raffia::Syntax::Sass => Ok(Self::Sass), + raffia::Syntax::Scss => Ok(Self::Scss), + _ => Err(()) + } + } +} + +impl TryFrom for OneSyntaxToRuleThemAll { + type Error = (); + fn try_from(value: grass::InputSyntax) -> Result { + match value { + grass::InputSyntax::Sass => Ok(Self::Sass), + grass::InputSyntax::Scss => Ok(Self::Scss), + _ => Err(()) + } + } +} + +impl From for raffia::Syntax { + fn from(value: OneSyntaxToRuleThemAll) -> Self { + match value { + OneSyntaxToRuleThemAll::Sass => Self::Sass, + OneSyntaxToRuleThemAll::Scss => Self::Scss + } + } +} + +impl From for grass::InputSyntax { + fn from(value: OneSyntaxToRuleThemAll) -> Self { + match value { + OneSyntaxToRuleThemAll::Scss => Self::Scss, + OneSyntaxToRuleThemAll::Sass => Self::Sass + } + } +} diff --git a/sabry_procmacro_impl/src/impls/mod.rs b/sabry_procmacro_impl/src/impls/mod.rs index 0a0bbde..009df1f 100644 --- a/sabry_procmacro_impl/src/impls/mod.rs +++ b/sabry_procmacro_impl/src/impls/mod.rs @@ -3,7 +3,7 @@ use std::{fmt::Debug, fs, path::PathBuf, str::FromStr}; use proc_macro2::{Span, TokenStream}; use quote::{quote, ToTokens, TokenStreamExt}; use regex::Regex; -use sabry_intrnl::compiler::CompilerSyntax; +use sabry_intrnl::syntax::ostrta::OneSyntaxToRuleThemAll; use syn::{braced, parse::Parse, Ident, LitStr, Token}; pub mod sassy; @@ -93,26 +93,20 @@ impl ToString for ArbitraryStyleBlock { } } -#[derive(Clone, Copy)] -pub enum ArbitraryStyleSyntax { - Scss, - Sass, -} +#[derive(Default, Debug, Clone, Copy)] +pub struct ArbitraryStyleSyntax(OneSyntaxToRuleThemAll); -impl From for CompilerSyntax { +impl From for OneSyntaxToRuleThemAll { fn from(value: ArbitraryStyleSyntax) -> Self { - match value { - ArbitraryStyleSyntax::Sass => Self::Sass, - ArbitraryStyleSyntax::Scss => Self::Scss, - } + value.0 } } impl ToTokens for ArbitraryStyleSyntax { fn to_tokens(&self, tokens: &mut TokenStream) { - match self { - Self::Sass => tokens.append_all(quote! {"sass"}), - Self::Scss => tokens.append_all(quote! {"scss"}), + match self.0 { + OneSyntaxToRuleThemAll::Sass => tokens.append_all(quote! {"sass"}), + OneSyntaxToRuleThemAll::Scss => tokens.append_all(quote! {"scss"}), } } } @@ -120,11 +114,7 @@ impl ToTokens for ArbitraryStyleSyntax { impl TryFrom<&str> for ArbitraryStyleSyntax { type Error = (); fn try_from(value: &str) -> Result { - match value { - "sass" => Ok(Self::Sass), - "scss" => Ok(Self::Scss), - _ => Err(()) - } + Ok(Self(OneSyntaxToRuleThemAll::try_from(value)?)) } } @@ -152,31 +142,6 @@ impl Parse for ArbitraryStyleSyntax { } } -impl Debug for ArbitraryStyleSyntax { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - let name = match self { - Self::Sass => "sass", - Self::Scss => "scss", - }; - write!(f, "{name}") - } -} - -impl Default for ArbitraryStyleSyntax { - fn default() -> Self { - Self::Scss - } -} - -impl From for raffia::Syntax { - fn from(value: ArbitraryStyleSyntax) -> Self { - match value { - ArbitraryStyleSyntax::Sass => Self::Sass, - ArbitraryStyleSyntax::Scss => Self::Scss, - } - } -} - #[cfg(test)] mod test { #[test] diff --git a/sabry_procmacro_impl/src/impls/sassy.rs b/sabry_procmacro_impl/src/impls/sassy.rs index e8149bc..c15c303 100644 --- a/sabry_procmacro_impl/src/impls/sassy.rs +++ b/sabry_procmacro_impl/src/impls/sassy.rs @@ -22,7 +22,7 @@ pub fn sassy_macro_impl(input: TokenStream) -> TokenStream { }; // quick raffia syntax check - match ArbitraryScope::from_source(mode.into(), ident.clone(), &code.code) { + match ArbitraryScope::from_source(mode.0, ident.clone(), &code.code) { Ok(_) => {} Err(e) => return syn::Error::new(code.span, format!("{e:?}")).into_compile_error(), } diff --git a/sabry_procmacro_impl/src/impls/styly.rs b/sabry_procmacro_impl/src/impls/styly.rs index 4a157d2..296fc4f 100644 --- a/sabry_procmacro_impl/src/impls/styly.rs +++ b/sabry_procmacro_impl/src/impls/styly.rs @@ -45,7 +45,7 @@ pub fn styly_macro_impl(input: TokenStream) -> TokenStream { Err(e) => return e.to_compile_error(), }; - let scope = match ArbitraryScope::from_source(ms.syntax.into(), ms.scope.clone(), &ms.code.code) + let scope = match ArbitraryScope::from_source(ms.syntax.0, ms.scope.clone(), &ms.code.code) { Ok(s) => match s.hashed(&config.hash) { Ok(hs) => Ok(hs), @@ -134,7 +134,7 @@ pub fn styly_macro_impl(input: TokenStream) -> TokenStream { if constant { let compiler = CompilerAdapter::new(config.clone()); - let css = match compiler.compile_module(ms.syntax.into(), &ms.code.code) { + let css = match compiler.compile_module(ms.syntax.0, &ms.code.code) { Ok(c) => c, Err(e) => { return syn::Error::new(