Merge pull request #580 from swimos/transient-agents

Allows the 'transient' flag to be applied to an entire agent.

Author: SirCipher

macro_utilities/src/names/mod.rs

@@ -62,6 +62,22 @@ pub enum TypeLevelNameTransform {
     Convention(CaseConvention),
 }
 
+impl From<CaseConvention> for TypeLevelNameTransform {
+    fn from(value: CaseConvention) -> Self {
+        TypeLevelNameTransform::Convention(value)
+    }
+}
+
+impl From<Option<CaseConvention>> for TypeLevelNameTransform {
+    fn from(value: Option<CaseConvention>) -> Self {
+        if let Some(conv) = value {
+            TypeLevelNameTransform::Convention(conv)
+        } else {
+            TypeLevelNameTransform::Identity
+        }
+    }
+}
+
 impl TypeLevelNameTransform {
     pub fn is_identity(&self) -> bool {
         matches!(self, TypeLevelNameTransform::Identity)

server/swim_agent_derive/src/lane_model_derive/attributes/mod.rs

@@ -32,6 +32,8 @@ const ROOT_ATTR_NAME: &str = "root";
 const INVALID_FIELD_ATTR: &str = "Invalid field attribute.";
 const INVALID_AGENT_ROOT: &str = "Invalid agent root specifier.";
 
+struct TransientFlag;
+
 /// Attribute consumer to recognize the transient flag for agent items.
 struct TransientFlagConsumer;
 
@@ -43,14 +45,14 @@ pub enum ItemAttr {
     Transform(Transformation),
 }
 
-impl NestedMetaConsumer<ItemAttr> for TransientFlagConsumer {
-    fn try_consume(&self, meta: &syn::NestedMeta) -> Result<Option<ItemAttr>, syn::Error> {
+impl NestedMetaConsumer<TransientFlag> for TransientFlagConsumer {
+    fn try_consume(&self, meta: &syn::NestedMeta) -> Result<Option<TransientFlag>, syn::Error> {
         match meta {
             syn::NestedMeta::Meta(syn::Meta::Path(path)) => match path.segments.first() {
                 Some(seg) => {
                     if seg.ident == TRANSIENT_ATTR_NAME {
                         if path.segments.len() == 1 && seg.arguments.is_empty() {
-                            Ok(Some(ItemAttr::Transient))
+                            Ok(Some(TransientFlag))
                         } else {
                             Err(syn::Error::new_spanned(meta, INVALID_FIELD_ATTR))
                         }
@@ -68,7 +70,7 @@ impl NestedMetaConsumer<ItemAttr> for TransientFlagConsumer {
 pub fn make_item_attr_consumer() -> impl NestedMetaConsumer<ItemAttr> {
     let trans_consumer = NameTransformConsumer::new(RENAME_TAG, CONV_TAG);
     hlist![
-        TransientFlagConsumer,
+        TransientFlagConsumer.map(|_| ItemAttr::Transient),
         trans_consumer.map(ItemAttr::Transform)
     ]
 }
@@ -108,6 +110,8 @@ pub fn combine_item_attrs(
 
 /// Types of modification that can be applied to an agent using attributes.
 pub enum AgentAttr {
+    /// Mark all items of the agent as transient.
+    Transient,
     /// Module path where the types from the `swim_agent` create can be found.
     Root(syn::Path),
     /// Renaming convention to apply to all items of the agent.
@@ -141,6 +145,7 @@ impl NestedMetaConsumer<AgentAttr> for RootConsumer {
 pub fn make_agent_attr_consumer() -> impl NestedMetaConsumer<AgentAttr> {
     let trans_consumer = TypeLevelNameTransformConsumer::new(CONV_TAG);
     hlist![
+        TransientFlagConsumer.map(|_| AgentAttr::Transient),
         RootConsumer,
         trans_consumer.map(AgentAttr::RenameConvention)
     ]
@@ -149,6 +154,8 @@ pub fn make_agent_attr_consumer() -> impl NestedMetaConsumer<AgentAttr> {
 /// Modifications to an agent, defined by attributes attached to it.
 #[derive(Debug)]
 pub struct AgentModifiers {
+    /// Mark all items of the agent as transient.
+    pub transient: bool,
     /// Renaming strategy for all items of the agent.
     pub transform: Option<CaseConvention>,
     /// Module path where the types from the `swim_agent` create can be found.
@@ -162,6 +169,7 @@ fn default_root() -> syn::Path {
 impl Default for AgentModifiers {
     fn default() -> Self {
         Self {
+            transient: false,
             transform: None,
             root: default_root(),
         }
@@ -180,6 +188,7 @@ pub fn combine_agent_attrs(
         |mut modifiers, attr| {
             let mut errors = Errors::empty();
             match attr {
+                AgentAttr::Transient => modifiers.transient = true,
                 AgentAttr::Root(path) => modifiers.root = path,
                 AgentAttr::RenameConvention(conv) => {
                     if modifiers.transform.is_some() {

server/swim_agent_derive/src/lane_model_derive/mod.rs

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use macro_utilities::TypeLevelNameTransform;
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens, TokenStreamExt};
 use swim_utilities::errors::{validation::Validation, Errors};
@@ -40,10 +39,12 @@ impl<'a> DeriveAgentLaneModel<'a> {
         modifiers: AgentModifiers,
         mut model: LanesModel<'a>,
     ) -> Validation<Self, Errors<syn::Error>> {
-        let AgentModifiers { transform, root } = modifiers;
-        if let Some(convention) = transform {
-            model.apply_transform(TypeLevelNameTransform::Convention(convention));
-        }
+        let AgentModifiers {
+            transient,
+            transform,
+            root,
+        } = modifiers;
+        model.apply_modifiers(transient, transform.into());
         if let Err(err) = model.check_names(src) {
             Validation::Validated(DeriveAgentLaneModel { root, model }, Errors::of(err))
         } else {

server/swim_agent_derive/src/lane_model_derive/model.rs

@@ -45,10 +45,23 @@ impl<'a> LanesModel<'a> {
         LanesModel { agent_type, lanes }
     }
 
-    /// Apply a name transform to all items.
-    pub fn apply_transform(&mut self, type_transform: TypeLevelNameTransform) {
-        for ItemModel { transform, .. } in &mut self.lanes {
+    /// Apply global transformations to all lanes.
+    pub fn apply_modifiers(
+        &mut self,
+        set_transient_flag: bool,
+        type_transform: TypeLevelNameTransform,
+    ) {
+        let add_flags = if set_transient_flag {
+            ItemFlags::TRANSIENT
+        } else {
+            ItemFlags::empty()
+        };
+        for ItemModel {
+            transform, flags, ..
+        } in &mut self.lanes
+        {
             *transform = type_transform.resolve(std::mem::take(transform));
+            flags.insert(add_flags);
         }
     }
 

swim/tests/deriveagentlanemodel.rs

@@ -737,3 +737,22 @@ fn override_top_level_convention() {
         persistent_lane_renamed(2, "thirdLane", "third_lane", WarpLaneKind::Value),
     ]);
 }
+
+#[test]
+fn agent_level_transient_flag() {
+    #[derive(AgentLaneModel)]
+    #[agent(transient)]
+    struct EverythingTransient {
+        first: ValueLane<i32>,
+        second: MapLane<i32, i32>,
+        third: CommandLane<i32>,
+        fourth: ValueStore<i32>,
+    }
+
+    check_agent::<EverythingTransient>(vec![
+        transient_lane(0, "first", WarpLaneKind::Value),
+        transient_lane(1, "second", WarpLaneKind::Map),
+        transient_lane(2, "third", WarpLaneKind::Command),
+        transient_store(3, "fourth", StoreKind::Value),
+    ]);
+}