sabry_procmacro_impl 0.0.4

Sabry proc-macro internals reusable outside of proc-macro context
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use std::path::PathBuf;

use proc_macro2::TokenStream;
use quote::quote;
use sabry_intrnl::scoper::ArbitraryScope;
use syn::{
    parse::{Parse, ParseStream},
    Ident,
};

use super::{ArbitraryStyleBlock, ArbitraryStyleSyntax};

/// Syntax:
/// `#ident(:$syntax)? { $code }`
///
/// `$syntax`: sass/scss
///
/// `$code`: intended to be valid based on $syntax
pub fn scssy_macro_impl(input: TokenStream, source_path: Option<PathBuf>) -> TokenStream {
    let MacroSyntax {
        ident,
        syntax,
        code,
    } = match syn::parse::Parser::parse2(
        |input: ParseStream<'_>| MacroSyntax::parse_syn(input, source_path),
        input,
    ) {
        Ok(m) => m,
        Err(e) => return e.to_compile_error(),
    };

    // quick raffia syntax check
    match ArbitraryScope::from_source(syntax.0, ident.clone(), &code.code) {
        Ok(_) => {}
        Err(e) => return syn::Error::new(code.span, format!("{e:?}")).into_compile_error(),
    }

    let sourcesass = code.to_string();
    let macro_doc = format!("Arbitrary {:?} code declared with `scssy!`. Pretty usable in tandem with `usey!` and `buildy` at build time", syntax);

    quote! {
        #[doc = #macro_doc]
        #[macro_export]
        macro_rules! #ident {
            () => {#sourcesass};
            (syntax) => {#syntax};
        }
    }
}

pub struct MacroSyntax {
    ident: Ident,
    syntax: ArbitraryStyleSyntax,
    code: ArbitraryStyleBlock,
}

impl MacroSyntax {
    pub fn parse_syn(
        input: syn::parse::ParseStream,
        source_path: Option<PathBuf>,
    ) -> syn::Result<Self> {
        let ident = input.parse::<Ident>()?;
        let syntax = input.parse::<ArbitraryStyleSyntax>()?;

        let code = match source_path {
            Some(sp) => ArbitraryStyleBlock::parse_syn(input, Some(sp))?,
            None => input.parse::<ArbitraryStyleBlock>()?,
        };

        Ok(Self {
            ident,
            syntax,
            code,
        })
    }
}

impl Parse for MacroSyntax {
    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
        Self::parse_syn(input, None)
    }
}

#[cfg(test)]
mod test {}