refactor(tools): separate metamodels and move serializers to tools/serialization

Author: melodyoncode

cpp/libclang/src/visitor/BUILD

@@ -25,8 +25,8 @@ rust_library(
     ],
     visibility = ["//cpp/libclang:__subpackages__"],
     deps = [
-        "//tools/metamodel:class_diagram",
-        "//tools/metamodel:sequence_diagram",
+        "//tools/metamodel/class:class_diagram",
+        "//tools/metamodel/sequence:sequence_diagram",
         "@crates//:clang",
         "@crates//:serde",
     ],

plantuml/linker/BUILD

@@ -18,7 +18,7 @@ rust_binary(
     crate_root = "src/main.rs",
     visibility = ["//visibility:public"],
     deps = [
-        "//plantuml/parser/puml_serializer/src/fbs:component_fbs",
+        "//tools/serialization/flatbuffers/component:component_fbs",
         "@crates//:clap",
         "@crates//:env_logger",
         "@crates//:flatbuffers",

plantuml/parser/README.md

@@ -86,4 +86,10 @@ Each diagram parser uses [pest](https://pest.rs/) PEG grammars to tokenize Plant
 then builds a typed AST. The CLI (`puml_cli`) dispatches to the appropriate parser based on
 `--diagram-type` or auto-detection.
 
+Shared model and serialization crates are split by responsibility:
+
+- `tools/metamodel/{class,component,sequence}` contains the logical model types.
+- `tools/serialization/flatbuffers/{class,component,sequence}` contains the FlatBuffers
+  schemas and serializer crates that produce `.fbs.bin` outputs.
+
 For the detailed design and users Guide, see `docs/README.md` in the source tree.

plantuml/parser/docs/README.md

@@ -52,7 +52,9 @@ The AST is resolved into a logical model by the `ComponentResolver`:
 
 #### 4. Serialization Phase
 
-The resolved logical model is serialized to FlatBuffers binary format by `ComponentSerializer` for further downstream processing.
+The resolved logical model is serialized to FlatBuffers binary format for further downstream processing.
+The logical model types live under `tools/metamodel/{class,component,sequence}`,
+while the FlatBuffers schemas and serializers live under `tools/serialization/flatbuffers/{class,component,sequence}`.
 
 **Example input**
 
@@ -132,10 +134,16 @@ Interface(
 | `puml_utils` | Shared utilities: `LogLevel` enum, file writing helpers |
 | `puml_parser` | Preprocessor (include expansion) + Class / Component / Sequence diagram parsers |
 | `puml_resolver` | Resolves raw AST into logical model (`ComponentResolver`, `DiagramResolver` trait) |
-| `puml_serializer` | FlatBuffers serialization of the resolved model (`ComponentSerializer`) |
 | `puml_lobster` | Converts the resolved model to LOBSTER traceability JSON |
 | `puml_cli` | CLI argument parsing and orchestration of all phases |
 
+### Shared Dependencies
+
+| Module | Responsibility |
+|---|---|
+| `tools/metamodel` | Shared logical model crates for class/component/sequence diagrams, consumed by the PlantUML parser, validation, and C++ tooling |
+| `tools/serialization/flatbuffers` | FlatBuffers schemas and serializer crates for class/component/sequence models |
+
 ### Architecture Diagrams
 
 **Class structure:**

plantuml/parser/integration_test/BUILD

@@ -25,7 +25,7 @@ rust_library(
         "//plantuml/parser/puml_parser",
         "//plantuml/parser/puml_resolver",
         "//plantuml/parser/puml_utils",
-        "//tools/metamodel:class_diagram",
+        "//tools/metamodel/class:class_diagram",
         "@crates//:serde",
         "@crates//:serde_json",
         "@crates//:serde_yaml",

plantuml/parser/integration_test/src/test_error_view.rs

@@ -17,7 +17,7 @@ use puml_parser::{
     ActivityParserError, BaseParseError, ClassError, IncludeExpandError, IncludeParseError,
     PreprocessError, ProcedureExpandError, ProcedureParseError,
 };
-use puml_resolver::{ActivityResolverError, ClassPumlResolverError, ElementResolverError};
+use puml_resolver::{ActivityResolverError, ClassPumlResolverError, ComponentResolverError};
 
 #[derive(Debug)]
 pub struct ProjectedError {
@@ -209,32 +209,32 @@ impl ErrorView for ActivityParserError {
     }
 }
 
-impl ErrorView for ElementResolverError {
+impl ErrorView for ComponentResolverError {
     fn project(&self, _base_dir: &Path) -> ProjectedError {
         match self {
-            ElementResolverError::UnresolvedReference { reference } => {
+            ComponentResolverError::UnresolvedReference { reference } => {
                 ProjectedError::new("UnresolvedReference")
                     .with_field("reference", reference.clone())
             }
 
-            ElementResolverError::DuplicateElement { element_id } => {
+            ComponentResolverError::DuplicateElement { element_id } => {
                 ProjectedError::new("DuplicateComponent")
                     .with_field("component_id", element_id.clone())
             }
 
-            ElementResolverError::UnknownElementType { element_type } => {
+            ComponentResolverError::UnknownElementType { element_type } => {
                 ProjectedError::new("UnknownComponentType")
                     .with_field("component_type", element_type.clone())
             }
 
-            ElementResolverError::InvalidRelationship { from, to, reason } => {
+            ComponentResolverError::InvalidRelationship { from, to, reason } => {
                 ProjectedError::new("InvalidRelationship")
                     .with_field("from", from.clone())
                     .with_field("to", to.clone())
                     .with_field("reason", reason.clone())
             }
 
-            ElementResolverError::AmbiguousReference {
+            ComponentResolverError::AmbiguousReference {
                 reference,
                 candidates,
             } => ProjectedError::new("AmbiguousReference")

plantuml/parser/puml_cli/BUILD

@@ -21,10 +21,13 @@ rust_binary(
         "//plantuml/parser/puml_lobster",
         "//plantuml/parser/puml_parser",
         "//plantuml/parser/puml_resolver",
-        "//plantuml/parser/puml_serializer",
         "//plantuml/parser/puml_utils",
-        "//tools/metamodel:class_diagram",
-        "//tools/metamodel:sequence_diagram",
+        "//tools/metamodel/class:class_diagram",
+        "//tools/metamodel/component:component_diagram",
+        "//tools/metamodel/sequence:sequence_diagram",
+        "//tools/serialization/flatbuffers/class:class_serializer",
+        "//tools/serialization/flatbuffers/component:component_serializer",
+        "//tools/serialization/flatbuffers/sequence:sequence_serializer",
         "@crates//:clap",
         "@crates//:env_logger",
         "@crates//:log",
@@ -40,10 +43,13 @@ rust_test(
         "//plantuml/parser/puml_lobster",
         "//plantuml/parser/puml_parser",
         "//plantuml/parser/puml_resolver",
-        "//plantuml/parser/puml_serializer",
         "//plantuml/parser/puml_utils",
-        "//tools/metamodel:class_diagram",
-        "//tools/metamodel:sequence_diagram",
+        "//tools/metamodel/class:class_diagram",
+        "//tools/metamodel/component:component_diagram",
+        "//tools/metamodel/sequence:sequence_diagram",
+        "//tools/serialization/flatbuffers/class:class_serializer",
+        "//tools/serialization/flatbuffers/component:component_serializer",
+        "//tools/serialization/flatbuffers/sequence:sequence_serializer",
         "@crates//:clap",
         "@crates//:env_logger",
         "@crates//:log",

plantuml/parser/puml_cli/src/main.rs

@@ -15,21 +15,21 @@ use clap::{ArgGroup, Parser, ValueEnum};
 use env_logger::Builder;
 use log::debug;
 use serde::Serialize;
-use std::collections::HashMap;
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::fs;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
 
+use class_serializer::ClassSerializer;
+use component_serializer::ComponentSerializer;
+use sequence_serializer::SequenceSerializer;
+
 use puml_lobster::{write_lobster_to_file, LobsterModel};
 use puml_parser::{
     DiagramParser, ErrorLocation, Preprocessor, PumlClassParser, PumlComponentParser,
     PumlSequenceParser,
 };
-use puml_resolver::{
-    ClassResolver, DiagramResolver, ElementResolver, LogicElement, SequenceResolver, SequenceTree,
-};
-use puml_serializer::{ClassSerializer, ComponentSerializer, SequenceSerializer};
+use puml_resolver::{ClassResolver, ComponentResolver, DiagramResolver, SequenceResolver};
 use puml_utils::{write_fbs_to_file, write_json_to_file, LogLevel};
 
 /// CLI wrapper for LogLevel that implements ValueEnum
@@ -222,17 +222,17 @@ fn serialize_resolved_diagram(resolved_content: &ResolvedDiagram, source_file: &
 
 #[derive(Debug, Serialize)]
 pub enum ResolvedDiagram {
-    Component(HashMap<String, LogicElement>),
+    Component(HashMap<String, component_diagram::LogicComponent>),
     Class(class_diagram::ClassDiagram),
-    Sequence(SequenceTree),
+    Sequence(sequence_logic::SequenceTree),
 }
 
 fn resolve_parsed_diagram(
     parsed_content: ParsedDiagram,
 ) -> Result<ResolvedDiagram, Box<dyn std::error::Error>> {
     match parsed_content {
         ParsedDiagram::Component(parsed_content) => {
-            let mut resolver = ElementResolver::new();
+            let mut resolver = ComponentResolver::new();
             puml_resolver(&mut resolver, &parsed_content).map(ResolvedDiagram::Component)
         }
         ParsedDiagram::Class(parsed_content) => {

plantuml/parser/puml_lobster/BUILD

@@ -18,8 +18,8 @@ rust_library(
     srcs = ["src/lib.rs"],
     visibility = ["//plantuml/parser:__subpackages__"],
     deps = [
-        "//plantuml/parser/puml_resolver",
-        "//tools/metamodel:class_diagram",
+        "//tools/metamodel/class:class_diagram",
+        "//tools/metamodel/component:component_diagram",
         "@crates//:serde_json",
     ],
 )

plantuml/parser/puml_lobster/src/lib.rs

@@ -14,10 +14,10 @@
 //! Converts the resolved PlantUML logical model into a `lobster-imp-trace`
 //! JSON file compatible with the LOBSTER traceability toolchain.
 //!
-//! Only [`ElementType::Interface`] elements are emitted
+//! Only [`ComponentType::Interface`] elements are emitted
 
 use class_diagram::{ClassDiagram, EntityType};
-use puml_resolver::{ElementType, LogicElement};
+use component_diagram::{ComponentType, LogicComponent};
 use serde_json::{json, Value};
 use std::collections::HashMap;
 use std::ffi::OsStr;
@@ -26,7 +26,7 @@ use std::io;
 use std::path::{Path, PathBuf};
 
 pub enum LobsterModel<'a> {
-    Component(&'a HashMap<String, LogicElement>),
+    Component(&'a HashMap<String, LogicComponent>),
     Class(&'a ClassDiagram),
     Empty,
 }
@@ -36,10 +36,10 @@ pub enum LobsterModel<'a> {
 ///
 /// `source_path` is embedded in the `location.file` field of every emitted
 /// item so that LOBSTER can trace items back to their source diagram.
-fn comp_model_to_lobster(model: &HashMap<String, LogicElement>, source_path: &str) -> Value {
+fn comp_model_to_lobster(model: &HashMap<String, LogicComponent>, source_path: &str) -> Value {
     let items: Vec<Value> = model
         .values()
-        .filter(|element| element.element_type == ElementType::Interface)
+        .filter(|element| element.element_type == ComponentType::Interface)
         .map(|element| build_lobster_item(&element.id, source_path, None, "Interface"))
         .collect();