nrelm-macros 0.2.0

An idiomatic GUI library inspired by Elm and based on gtk3-rs
Documentation
use proc_macro2::TokenStream as TokenStream2;
use quote::{quote, quote_spanned};
use syn::Ident;
use syn::spanned::Spanned;
use syn::visit::Visit;

use super::{Handler, List, Row};

impl List {
    pub(crate) fn list_stream(&self) -> TokenStream2 {
        let gtk_import = crate::gtk_import();
        let rows_stream = self.rows.iter().map(|row| row.row_stream());
        let actions_stream = self.rows.iter().map(|row| row.action_stream());

        quote! {
            {
                let list = #gtk_import::ListBox::new();
                #gtk_import::prelude::ListBoxExt::set_selection_mode(
                    &list,
                    #gtk_import::SelectionMode::None,
                );

                let rows: Vec<#gtk_import::Widget> = vec![#(#rows_stream),*];
                let actions: Vec<Option<Box<dyn Fn()>>> = vec![#(#actions_stream),*];

                for row in rows.iter() {
                    #gtk_import::prelude::ListBoxExt::insert(&list, row, -1);
                }

                #gtk_import::prelude::ListBoxExt::connect_row_activated(
                    &list,
                    move |_, row| {
                        for (r, action) in rows.iter().zip(actions.iter()) {
                            if r == #gtk_import::prelude::Cast::upcast_ref::<#gtk_import::Widget>(row) {
                                if let Some(action) = action {
                                    action();
                                }
                                break;
                            }
                        }
                    },
                );

                // The generated widgets are not shown by default, like the
                // widgets created by the `view!` macro.
                #gtk_import::prelude::WidgetExt::show_all(&list);
                list
            }
        }
    }
}

impl Row {
    /// Expression producing the row widget.
    fn row_stream(&self) -> TokenStream2 {
        let gtk_import = crate::gtk_import();

        match self {
            Self::Widget(widget) => {
                quote_spanned! { widget.span() =>
                    #gtk_import::prelude::Cast::upcast::<#gtk_import::Widget>(#widget)
                }
            }
            Self::Labeled { label, .. } => {
                let label_span = label.span();
                quote_spanned! { label_span =>
                    {
                        let row = #gtk_import::ListBoxRow::new();
                        nrelm::RelmWidgetExt::add_css_class(&row, "activatable");
                        let label = #gtk_import::Label::new(Some(#label));
                        #gtk_import::prelude::WidgetExt::set_margin(&label, 6);
                        #gtk_import::prelude::WidgetExt::set_expand(&label, true);
                        #gtk_import::prelude::ContainerExt::add(&row, &label);
                        #gtk_import::prelude::Cast::upcast::<#gtk_import::Widget>(row)
                    }
                }
            }
        }
    }

    /// Expression producing the row action, or `None` for custom widgets.
    fn action_stream(&self) -> TokenStream2 {
        match self {
            Self::Widget(_) => quote! { None },
            Self::Labeled { label, handler } => {
                let label_span = label.span();
                match handler {
                    Handler::Msg(msg_expr) => quote_spanned! { label_span =>
                        Some(Box::new({
                            let sender = sender.clone();
                            move || sender.input(#msg_expr)
                        }))
                    },
                    Handler::Block(block) => {
                        // Clone all values that are used as method receivers
                        // inside the handler, so they can still be used
                        // afterwards by the caller.
                        let mut visitor = ReceiverVisitor::default();
                        visitor.visit_expr(block);
                        let clones = visitor.idents.into_iter().map(|ident| {
                            quote_spanned! { ident.span() =>
                                #[allow(clippy::redundant_clone)]
                                #[allow(clippy::clone_on_copy)]
                                let #ident = #ident.clone();
                            }
                        });

                        quote_spanned! { label_span =>
                            Some(Box::new({
                                #(#clones)*
                                move || { #block }
                            }))
                        }
                    }
                }
            }
        }
    }
}

/// Collects the identifiers of method receivers in an expression, e.g. `sender`
/// and `more_popover` in `sender.input(AppMsg::X); more_popover.popdown();`.
#[derive(Default)]
struct ReceiverVisitor {
    idents: Vec<Ident>,
}

impl<'ast> Visit<'ast> for ReceiverVisitor {
    fn visit_expr_method_call(&mut self, node: &'ast syn::ExprMethodCall) {
        if let syn::Expr::Path(path) = &*node.receiver
            && let Some(segment) = path.path.segments.first()
            && segment.arguments.is_empty()
            && !is_excluded_ident(&segment.ident)
            && !self.idents.contains(&segment.ident)
        {
            self.idents.push(segment.ident.clone());
        }
        syn::visit::visit_expr_method_call(self, node);
    }
}

fn is_excluded_ident(ident: &Ident) -> bool {
    matches!(
        ident.to_string().as_str(),
        "self" | "gtk" | "nrelm" | "std" | "core" | "alloc"
    )
}