telex_macro/

lib.rs

//! Procedural macros for Telex.
//!
//! The `view!` macro provides JSX-like syntax for building UI trees.

use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::{
    braced,
    parse::{Parse, ParseStream},
    parse_macro_input, Expr, Ident, LitStr, Result, Token,
};

/// The view! macro for building UI trees with JSX-like syntax.
#[proc_macro]
pub fn view(input: TokenStream) -> TokenStream {
    let node = parse_macro_input!(input as ViewNode);
    let expanded = node.to_tokens();
    TokenStream::from(expanded)
}

/// A node in the view tree (during parsing).
enum ViewNode {
    /// An element like <Text>...</Text>
    Element(ElementNode),
    /// A string literal "Hello"
    Text(String),
    /// An expression in braces {expr}
    Expr(Expr),
}

/// A prop like on_press={...} or selected={...}
struct Prop {
    name: Ident,
    value: Expr,
}

struct ElementNode {
    tag: String,
    props: Vec<Prop>,
    children: Vec<ViewNode>,
}

impl Parse for ViewNode {
    fn parse(input: ParseStream) -> Result<Self> {
        if input.peek(Token![<]) {
            // Parse element: <Tag prop={val}>...</Tag>
            input.parse::<Token![<]>()?;
            let tag: Ident = input.parse()?;

            // Parse props
            let mut props = Vec::new();
            while !input.peek(Token![>]) && !input.peek(Token![/]) {
                let name: Ident = input.parse()?;
                input.parse::<Token![=]>()?;
                let content;
                braced!(content in input);
                let value: Expr = content.parse()?;
                props.push(Prop { name, value });
            }

            // Check for self-closing tag: <Tag />
            if input.peek(Token![/]) {
                input.parse::<Token![/]>()?;
                input.parse::<Token![>]>()?;
                return Ok(ViewNode::Element(ElementNode {
                    tag: tag.to_string(),
                    props,
                    children: Vec::new(),
                }));
            }

            input.parse::<Token![>]>()?;

            let mut children = Vec::new();

            // Parse children until we hit the closing tag
            while !(input.peek(Token![<]) && input.peek2(Token![/])) {
                if input.is_empty() {
                    return Err(syn::Error::new(tag.span(), format!("Unclosed tag: <{}>", tag)));
                }
                children.push(input.parse()?);
            }

            // Parse closing tag: </Tag>
            input.parse::<Token![<]>()?;
            input.parse::<Token![/]>()?;
            let close_tag: Ident = input.parse()?;
            input.parse::<Token![>]>()?;

            if tag != close_tag {
                return Err(syn::Error::new(
                    close_tag.span(),
                    format!(
                        "Mismatched tags: expected </{}>, found </{}>",
                        tag, close_tag
                    ),
                ));
            }

            Ok(ViewNode::Element(ElementNode {
                tag: tag.to_string(),
                props,
                children,
            }))
        } else if input.peek(LitStr) {
            // Parse string literal: "Hello"
            let lit: LitStr = input.parse()?;
            Ok(ViewNode::Text(lit.value()))
        } else if input.peek(syn::token::Brace) {
            // Parse expression: {expr}
            let content;
            braced!(content in input);
            let expr: Expr = content.parse()?;
            Ok(ViewNode::Expr(expr))
        } else {
            Err(input.error("Expected <Element>, \"string literal\", or {expression}"))
        }
    }
}

