serialize relationship in component diagram

melodyoncode · hoe-jo · commit 32ee3cb0dc1a · 2026-06-10T16:03:44.000+02:00
diff --git a/plantuml/parser/integration_test/src/test_error_view.rs b/plantuml/parser/integration_test/src/test_error_view.rs
@@ -240,7 +240,6 @@ impl ErrorView for ElementResolverError {
             } => ProjectedError::new("AmbiguousReference")
                 .with_field("reference", reference.clone())
                 .with_field("candidates", candidates.join(", ")),
-
         }
     }
 }
diff --git a/plantuml/parser/puml_resolver/src/component_diagram/src/component_relations.md b/plantuml/parser/puml_resolver/src/component_diagram/src/component_relations.md
@@ -1,3 +1,16 @@
+<!-- ----------------------------------------------------------------------------
+  Copyright (c) 2026 Contributors to the Eclipse Foundation
+
+  See the NOTICE file(s) distributed with this work for additional
+  information regarding copyright ownership.
+
+  This program and the accompanying materials are made available under the
+  terms of the Apache License Version 2.0 which is available at
+  https://www.apache.org/licenses/LICENSE-2.0
+
+  SPDX-License-Identifier: Apache-2.0
+----------------------------------------------------------------------------- -->
+
 ### Supported component relations
 
 - Association (no direction):
diff --git a/plantuml/parser/puml_resolver/src/component_diagram/src/component_resolver.rs b/plantuml/parser/puml_resolver/src/component_diagram/src/component_resolver.rs
@@ -183,11 +183,7 @@ impl ElementResolver {
                 continue;
             };
 
