Allow call expressions with multiple args in builder(foreach)

Author: gyscos

cursive-core/src/views/dialog.rs

@@ -932,76 +932,46 @@ impl View for Dialog {
     }
 }
 
-/*
-#[crate::blueprint(Dialog::new())]
-struct Blueprint {
-    title: String,
-
-    content: Option<BoxedView>,
-
-    // TODO: buttons?
-    // Define some Button type?
-    // Implement Resolvable as blueprints?
-    // Allow blueprint(foreach) with multiple arguments?
-    // Ex: foreach(add_button_with_cb( .key, .value ))
+struct Btn {
+    key: String,
+    value: std::sync::Arc<dyn Fn(&mut Cursive) + Send + Sync>,
 }
-*/
 
-crate::manual_blueprint!(Dialog, |config, context| {
-    use crate::builder::{Config, Context, Error, Resolvable};
-    let mut dialog = Dialog::new();
-
-    if let Some(title) = context.resolve(&config["title"])? {
-        dialog.set_title::<StyledString>(title);
-    }
+#[cfg(feature = "builder")]
+use crate::builder::{Config, Context, Error, Resolvable};
 
-    if let Some(title_position) = context.resolve(&config["title_position"])? {
-        dialog.set_title_position(title_position);
-    }
+#[cfg(feature = "builder")]
+impl Resolvable for Btn {
+    fn from_config(config: &Config, context: &Context) -> Result<Self, Error> {
+        let config = config
+            .as_object()
+            .ok_or_else(|| Error::invalid_config("Expected object", config))?;
 
-    let content: Option<BoxedView> = context.resolve(&config["content"])?;
-    if let Some(content) = content {
-        dialog.set_content(content);
-    }
+        let (key, value) = config
+            .iter()
+            .next()
+            .ok_or_else(|| Error::invalid_config("Expected non-empty object", config))?;
 
-    if let Some(padding) = context.resolve(&config["padding"])? {
-        dialog.set_padding(padding);
-    }
+        let key = key.into();
+        let value = context.resolve(value)?;
 
-    struct Btn {
-        key: String,
-        value: std::sync::Arc<dyn Fn(&mut Cursive) + Send + Sync>,
+        Ok(Btn { key, value })
     }
+}
 
-    impl Resolvable for Btn {
-        fn from_config(config: &Config, context: &Context) -> Result<Self, Error> {
-            let config = config
-                .as_object()
-                .ok_or_else(|| Error::invalid_config("Expected object", config))?;
-
-            let (key, value) = config
-                .iter()
-                .next()
-                .ok_or_else(|| Error::invalid_config("Expected non-empty object", config))?;
-
-            let key = key.into();
-            let value = context.resolve(value)?;
-
-            Ok(Btn { key, value })
-        }
-    }
+#[crate::blueprint(Dialog::new())]
+struct Blueprint {
+    title: String,
+    title_position: Option<HAlign>,
 
-    let buttons: Vec<Btn> = context.resolve(&config["buttons"])?;
-    for btn in buttons {
-        dialog.add_button_with_cb(btn.key, btn.value);
-    }
+    content: Option<BoxedView>,
 
-    if let Some(focus) = context.resolve(&config["focus"])? {
-        dialog.set_focus(focus);
-    }
+    #[blueprint(foreach=add_button_with_cb(buttons.key, buttons.value))]
+    buttons: Vec<Btn>,
 
-    Ok(dialog)
-});
+    padding: Option<Margins>,
+    focus: Option<DialogFocus>,
+}
 
 /*
 #[crate::fn_blueprint(Dialog::info())]

cursive-macros/src/builder/blueprint.rs

@@ -148,8 +148,8 @@ fn parse_enum(
 // )]
 struct VariableSpecs {
     no_config: bool,
-    setter: Option<syn::Ident>,
-    foreach: Option<syn::Ident>,
+    setter: Option<syn::Expr>,
+    foreach: Option<syn::Expr>,
     callback: Option<bool>,
     config_name: Option<String>,
     default: Option<syn::Expr>,
@@ -319,33 +319,7 @@ impl Variable {
             Consumer::Noop
         } else {
             let inferred_type = looks_inferred(&field.ty);
-            match (specs.setter, specs.foreach, specs.callback, inferred_type) {
-                (None, None, None | Some(false), false) | (None, None, Some(false), true) => {
-                    // Default case: use a setter based on the ident.
-                    let setter = format!("set_{parameter_name}");
-                    Consumer::Setter(Setter {
-                        method: syn::Ident::new(&setter, Span::call_site()),
-                    })
-                }
-                (Some(setter), None, None | Some(false), _) => {
-                    // Explicit setter function
-                    Consumer::Setter(Setter { method: setter })
-                }
-                (None, Some(foreach), None | Some(false), _) => {
-                    // Foreach function (like `add_item`)
-                    Consumer::ForEach(Box::new(Consumer::Setter(Setter { method: foreach })))
-                }
-                (None, None, Some(true), _) | (None, None, _, true) => {
-                    // TODO: Check that the type is iterable? A Vec?
-
-                    // Callback flag means we use the callback_helper-generated `_cb` setter.
-                    let setter = format!("set_{parameter_name}_cb");
-                    Consumer::Setter(Setter {
-                        method: syn::Ident::new(&setter, Span::call_site()),
-                    })
-                }
-                _ => panic!("unsupported configuration"),
-            }
+            Consumer::parse(&specs, inferred_type, &parameter_name)
         };
 
         // Some types have special handling
@@ -372,8 +346,11 @@ impl Variable {
     }
 }
 
-struct Setter {
-    method: syn::Ident,
+enum Setter {
+    /// A method call, implicitly applied to the target object.
+    Call(syn::ExprCall),
+    /// An ident, the name of the method to call, with a single arg.
+    Ident(syn::Ident),
 }
 
 impl Setter {
@@ -382,9 +359,30 @@ impl Setter {
         base_ident: &syn::Ident,
         field_ident: &syn::Ident,
     ) -> proc_macro2::TokenStream {
-        let function = &self.method;
-        quote! {
-            #base_ident.#function(#field_ident);
+        match self {
+            Self::Call(call) => {
+                // Here we don't care about the field ident.
+                quote! {
+                    #base_ident.#call;
+                }
+            }
+            Self::Ident(function) => {
+                quote! {
+                    #base_ident.#function(#field_ident);
+                }
+            }
+        }
+    }
+
+    fn parse(expr: &syn::Expr) -> Self {
+        match expr {
+            syn::Expr::Path(path) => {
+                let ident = path.path.get_ident().unwrap();
+                Self::Ident(ident.clone())
+            }
+            syn::Expr::Call(call) => Self::Call(call.clone()),
+
+            _ => panic!("Unsupported setter expression ({expr:?})"),
         }
     }
 }
@@ -401,6 +399,7 @@ enum Consumer {
     // The value is a Vec<T> and we need to call something on each item.
     ForEach(Box<Consumer>),
 
+    // Optional consumer - unwraps an option and calls the inner consumer.
     Opt(Box<Consumer>),
 
     // We need to call this method to "set" the value.
@@ -436,6 +435,37 @@ impl Consumer {
             }
         }
     }
+
+    fn parse(specs: &VariableSpecs, inferred_type: bool, parameter_name: &str) -> Self {
+        match (
+            &specs.setter,
+            &specs.foreach,
+            &specs.callback,
+            inferred_type,
+        ) {
+            (None, None, None | Some(false), false) | (None, None, Some(false), true) => {
+                // Default case: use a setter based on the ident.
+                let setter = format!("set_{parameter_name}");
+                Consumer::Setter(Setter::Ident(syn::Ident::new(&setter, Span::call_site())))
+            }
+            (Some(setter), None, None | Some(false), _) => {
+                // Explicit setter function
+                Consumer::Setter(Setter::parse(setter))
+            }
+            (None, Some(foreach), None | Some(false), _) => {
+                // Foreach function (like `add_item`)
+                Consumer::ForEach(Box::new(Consumer::Setter(Setter::parse(foreach))))
+            }
+            (None, None, Some(true), _) | (None, None, _, true) => {
+                // TODO: Check that the type is iterable? A Vec?
+
+                // Callback flag means we use the callback_helper-generated `_cb` setter.
+                let setter = format!("set_{parameter_name}_cb");
+                Consumer::Setter(Setter::Ident(syn::Ident::new(&setter, Span::call_site())))
+            }
+            _ => panic!("unsupported configuration"),
+        }
+    }
 }
 
 // Returns the quote!d code to build the object using this struct.