impl ViewNode {
    fn to_tokens(&self) -> TokenStream2 {
        match self {
            ViewNode::Text(s) => {
                quote! { telex::View::text(#s) }
            }
            ViewNode::Expr(expr) => {
                // Convert expression to string for text
                quote! { telex::View::text(format!("{}", #expr)) }
            }
            ViewNode::Element(elem) => elem.to_tokens(),
        }
    }
}

impl ElementNode {
    fn to_tokens(&self) -> TokenStream2 {
        match self.tag.as_str() {
            "Text" => {
                // <Text>"content"</Text> or <Text>{expr}</Text>
                if let Some(child) = self.children.first() {
                    match child {
                        ViewNode::Text(content) => quote! { telex::View::text(#content) },
                        ViewNode::Expr(expr) => quote! { telex::View::text(format!("{}", #expr)) },
                        _ => quote! { telex::View::text("") },
                    }
                } else {
                    quote! { telex::View::text("") }
                }
            }
            "VStack" => {
                let mut builder_calls = Vec::new();

                // Handle props (spacing)
                for prop in &self.props {
                    let name = &prop.name;
                    let value = &prop.value;
                    builder_calls.push(quote! { .#name(#value) });
                }

                // Handle children
                for child in &self.children {
                    let tokens = child.to_tokens();
                    builder_calls.push(quote! { .child(#tokens) });
                }

                quote! { telex::View::vstack()#(#builder_calls)*.build() }
            }
            "HStack" => {
                let mut builder_calls = Vec::new();

                // Handle props (spacing)
                for prop in &self.props {
                    let name = &prop.name;
                    let value = &prop.value;
                    builder_calls.push(quote! { .#name(#value) });
                }

                // Handle children
                for child in &self.children {
                    let tokens = child.to_tokens();
                    builder_calls.push(quote! { .child(#tokens) });
                }

                quote! { telex::View::hstack()#(#builder_calls)*.build() }
            }
            "Box" => {
                let mut builder_calls = Vec::new();

                // Handle props (border, padding, flex)
                for prop in &self.props {
                    let name = &prop.name;
                    let value = &prop.value;
                    builder_calls.push(quote! { .#name(#value) });
                }

                // Handle single child
                if let Some(child) = self.children.first() {
                    let tokens = child.to_tokens();
                    builder_calls.push(quote! { .child(#tokens) });
                }

                quote! { telex::View::boxed()#(#builder_calls)*.build() }
            }
            "Spacer" => {
                // Spacer with optional flex prop
                if let Some(prop) = self.props.iter().find(|p| p.name == "flex") {
                    let value = &prop.value;
                    quote! { telex::View::spacer_flex(#value) }
                } else {
                    quote! { telex::View::spacer() }
                }
            }
            "Button" => {
                // Parse props and children for Button
                let mut builder_calls = Vec::new();

                // Handle props
                for prop in &self.props {
                    let name = &prop.name;
                    let value = &prop.value;
                    builder_calls.push(quote! { .#name(#value) });
                }

                // Handle label from children
                if let Some(child) = self.children.first() {
                    match child {
                        ViewNode::Text(label) => {
                            builder_calls.push(quote! { .label(#label) });
                        }
                        ViewNode::Expr(expr) => {
                            builder_calls.push(quote! { .label(format!("{}", #expr)) });
                        }
                        _ => {}
                    }
                }

                quote! { telex::View::button()#(#builder_calls)*.build() }
            }
            "List" => {
                // Parse props for List: items, selected, on_select
                let mut builder_calls = Vec::new();

                for prop in &self.props {
                    let name = &prop.name;
                    let value = &prop.value;
                    builder_calls.push(quote! { .#name(#value) });
                }

                quote! { telex::View::list()#(#builder_calls)*.build() }
            }
            "TextInput" => {
                // Parse props for TextInput: value, placeholder, on_change
                let mut builder_calls = Vec::new();

                for prop in &self.props {
                    let name = &prop.name;
                    let value = &prop.value;
                    builder_calls.push(quote! { .#name(#value) });
                }

                quote! { telex::View::text_input()#(#builder_calls)*.build() }
            }
            "Checkbox" => {
                // Parse props and children for Checkbox: checked, on_toggle
                let mut builder_calls = Vec::new();

                // Handle props
                for prop in &self.props {
                    let name = &prop.name;
                    let value = &prop.value;
                    builder_calls.push(quote! { .#name(#value) });
                }

                // Handle label from children
                if let Some(child) = self.children.first() {
                    match child {
                        ViewNode::Text(label) => {
                            builder_calls.push(quote! { .label(#label) });
                        }
                        ViewNode::Expr(expr) => {
                            builder_calls.push(quote! { .label(format!("{}", #expr)) });
                        }
                        _ => {}
                    }
                }

                quote! { telex::View::checkbox()#(#builder_calls)*.build() }
            }
            "TextArea" => {
                // Parse props for TextArea: value, placeholder, rows, cursor_line, cursor_col, on_change
                let mut builder_calls = Vec::new();

                for prop in &self.props {
                    let name = &prop.name;
                    let value = &prop.value;
                    builder_calls.push(quote! { .#name(#value) });
                }

                quote! { telex::View::text_area()#(#builder_calls)*.build() }
            }
            "Modal" => {
                // Parse props for Modal: visible, title, width, height, on_dismiss
                let mut builder_calls = Vec::new();

                for prop in &self.props {
                    let name = &prop.name;
                    let value = &prop.value;
                    builder_calls.push(quote! { .#name(#value) });
                }

                // Handle single child
                if let Some(child) = self.children.first() {
                    let tokens = child.to_tokens();
                    builder_calls.push(quote! { .child(#tokens) });
                }

                quote! { telex::View::modal()#(#builder_calls)*.build() }
            }
            "StyledText" => {
                // Parse props for styled text: bold, italic, underline, dim, color, bg
                let mut content = quote! { "" };
                let mut bold_val = quote! { false };
                let mut italic_val = quote! { false };
                let mut underline_val = quote! { false };
                let mut dim_val = quote! { false };
                let mut color_call = quote! {};
                let mut bg_call = quote! {};

                // Handle props
                for prop in &self.props {
                    let name_str = prop.name.to_string();
                    let value = &prop.value;

                    match name_str.as_str() {
                        "bold" => bold_val = quote! { #value },
                        "italic" => italic_val = quote! { #value },
                        "underline" => underline_val = quote! { #value },
                        "dim" => dim_val = quote! { #value },
                        "color" => color_call = quote! { .color(#value) },
                        "bg" => bg_call = quote! { .bg(#value) },
                        _ => {}
                    }
                }

                // Handle text content from children
                if let Some(child) = self.children.first() {
                    match child {
                        ViewNode::Text(text) => {
                            content = quote! { #text };
                        }
                        ViewNode::Expr(expr) => {
                            content = quote! { format!("{}", #expr) };
                        }
                        _ => {}
                    }
                }

                // Generate conditional builder chain
                quote! {
                    {
                        let __builder = telex::View::styled_text(#content);
                        let __builder = if #bold_val { __builder.bold() } else { __builder };
                        let __builder = if #italic_val { __builder.italic() } else { __builder };
                        let __builder = if #underline_val { __builder.underline() } else { __builder };
                        let __builder = if #dim_val { __builder.dim() } else { __builder };
                        __builder #color_call #bg_call .build()
                    }
                }
            }
            unknown => {
                // Provide helpful error with suggestions
                let known_elements = [
                    "Text", "StyledText", "VStack", "HStack", "Box", "Spacer",
                    "Button", "List", "TextInput", "TextArea", "Checkbox", "Modal",
                ];

                // Find similar element names (simple edit distance check)
                let suggestion = known_elements.iter()
                    .filter(|&e| {
                        let e_lower = e.to_lowercase();
                        let u_lower = unknown.to_lowercase();
                        e_lower.starts_with(&u_lower[..1.min(u_lower.len())]) ||
                        u_lower.starts_with(&e_lower[..1.min(e_lower.len())]) ||
                        e_lower.contains(&u_lower) ||
                        u_lower.contains(&e_lower)
                    })
                    .next();

                let msg = if let Some(suggested) = suggestion {
                    format!(
                        "Unknown element: <{}>. Did you mean <{}>?\n\nAvailable elements: {}",
                        unknown, suggested, known_elements.join(", ")
                    )
                } else {
                    format!(
                        "Unknown element: <{}>.\n\nAvailable elements: {}",
                        unknown, known_elements.join(", ")
                    )
                };
                quote! { compile_error!(#msg) }
            }
        }
    }
}