Add match and closure syntax

src/cmd.rs

@@ -0,0 +1,395 @@
+use quote::{quote, ToTokens};
+use syn::{braced, bracketed, parse::Parse, punctuated::Punctuated, token, Token};
+
+pub struct Command {
+    program: Value,
+    args: Option<Punctuated<LogicArg, Token![,]>>,
+}
+
+impl Parse for Command {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let program = input.parse()?;
+
+        if input.is_empty() {
+            Ok(Self {
+                program,
+                args: None,
+            })
+        } else {
+            _ = input.parse::<Token![,]>()?;
+            Ok(Self {
+                program,
+                args: Some(Punctuated::parse_terminated(input)?),
+            })
+        }
+    }
+}
+
+impl ToTokens for Command {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let Self { program, args } = self;
+        let program = quote! { ::std::process::Command::new(#program) };
+        let args = args.as_ref().map(Punctuated::iter);
+
+        tokens.extend(args.map_or_else(
+            || quote! { #program },
+            |args| {
+                quote! {
+                    {
+                        let mut _c = #program;
+                        #(#args)*
+                        _c
+                    }
+                }
+            },
+        ));
+    }
+}
+
+enum LogicArg {
+    Expr(SingleArg),
+    ForIter(ForIter),
+    ForIn(ForIn),
+    IfLet(IfLet),
+    If(If),
+    Match(Match),
+    Closure(Closure),
+}
+
+impl Parse for LogicArg {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        if input.peek(Token![for]) {
+            if input.peek3(Token![in]) {
+                input.parse().map(Self::ForIn)
+            } else {
+                input.parse().map(Self::ForIter)
+            }
+        } else if input.peek(Token![if]) {
+            if input.peek2(Token![let]) {
+                input.parse().map(Self::IfLet)
+            } else {
+                input.parse().map(Self::If)
+            }
+        } else if input.peek(Token![match]) {
+            input.parse().map(Self::Match)
+        } else if input.peek(Token![||]) {
+            input.parse().map(Self::Closure)
+        } else {
+            input.parse().map(Self::Expr)
+        }
+    }
+}
+
+impl ToTokens for LogicArg {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        tokens.extend(match self {
+            Self::Expr(expr) => quote! { #expr },
+            Self::ForIter(for_iter) => quote! { #for_iter },
+            Self::ForIn(for_in) => quote! { #for_in },
+            Self::IfLet(if_let) => quote! { #if_let },
+            Self::If(if_) => quote! { #if_ },
+            Self::Match(match_) => quote! { #match_ },
+            Self::Closure(closure) => quote! { #closure },
+        });
+    }
+}
+
+struct ForIter {
+    expr: Value,
+}
+
+impl Parse for ForIter {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        _ = input.parse::<Token![for]>()?;
+        let expr = input.parse()?;
+
+        Ok(Self { expr })
+    }
+}
+
+impl ToTokens for ForIter {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let expr = &self.expr;
+
+        tokens.extend(quote! {
+            for _a in #expr {
+                _c.arg(_a);
+            }
+        });
+    }
+}
+
+struct ForIn {
+    pattern: syn::Pat,
+    iter: Value,
+    args: Arguments,
+}
+
+impl Parse for ForIn {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        _ = input.parse::<Token![for]>()?;
+        let pattern = input.call(syn::Pat::parse_single)?;
+        _ = input.parse::<Token![in]>()?;
+        let iter = input.parse()?;
+        _ = input.parse::<Token![=>]>()?;
+        let args = input.parse()?;
+
+        Ok(Self {
+            pattern,
+            iter,
+            args,
+        })
+    }
+}
+
+impl ToTokens for ForIn {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let Self {
+            pattern,
+            iter,
+            args,
+        } = self;
+
+        tokens.extend(quote! {
+            for #pattern in #iter {
+                #args
+            }
+        });
+    }
+}
+
+struct IfLet {
+    pattern: syn::Pat,
+    expr: Value,
+    args: Arguments,
+}
+
+impl Parse for IfLet {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        _ = input.parse::<Token![if]>()?;
+        _ = input.parse::<Token![let]>()?;
+        let pattern = input.call(syn::Pat::parse_single)?;
+        _ = input.parse::<Token![=]>()?;
+        let expr = input.parse()?;
+        _ = input.parse::<Token![=>]>()?;
+        let args = input.parse()?;
+
+        Ok(Self {
+            pattern,
+            expr,
+            args,
+        })
+    }
+}
+
+impl ToTokens for IfLet {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let Self {
+            pattern,
+            expr,
+            args,
+        } = &self;
+
+        tokens.extend(quote! {
+            if let #pattern = #expr {
+                #args
+            }
+        });
+    }
+}
+
+struct If {
+    expr: Value,
+    args: Arguments,
+}
+
+impl Parse for If {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        _ = input.parse::<Token![if]>()?;
+        let expr = input.parse()?;
+        _ = input.parse::<Token![=>]>()?;
+        let args = input.parse()?;
+
+        Ok(Self { expr, args })
+    }
+}
+
+impl ToTokens for If {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let Self { expr, args } = self;
+
+        tokens.extend(quote! {
+            if #expr {
+                #args
+            }
+        });
+    }
+}
+
+struct Match {
+    expr: Value,
+    match_arms: Punctuated<MatchArm, Token![,]>,
+}
+
+impl Parse for Match {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        _ = input.parse::<Token![match]>()?;
+        let expr = input.parse()?;
+        let arms;
+        braced!(arms in input);
+        let match_arms = Punctuated::parse_terminated(&arms)?;
+
+        Ok(Self { expr, match_arms })
+    }
+}
+
+impl ToTokens for Match {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let Self { expr, match_arms } = self;
+        let match_arms = match_arms.iter();
+
+        tokens.extend(quote! {
+            match #expr {
+                #(#match_arms)*
+            }
+        });
+    }
+}
+
+struct MatchArm {
+    pattern: syn::Pat,
+    args: Arguments,
+}
+
+impl Parse for MatchArm {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let pattern = input.call(syn::Pat::parse_multi)?;
+        _ = input.parse::<Token![=>]>()?;
+        let args = input.parse()?;
+
+        Ok(Self { pattern, args })
+    }
+}
+
+impl ToTokens for MatchArm {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let Self { pattern, args } = self;
+
+        tokens.extend(quote! {
+            #pattern => {
+                #args
+            }
+        });
+    }
+}
+
+struct Closure(syn::Expr);
+
+impl Parse for Closure {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        _ = input.parse::<Token![||]>()?;
+
+        input.parse().map(Self)
+    }
+}
+
+impl ToTokens for Closure {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let Self(block) = self;
+
+        tokens.extend(quote! {
+            let _fn = || #block;
+            for _a in _fn() {
+                _c.arg(_a);
+            }
+        });
+    }
+}
+
+enum Arguments {
+    Single(SingleArg),
+    Multi(MultiArg),
+}
+
+impl Parse for Arguments {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        if input.peek(token::Bracket) {
+            input.parse().map(Self::Multi)
+        } else {
+            input.parse().map(Self::Single)
+        }
+    }
+}
+
+impl ToTokens for Arguments {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        tokens.extend(match self {
+            Self::Single(arg) => quote! { #arg },
+            Self::Multi(args) => quote! { #args },
+        });
+    }
+}
+
+struct MultiArg(Punctuated<SingleArg, Token![,]>);
+
+impl Parse for MultiArg {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let args;
+        bracketed!(args in input);
+
+        Punctuated::parse_terminated(&args).map(Self)
+    }
+}
+
+impl ToTokens for MultiArg {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let args = self.0.iter().collect::<Vec<_>>();
+
+        tokens.extend(quote! { #(#args)* });
+    }
+}
+
+struct SingleArg(Value);
+
+impl Parse for SingleArg {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        input.parse().map(Self)
+    }
+}
+
+impl ToTokens for SingleArg {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        let arg = &self.0;
+        tokens.extend(quote! {
+            _c.arg(#arg);
+        });
+    }
+}
+
+enum Value {
+    Lit(syn::Lit),
+    Ident(syn::Ident),
+    Expr(syn::Expr),
+}
+
+impl Parse for Value {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        if input.peek(syn::Lit) {
+            input.parse().map(Self::Lit)
+        } else if input.peek(syn::Ident) {
+            input.parse().map(Self::Ident)
+        } else {
+            input.parse().map(Self::Expr)
+        }
+    }
+}
+
+impl ToTokens for Value {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        tokens.extend(match self {
+            Self::Lit(lit) => quote! { #lit },
+            Self::Ident(ident) => quote! { #ident },
+            Self::Expr(expr) => quote! { #expr },
+        });
+    }
+}