-            let Some(name) = element
-                .alias
-                .as_deref()
-                .or_else(|| element.name.as_deref())
-            else {
+            let Some(name) = element.alias.as_deref().or(element.name.as_deref()) else {
                 continue;
             };
 
@@ -208,7 +204,8 @@ impl ElementResolver {
         if parts.len() == 1 {
             for i in (0..=self.scope.len()).rev() {
                 let outer_scope = &self.scope[..i];
-                let matches = self.collect_matching_port_fqns_in_scope_or_children(outer_scope, raw);
+                let matches =
+                    self.collect_matching_port_fqns_in_scope_or_children(outer_scope, raw);
                 if !matches.is_empty() {
                     // Keep nearest-scope matches only for simple names.
                     candidates.extend(matches);
@@ -254,7 +251,8 @@ impl ElementResolver {
 
         for pfqn in &candidates {
             let ok = pfqn == resolved
-                || self.port_parents
+                || self
+                    .port_parents
                     .get(pfqn)
                     .map(|p| p == resolved)
                     .unwrap_or(false);
@@ -342,8 +340,7 @@ impl ElementResolver {
 
         // 2) lexical port lookup (collapsed to parent component)
         if let Some(res) = self.walk_scopes_nearest_first(|scope| {
-            let ports =
-                self.collect_matching_port_fqns_in_scope_or_children(scope, name);
+            let ports = self.collect_matching_port_fqns_in_scope_or_children(scope, name);
 
             if ports.is_empty() {
                 return Ok(None);
@@ -366,32 +363,22 @@ impl ElementResolver {
         let global: Vec<String> = self
             .elements
             .values()
-            .filter(|e| {
-                e.alias.as_deref() == Some(name)
-                    || e.name.as_deref() == Some(name)
-            })
+            .filter(|e| e.alias.as_deref() == Some(name) || e.name.as_deref() == Some(name))
             .map(|e| e.id.clone())
             .collect::<std::collections::BTreeSet<_>>()
             .into_iter()
             .collect();
 
-        Ok(Self::pick_unique(global, raw)?)
+        Self::pick_unique(global, raw)
     }
 
-    fn resolve_relative(
-        &self,
-        parts: &[&str],
-    ) -> Result<Option<String>, ElementResolverError> {
-        let matches =
-            self.collect_element_fqns_in_scope_or_children(&self.scope, parts);
+    fn resolve_relative(&self, parts: &[&str]) -> Result<Option<String>, ElementResolverError> {
+        let matches = self.collect_element_fqns_in_scope_or_children(&self.scope, parts);
 
-        Ok(Self::pick_unique(matches, &parts.join("."))?)
+        Self::pick_unique(matches, &parts.join("."))
     }
 
-    fn walk_scopes_nearest_first<F>(
-        &self,
-        mut f: F,
-    ) -> Result<Option<String>, ElementResolverError>
+    fn walk_scopes_nearest_first<F>(&self, mut f: F) -> Result<Option<String>, ElementResolverError>
     where
         F: FnMut(&[String]) -> Result<Option<String>, ElementResolverError>,
     {
@@ -504,24 +491,8 @@ impl ElementResolver {
 
     fn validate_relation_constraints(
         &self,
-        relation: &Relation,
-        has_interface_tokens: bool,
-        src_is_interface: bool,
-        tgt_is_interface: bool,
-        src_is_component: bool,
-        decor_role: Option<EndpointRole>,
-        src_port_role: Option<EndpointRole>,
+        input: &RelationValidationInput<'_>,
     ) -> Result<(), ElementResolverError> {
-        let input = RelationValidationInput {
-            relation,
-            has_interface_tokens,
-            src_is_interface,
-            tgt_is_interface,
-            src_is_component,
-            decor_role,
-            src_port_role,
-        };
-
         let rules: [RelationValidationRule; 5] = [
             Self::rule_require_exactly_one_interface_endpoint,
             Self::rule_disallow_interface_to_interface,
@@ -531,7 +502,7 @@ impl ElementResolver {
         ];
 
         for rule in rules {
-            if let Some(err) = rule(&input) {
+            if let Some(err) = rule(input) {
                 return Err(err);
             }
         }
@@ -540,58 +511,53 @@ impl ElementResolver {
     }
 
     fn rule_require_exactly_one_interface_endpoint(
-        input: &RelationValidationInput<'_>
+        input: &RelationValidationInput<'_>,
     ) -> Option<ElementResolverError> {
-        if input.has_interface_tokens
-            && !input.src_is_interface
-            && !input.tgt_is_interface
-        {
+        if input.has_interface_tokens && !input.src_is_interface && !input.tgt_is_interface {
             return Some(ElementResolverError::InvalidRelationship {
                 from: input.relation.lhs.clone(),
                 to: input.relation.rhs.clone(),
-                reason:
-                    "Interface decorators '-(' and ')-' require exactly one Interface endpoint"
-                        .to_string(),
+                reason: "Interface decorators '-(' and ')-' require exactly one Interface endpoint"
+                    .to_string(),
             });
         }
         None
     }
 
     fn rule_disallow_interface_to_interface(
-        input: &RelationValidationInput<'_>
+        input: &RelationValidationInput<'_>,
     ) -> Option<ElementResolverError> {
-        if input.has_interface_tokens
-            && input.src_is_interface
-            && input.tgt_is_interface
-        {
+        if input.has_interface_tokens && input.src_is_interface && input.tgt_is_interface {
             return Some(ElementResolverError::InvalidRelationship {
                 from: input.relation.lhs.clone(),
                 to: input.relation.rhs.clone(),
-                reason:
-                    "Interface decorators '-(' and ')-' are not allowed between two interfaces"
-                        .to_string(),
+                reason: "Interface decorators '-(' and ')-' are not allowed between two interfaces"
+                    .to_string(),
             });
         }
         None
     }
 
     fn rule_require_component_endpoint_for_binding(
-        input: &RelationValidationInput<'_>
+        input: &RelationValidationInput<'_>,
     ) -> Option<ElementResolverError> {
-        if input.has_interface_tokens && input.decor_role.is_some() {
-            if !input.src_is_component || !input.tgt_is_interface {
-                return Some(ElementResolverError::InvalidRelationship {
-                    from: input.relation.lhs.clone(),
-                    to: input.relation.rhs.clone(),
-                    reason: "Decorator binding only allows Component on the left and Interface on the right".to_string(),
-                });
-            }
+        if input.has_interface_tokens
+            && input.decor_role.is_some()
+            && (!input.src_is_component || !input.tgt_is_interface)
+        {
+            return Some(ElementResolverError::InvalidRelationship {
+                from: input.relation.lhs.clone(),
+                to: input.relation.rhs.clone(),
+                reason:
+                    "Decorator binding only allows Component on the left and Interface on the right"
+                        .to_string(),
+            });
         }
         None
     }
 
     fn rule_disallow_generic_decor_with_direction(
-        input: &RelationValidationInput<'_>
+        input: &RelationValidationInput<'_>,
     ) -> Option<ElementResolverError> {
         if input.has_interface_tokens
             && input.decor_role.is_none()
@@ -608,11 +574,9 @@ impl ElementResolver {
     }
 
     fn rule_port_role_consistency(
-        input: &RelationValidationInput<'_>
+        input: &RelationValidationInput<'_>,
     ) -> Option<ElementResolverError> {
-        if let (Some(port_role), Some(decor_role)) =
-            (input.src_port_role, input.decor_role)
-        {
+        if let (Some(port_role), Some(decor_role)) = (input.src_port_role, input.decor_role) {
             if port_role != decor_role {
                 return Some(ElementResolverError::InvalidRelationship {
                     from: input.relation.lhs.clone(),
@@ -646,15 +610,18 @@ impl ElementResolver {
         let tgt_is_interface = matches!(tgt_type, Some(ElementType::Interface));
         let src_is_component = matches!(src_type, Some(ElementType::Component));
 
-        self.validate_relation_constraints(
+        let validation_input = RelationValidationInput {
             relation,
-            parsed_arrow.has_provided_token || parsed_arrow.has_required_token,
+            has_interface_tokens: parsed_arrow.has_provided_token
+                || parsed_arrow.has_required_token,
             src_is_interface,
             tgt_is_interface,
             src_is_component,
-            parsed_arrow.decor_role,
+            decor_role: parsed_arrow.decor_role,
             src_port_role,
-        )?;
+        };
+
+        self.validate_relation_constraints(&validation_input)?;
 
         let relation_type = Self::infer_relation_type(&parsed_arrow);
 
diff --git a/plantuml/parser/puml_resolver/src/component_diagram/src/lib.rs b/plantuml/parser/puml_resolver/src/component_diagram/src/lib.rs
@@ -15,7 +15,7 @@ mod component_logic;
 mod component_resolver;
 
 pub use component_logic::{
-    ComponentResolverError, ComponentType, ElementResolverError, ElementType, LogicComponent,
-    LogicElement,
+    ComponentRelationType, ComponentResolverError, ComponentType, ElementResolverError,
+    ElementType, EndpointRole, LogicComponent, LogicElement,
 };
 pub use component_resolver::{ComponentResolver, ElementResolver};
diff --git a/plantuml/parser/puml_serializer/src/fbs/component.fbs b/plantuml/parser/puml_serializer/src/fbs/component.fbs
@@ -13,10 +13,23 @@
 
 namespace component;
 
+enum ComponentRelationType:byte {
+  Association,
+  Dependency,
+  InterfaceBinding
+}
+
+enum EndpointRole:byte {
+  None,
+  Provided,
+  Required
+}
+
 table LogicRelation {
   target:string;
   annotation:string;
-  relation_type:string;
+  relation_type:ComponentRelationType = Association;
+  source_role:EndpointRole = None;
 }
 
 enum ComponentType:byte {
diff --git a/plantuml/parser/puml_serializer/src/serialize/component_serializer.rs b/plantuml/parser/puml_serializer/src/serialize/component_serializer.rs
@@ -15,7 +15,7 @@ use flatbuffers::FlatBufferBuilder;
 use std::collections::HashMap;
 
 use component_fbs::component as fb;
-use component_resolver::{ElementType, LogicElement};
+use component_resolver::{ComponentRelationType, ElementType, EndpointRole, LogicElement};
 
 pub struct ComponentSerializer;
 
@@ -34,14 +34,14 @@ impl ComponentSerializer {
             for r in &element.relations {
                 let target_offset = builder.create_string(&r.target);
                 let annotation_offset = r.annotation.as_ref().map(|s| builder.create_string(s));
-                let relation_type_offset = builder.create_string(&r.relation_type);
 
                 let rel = fb::LogicRelation::create(
                     &mut builder,
                     &fb::LogicRelationArgs {
                         target: Some(target_offset),
                         annotation: annotation_offset,
-                        relation_type: Some(relation_type_offset),
+                        relation_type: Self::convert_relation_type(r.relation_type),
+                        source_role: Self::convert_endpoint_role(r.source_role),
                     },
                 );
                 relation_offsets.push(rel);
@@ -136,4 +136,20 @@ impl ComponentSerializer {
             ElementType::Usecase => fb::ComponentType::Usecase,
         }
     }
+
+    fn convert_relation_type(relation_type: ComponentRelationType) -> fb::ComponentRelationType {
+        match relation_type {
+            ComponentRelationType::Association => fb::ComponentRelationType::Association,
+            ComponentRelationType::Dependency => fb::ComponentRelationType::Dependency,
+            ComponentRelationType::InterfaceBinding => fb::ComponentRelationType::InterfaceBinding,
+        }
+    }
+
+    fn convert_endpoint_role(source_role: EndpointRole) -> fb::EndpointRole {
+        match source_role {
+            EndpointRole::None => fb::EndpointRole::None,
+            EndpointRole::Provided => fb::EndpointRole::Provided,
+            EndpointRole::Required => fb::EndpointRole::Required,
+        }
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -240,7 +240,6 @@ impl ErrorView for ElementResolverError {`
`240`	`240`	`} => ProjectedError::new("AmbiguousReference")`
`241`	`241`	`.with_field("reference", reference.clone())`
`242`	`242`	`.with_field("candidates", candidates.join(", ")),`
`243`		`-`
`244`	`243`	`}`
`245`	`244`	`}`
`246`	`245`	`}`