Add support for description

Author: BCSol

rclrs/src/lib.rs

@@ -213,7 +213,7 @@ pub use error::*;
 pub use executor::*;
 pub use logging::*;
 pub use node::*;
-pub use parameter::structured::{ParameterOptions, StructuredParameters, StructuredParametersMeta};
+pub use parameter::structured::{StructuredParameters, StructuredParametersMeta};
 pub use parameter::*;
 pub use publisher::*;
 pub use qos::*;

rclrs/src/parameter/structured.rs

@@ -7,6 +7,7 @@ pub trait StructuredParametersMeta<T>: Sized {
         node: &NodeState,
         name: &str,
         default: Option<T>,
+        description: impl Into<std::sync::Arc<str>>,
     ) -> core::result::Result<Self, crate::DeclarationError>;
 }
 
@@ -15,11 +16,12 @@ pub trait StructuredParameters: Sized {
         node: &NodeState,
         name: &str,
         default: Option<T>,
+        description: impl Into<std::sync::Arc<str>>,
     ) -> core::result::Result<Self, crate::DeclarationError>
     where
         Self: StructuredParametersMeta<T>,
     {
-        Self::declare_structured_(node, name, default)
+        Self::declare_structured_(node, name, default, description)
     }
 }
 impl<T: crate::ParameterVariant> StructuredParameters for crate::MandatoryParameter<T> {}
@@ -28,13 +30,14 @@ impl<T: crate::ParameterVariant> StructuredParametersMeta<T> for crate::Mandator
         node: &NodeState,
         name: &str,
         default: Option<T>,
+        description: impl Into<std::sync::Arc<str>>,
     ) -> core::result::Result<Self, crate::DeclarationError> {
         let builder = node.declare_parameter(name);
         let builder = match default {
             Some(default) => builder.default(default),
             None => builder,
         };
-        builder.mandatory()
+        builder.description(description).mandatory()
     }
 }
 impl<T: crate::ParameterVariant> StructuredParameters for crate::ReadOnlyParameter<T> {}
@@ -43,13 +46,14 @@ impl<T: crate::ParameterVariant> StructuredParametersMeta<T> for crate::ReadOnly
         node: &NodeState,
         name: &str,
         default: Option<T>,
+        description: impl Into<std::sync::Arc<str>>,
     ) -> core::result::Result<Self, crate::DeclarationError> {
         let builder = node.declare_parameter(name);
         let builder = match default {
             Some(default) => builder.default(default),
             None => builder,
         };
-        builder.read_only()
+        builder.description(description).read_only()
     }
 }
 impl<T: crate::ParameterVariant> StructuredParameters for crate::OptionalParameter<T> {}
@@ -58,13 +62,14 @@ impl<T: crate::ParameterVariant> StructuredParametersMeta<T> for crate::Optional
         node: &NodeState,
         name: &str,
         default: Option<T>,
+        description: impl Into<std::sync::Arc<str>>,
     ) -> core::result::Result<Self, crate::DeclarationError> {
         let builder = node.declare_parameter(name);
         let builder = match default {
             Some(default) => builder.default(default),
             None => builder,
         };
-        builder.optional()
+        builder.description(description).optional()
     }
 }
 
@@ -76,7 +81,7 @@ impl NodeState {
     where
         T: StructuredParameters + StructuredParametersMeta<T0>,
     {
-        T::declare_structured(self, name, None)
+        T::declare_structured(self, name, None, "")
     }
 }
 
@@ -171,4 +176,27 @@ mod tests {
         let _params: SimpleStructuredParametersWithDefaults = node.declare_parameters("").unwrap();
         println!("{:?}", _params);
     }
+    #[derive(Debug, StructuredParameters)]
+    struct SimpleStructuredParametersWithDefaultsAndDescriptions {
+        #[param(default = 42.0, description = "_mandatory")]
+        _mandatory: rclrs::MandatoryParameter<f64>,
+        #[param(default = 42.0, description = "_optional")]
+        _optional: rclrs::OptionalParameter<f64>,
+        #[param(default = Arc::from("test"), description = "_readonly")]
+        _readonly: rclrs::ReadOnlyParameter<Arc<str>>,
+    }
+
+    #[test]
+    fn test_simple_structured_parameters_with_defaults_and_descriptions() {
+        let args: Vec<String> = ["test", "--ros-args"]
+            .into_iter()
+            .map(str::to_string)
+            .collect();
+        let context = crate::Context::new(args, rclrs::InitOptions::default()).unwrap();
+        let exec = context.create_basic_executor();
+        let node = exec.create_node(rclrs::NodeOptions::new("test")).unwrap();
+        let _params: SimpleStructuredParametersWithDefaultsAndDescriptions =
+            node.declare_parameters("").unwrap();
+        println!("{:?}", _params);
+    }
 }

rclrs_proc_macros/src/impl.rs

@@ -25,15 +25,20 @@ pub(crate) fn derive_struct_parameters(input: DeriveInput) -> syn::Result<TokenS
         let ident_str = syn::LitStr::new(&f.ident.as_ref().unwrap().to_string(), ident.span());
 
         let mut default: Option<Expr> = None;
+        let mut description: Option<Expr> = None;
 
         for attr in &f.attrs {
             if attr.path().is_ident("param") {
                 attr.parse_nested_meta(|meta| {
                     if meta.path.is_ident("default") {
                         default = Some(meta.value()?.parse()?);
                         Ok(())
+                    } else if meta.path.is_ident("description") {
+                        description = Some(meta.value()?.parse()?);
+                        Ok(())
                     } else {
-                        syn::Result::Err(syn::Error::new_spanned(meta.path, "Unknown key."))
+                        let err = format!("Unknown key: {:?}", &meta.path);
+                        syn::Result::Err(syn::Error::new_spanned(meta.path, err))
                     }
                 })?;
             }
@@ -43,6 +48,10 @@ pub(crate) fn derive_struct_parameters(input: DeriveInput) -> syn::Result<TokenS
             Some(expr) => quote! {Some(#expr)},
             None => quote! {None},
         };
+        let description = match description {
+            Some(expr) => quote! {#expr},
+            None => quote! {""},
+        };
 
         let field_type = match &f.ty {
             syn::Type::Path(p) => {
@@ -67,6 +76,8 @@ pub(crate) fn derive_struct_parameters(input: DeriveInput) -> syn::Result<TokenS
                     prefix => [prefix, ".", #ident_str].concat(),
               }},
               #default,
+              #description,
+
           )?,
         };
         args.push(r);
@@ -86,6 +97,7 @@ pub(crate) fn derive_struct_parameters(input: DeriveInput) -> syn::Result<TokenS
           node: &rclrs::NodeState,
           name: &str,
           default: Option<DefaultForbidden>,
+          description: impl Into<std::sync::Arc<str>>,
         )
           -> core::result::Result<Self, crate::DeclarationError> {
               core::result::Result::Ok(Self{ #(#args)*})