lutaml 0.10.4 → 0.10.6

data/lib/lutaml/qea/factory/class_transformer.rb

@@ -6,95 +6,60 @@ require_relative "operation_transformer"
 require_relative "constraint_transformer"
 require_relative "tagged_value_transformer"
 require_relative "object_property_transformer"
-require_relative "generalization_transformer"
-require_relative "association_transformer"
+require_relative "stereotype_loader"
+require_relative "generalization_builder"
+require_relative "association_builder"
 require "lutaml/uml"
 
 module Lutaml
   module Qea
     module Factory
-      # Transforms EA objects (Class type) to UML classes
       class ClassTransformer < BaseTransformer
-        # Transform EA object to UML class
-        # @param ea_object [EaObject] EA object model
-        # @return [Lutaml::Uml::Class] UML class
-        def transform(ea_object) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        def transform(ea_object)
           return nil if ea_object.nil?
 
-          # Allow Class, Interface, ProxyConnector, and Text objects
           is_class_type = ea_object.uml_class? || ea_object.interface?
           is_proxy = ea_object.object_type == "ProxyConnector"
           is_text_class = ea_object.object_type == "Text"
           return nil unless is_class_type || is_proxy || is_text_class
 
-          Lutaml::Uml::Class.new.tap do |klass| # rubocop:disable Metrics/BlockLength
-            # Map basic properties
+          Lutaml::Uml::Class.new.tap do |klass|
             klass.name = ea_object.name
             klass.xmi_id = normalize_guid_to_xmi_format(ea_object.ea_guid,
                                                         "EAID")
             klass.is_abstract = ea_object.abstract?
-            # Text objects exported as Class in XMI
             klass.type = "Class"
             klass.visibility = map_visibility(ea_object.visibility)
 
-            # Map stereotype - return string if single, array if multiple
-            stereotypes = []
-            if ea_object.stereotype && !ea_object.stereotype.empty?
-              stereotypes << ea_object.stereotype
-            end
+            stereotypes = build_stereotypes(ea_object)
+            klass.stereotype = stereotypes unless stereotypes.empty?
 
-            # Check t_xref for additional stereotypes
-            # (only if not already added)
-            xref_stereotype = load_stereotype_from_xref(ea_object.ea_guid)
-            if xref_stereotype && !stereotypes.include?(xref_stereotype)
-              stereotypes << xref_stereotype
-            end
-
-            # Assign stereotypes (always as array for collection: true)
-            unless stereotypes.empty?
-              klass.stereotype = stereotypes
-            end
-
-            # Add "interface" stereotype if it's an interface
-            if ea_object.interface? && !klass.stereotype.include?("interface")
-              klass.stereotype << "interface"
-            end
-
-            # Map definition/notes
             klass.definition = normalize_line_endings(ea_object.note) unless
               ea_object.note.nil? || ea_object.note.empty?
 
-            # Load and transform attributes
+            gen_builder = GeneralizationBuilder.new(database)
+            assoc_builder = AssociationBuilder.new(database)
+
             attrs = load_attributes(ea_object.ea_object_id)
-            assoc_attrs = convert_to_top_element_attributes(
-              load_association_attributes(ea_object.ea_object_id),
+            assoc_attrs = gen_builder.convert_to_top_element_attributes(
+              assoc_builder.load_association_attributes(ea_object.ea_object_id),
             )
             klass.attributes = attrs + assoc_attrs
 
-            # Load and transform operations
             klass.operations = load_operations(ea_object.ea_object_id)
-
-            # Load and transform constraints
             klass.constraints = load_constraints(ea_object.ea_object_id)
-
-            # Load and transform tagged values
             klass.tagged_values = load_tagged_values(ea_object.ea_guid)
-
-            # Load and transform object properties (as additional tagged values)
             klass.tagged_values.concat(
               load_object_properties(ea_object.ea_object_id),
             )
 
-            # Load generalization (inheritance)
-            klass.generalization = load_generalization(ea_object.ea_object_id)
-
-            # Load association generalizations
-            klass.association_generalization = load_association_generalizations(
+            klass.generalization = gen_builder.load_generalization(
               ea_object.ea_object_id,
             )
+            klass.association_generalization = gen_builder
+              .load_association_generalizations(ea_object.ea_object_id)
 
-            # Load associations for this class
-            klass.associations = load_class_associations(
+            klass.associations = assoc_builder.load_class_associations(
               ea_object.ea_object_id, ea_object.ea_guid
             )
           end
@@ -102,584 +67,69 @@ module Lutaml
 
         private
 
-        # Load and transform attributes for a class
-        # @param object_id [Integer] Object ID
-        # @return [Array<Lutaml::Uml::TopElementAttribute>] UML attributes
+        def build_stereotypes(ea_object)
+          stereotypes = []
+          if ea_object.stereotype && !ea_object.stereotype.empty?
+            stereotypes << ea_object.stereotype
+          end
+
+          xref_stereotype = StereotypeLoader.new(database)
+            .load_from_xref(ea_object.ea_guid)
+          if xref_stereotype && !stereotypes.include?(xref_stereotype)
+            stereotypes << xref_stereotype
+          end
+
+          if ea_object.interface? && !stereotypes.include?("interface")
+            stereotypes << "interface"
+          end
+
+          stereotypes
+        end
+
         def load_attributes(object_id)
           return [] if object_id.nil?
 
           ea_attributes = database.attributes_for_object(object_id)
             .sort_by { |a| a.pos || 0 }
-
-          attribute_transformer = AttributeTransformer.new(database)
-          attribute_transformer.transform_collection(ea_attributes)
+          AttributeTransformer.new(database).transform_collection(ea_attributes)
         end
 
-        # Load and transform operations for a class
-        # @param object_id [Integer] Object ID
-        # @return [Array<Lutaml::Uml::Operation>] UML operations
         def load_operations(object_id)
           return [] if object_id.nil?
 
           ea_operations = database.operations_for_object(object_id)
             .sort_by { |op| op.pos || 0 }
-
-          operation_transformer = OperationTransformer.new(database)
-          operation_transformer.transform_collection(ea_operations)
+          OperationTransformer.new(database).transform_collection(ea_operations)
         end
 
-        # Load and transform constraints for a class
-        # @param object_id [Integer] Object ID
-        # @return [Array<Lutaml::Uml::Constraint>] UML constraints
         def load_constraints(object_id)
           return [] if object_id.nil?
           return [] unless database.object_constraints
 
-          # Filter constraints for this object from the in-memory collection
           ea_constraints = database.object_constraints.select do |c|
             c.ea_object_id == object_id
           end
-
-          # Transform to UML constraints
-          constraint_transformer = ConstraintTransformer.new(database)
-          constraint_transformer.transform_collection(ea_constraints)
+          ConstraintTransformer.new(database).transform_collection(ea_constraints)
         end
 
-        # Load and transform tagged values for a class
-        # @param ea_guid [String] Element GUID
-        # @return [Array<Lutaml::Uml::TaggedValue>] UML tagged values
         def load_tagged_values(ea_guid)
           return [] if ea_guid.nil?
           return [] unless database.tagged_values
 
-          # Filter tagged values for this element from the in-memory collection
           ea_tags = database.tagged_values.select do |tag|
             tag.element_id == ea_guid
           end
-
-          # Transform to UML tagged values
-          tag_transformer = TaggedValueTransformer.new(database)
-          tag_transformer.transform_collection(ea_tags)
+          TaggedValueTransformer.new(database).transform_collection(ea_tags)
         end
 
-        # Load and transform object properties for a class
-        # @param object_id [Integer] Object ID
-        # @return [Array<Lutaml::Uml::TaggedValue>] UML tagged values
         def load_object_properties(object_id)
           return [] if object_id.nil?
           return [] unless database.object_properties
 
-          # Filter object properties for this object from the in-memory
-          # collection
           ea_props = database.object_properties.select do |prop|
             prop.ea_object_id == object_id
           end
-
-          # Transform to UML tagged values
-          prop_transformer = ObjectPropertyTransformer.new(database)
-          prop_transformer.transform_collection(ea_props)
-        end
-
-        # Load stereotype from t_xref table
-        # @param ea_guid [String] Element GUID
-        # @return [String, nil] Stereotype value
-        def load_stereotype_from_xref(ea_guid) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          return nil if ea_guid.nil?
-          return nil unless database.xrefs
-
-          # Find stereotype xref from the in-memory collection
-          xref = database.xrefs.find do |x|
-            x.client == ea_guid && x.name == "Stereotypes" &&
-              x.type == "element property"
-          end
-
-          return nil unless xref
-
-          # Parse stereotype from Description field
-          # Format: @STEREO;Name=FeatureType;FQName=...;@ENDSTEREO;
-          description = xref.description
-          return nil if description.nil? || description.empty?
-
-          # Extract the Name value from the @STEREO format
-          if description =~ /@STEREO;Name=([^;]+);/
-            return $1
-          end
-
-          nil
-        end
-
-        # Load generalization for a class
-        # @param object_id [Integer] Object ID
-        # @param visited [Set] Set of visited object IDs to prevent
-        # circular references
-        # @param is_leaf [Boolean] Whether this is the leaf class
-        # (not a parent in recursion)
-        # @return [Lutaml::Uml::Generalization, nil] UML generalization or nil
-        def load_generalization(object_id, visited = Set.new, is_leaf = true) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity,Style/OptionalBooleanParameter
-          return nil if object_id.nil?
-
-          # Detect circular reference
-          if visited.include?(object_id)
-            warn "Circular inheritance detected for object_id #{object_id}, " \
-                 "stopping recursion"
-            return nil
-          end
-
-          # Add current object to visited set
-          visited = visited.dup.add(object_id)
-
-          # 1. Load CURRENT object
-          current_obj = find_object_by_id(object_id)
-          return nil unless current_obj
-
-          # 2. Find generalization connector where this class is the subtype
-          ea_connector = database.connectors_for_object(object_id)
-            .find { |c| c.generalization? && c.start_object_id == object_id }
-
-          # 3. Create generalization object for current class
-          # Even if no parent exists, we need a Generalization
-          # representing this class
-          gen_transformer = GeneralizationTransformer.new(database)
-          generalization = if ea_connector.nil?
-            # No parent - create terminal generalization
-            gen_transformer.transform(nil, current_obj)
-          else
-            # Has parent - create generalization with parent connector
-            gen_transformer
-              .transform(ea_connector, current_obj)
-                           end
-          return nil unless generalization
-
-          # 4. Load CURRENT object attributes and convert to GeneralAttribute
-          current_attrs = load_attributes(object_id)
-          current_assoc_attrs = load_association_attributes(object_id)
-          general_attrs = convert_to_general_attributes(
-            current_attrs + current_assoc_attrs,
-          )
-
-          # Set gen_name and name_ns on general_attributes
-          # (matches current class context)
-          upper_klass = generalization.general_upper_klass
-          gen_name = generalization.general_name
-          general_attrs.each do |attr|
-            attr.gen_name = gen_name
-            # Determine name_ns based on type_ns
-            # (same logic as transform_general_attributes)
-            name_ns = case attr.type_ns
-                      when "core", "gml"
-                        upper_klass
-                      else
-                        attr.type_ns
-                      end
-            attr.name_ns = name_ns || upper_klass
-          end
-
-          generalization.general_attributes = general_attrs
-            .sort_by { |a| [a.name.to_s, a.id] }
-
-          # 5. Transform attributes (set name_ns, gen_name) -
-          # creates working copies
-          generalization.attributes = transform_general_attributes(
-            generalization,
-          )
-
-          # 6. Partition into owned_props and assoc_props
-          generalization.owned_props = generalization.attributes
-            .reject(&:has_association)
-          generalization.assoc_props = generalization.attributes
-            .select(&:has_association)
-
-          # 7. Recursively load PARENT generalization with circular
-          # reference detection
-          # Pass is_leaf=false so parent doesn't populate inherited_props
-          parent_object_id = ea_connector&.end_object_id
-          if parent_object_id
-            parent_gen = load_generalization(parent_object_id, visited, false)
-            if parent_gen
-              generalization.general = parent_gen
-              generalization.has_general = true
-            end
-          end
-
-          # 8. Collect inherited properties from ancestor chain
-          # Only populate inherited_props at the LEAF level
-          # (matches XMI behavior)
-          if is_leaf && generalization.has_general
-            collect_inherited_properties(generalization)
-          end
-
-          generalization
-        end
-
-        # Convert TopElementAttribute array to GeneralAttribute array
-        # @param attributes [Array<Lutaml::Uml::TopElementAttribute>]
-        # @return [Array<Lutaml::Uml::GeneralAttribute>]
-        def convert_to_general_attributes(attributes) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          attributes.map do |attr|
-            Lutaml::Uml::GeneralAttribute.new.tap do |gen_attr|
-              gen_attr.id = attr.id
-              gen_attr.name = attr.name
-              gen_attr.type = attr.type
-              gen_attr.xmi_id = attr.xmi_id
-              gen_attr.is_derived = !!attr.is_derived
-              gen_attr.cardinality = attr.cardinality
-              gen_attr.definition = attr.definition&.strip
-              gen_attr.association = attr.association
-              gen_attr.has_association = !!attr.association
-              gen_attr.type_ns = attr.type_ns
-            end
-          end
-        end
-
-        # Convert GeneralAttribute array to TopElementAttribute array
-        # @param attributes [Array<Lutaml::Uml::TopElementAttribute>]
-        # @return [Array<Lutaml::Uml::TopElementAttribute>]
-        def convert_to_top_element_attributes(attributes) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          attributes.map do |attr|
-            Lutaml::Uml::TopElementAttribute.new.tap do |top_attr|
-              top_attr.id = attr.id
-              top_attr.name = attr.name
-              top_attr.type = attr.type
-              top_attr.xmi_id = attr.xmi_id
-              top_attr.cardinality = attr.cardinality
-              top_attr.definition = attr.definition&.strip
-              top_attr.association = attr.association
-              top_attr.type_ns = attr.type_ns
-              top_attr.is_derived = !!attr.is_derived
-            end
-          end
-        end
-
-        # Transform GeneralAttributes with context (name_ns, gen_name)
-        # Similar to XMI's create_uml_attributes
-        # @param generalization [Lutaml::Uml::Generalization]
-        # @return [Array<Lutaml::Uml::GeneralAttribute>]
-        def transform_general_attributes(generalization) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          upper_klass = generalization.general_upper_klass
-          gen_name = generalization.general_name
-          gen_attrs = generalization.general_attributes
-
-          gen_attrs.map do |attr|
-            # Clone to avoid mutation
-            transformed = attr.dup
-
-            # Set name_ns based on type_ns
-            name_ns = case attr.type_ns
-                      when "core", "gml"
-                        upper_klass
-                      else
-                        attr.type_ns
-                      end
-            name_ns = upper_klass if name_ns.nil?
-
-            transformed.name_ns = name_ns
-            transformed.gen_name = gen_name
-            transformed.name = "" if transformed.name.nil?
-
-            transformed
-          end
-        end
-
-        # Collect inherited properties from ancestor chain
-        # Similar to XMI's loop_general_item
-        # @param generalization [Lutaml::Uml::Generalization]
-        # @return [void] (modifies generalization in place)
-        def collect_inherited_properties(generalization) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          inherited_props = []
-          inherited_assoc_props = []
-          level = 0
-
-          # Walk the general chain
-          current_gen = generalization.general
-          while current_gen
-            # Set metadata on BOTH general_attributes and attributes
-            # (matches XMI behavior)
-            # upper_klass and level are set during the inheritance walk
-            [current_gen.general_attributes,
-             current_gen.attributes].each do |attr_list|
-              attr_list&.each do |attr|
-                attr.upper_klass = current_gen.general_upper_klass
-                attr.level = level
-              end
-            end
-
-            # Process each attribute in reverse order
-            # (to show super class first after reversal)
-            current_gen.attributes.reverse_each do |attr|
-              # Clone attribute for inherited collection
-              inherited_attr = attr.dup
-              inherited_attr.upper_klass = current_gen.general_upper_klass
-              inherited_attr.gen_name = current_gen.general_name
-              inherited_attr.level = level
-
-              # Partition by association
-              if attr.has_association
-                inherited_assoc_props << inherited_attr
-              else
-                inherited_props << inherited_attr
-              end
-            end
-
-            # Move to next level
-            level += 1
-            current_gen = current_gen.general
-          end
-
-          # Reverse to show super class first
-          generalization.inherited_props = inherited_props.reverse
-          generalization.inherited_assoc_props = inherited_assoc_props.reverse
-        end
-
-        # Load association generalizations for a class
-        # @param object_id [Integer] Object ID
-        # @return [Array<Lutaml::Uml::AssociationGeneralization>]
-        # UML association generalizations
-        def load_association_generalizations(object_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          return [] if object_id.nil?
-
-          # Find ALL generalization connectors for this class
-          gen_connectors = database.connectors_for_object(object_id)
-            .select { |c| c.generalization? && c.start_object_id == object_id }
-
-          gen_connectors.filter_map do |ea_connector|
-            guid = ea_connector.ea_guid
-            parent_object_id = ea_connector.end_object_id
-
-            # Find parent object to get its GUID
-            parent_obj = find_object_by_id(parent_object_id)
-            next unless parent_obj
-
-            Lutaml::Uml::AssociationGeneralization.new.tap do |ag|
-              ag.id = normalize_guid_to_xmi_format(guid, "EAID")
-              ag.type = "uml:Generalization"
-              ag.general = normalize_guid_to_xmi_format(parent_obj.ea_guid,
-                                                        "EAID")
-            end
-          end
-        end
-
-        # Load associations for a class
-        # Creates Association objects from navigable association ends
-        # (ownedAttributes with association markers)
-        # This matches XMI behavior where current class is always the owner
-        # @param object_id [Integer] Object ID
-        # @param object_guid [String] Object GUID
-        # @return [Array<Lutaml::Uml::Association>] UML associations
-        def load_class_associations(object_id, object_guid) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          return [] if object_id.nil?
-
-          associations = []
-          normalized_owner_xmi_id = normalize_guid_to_xmi_format(object_guid,
-                                                                 "EAID")
-
-          assoc_types = ["Association", "Aggregation", "Composition"].freeze
-          assoc_connectors = database.connectors_for_object(object_id)
-            .select { |c| assoc_types.include?(c.connector_type) }
-
-          assoc_connectors.each do |ea_connector| # rubocop:disable Metrics/BlockLength
-            # Determine which end this class is on
-            is_start = ea_connector.start_object_id == object_id
-
-            # Get role name (this is the ownedAttribute name)
-            owner_end_attribute_name = if is_start
-                                         ea_connector.destrole
-                                       else
-                                         ea_connector.sourcerole
-                                       end
-
-            # Only create association if there's a navigable role name
-            # (matches XMI ownedAttribute[@association])
-            if owner_end_attribute_name.nil? || owner_end_attribute_name.empty?
-              next
-            end
-
-            # Get member end (the other class)
-            member_obj = if is_start
-                           find_object_by_id(ea_connector.end_object_id)
-                         else
-                           find_object_by_id(ea_connector.start_object_id)
-                         end
-            next unless member_obj
-
-            # Get member end attribute name
-            # (role at the opposite end, or class name if no role)
-            member_end_attribute_name = if is_start
-                                          ea_connector.sourcerole
-                                        else
-                                          ea_connector.destrole
-                                        end
-            if member_end_attribute_name.nil? ||
-                member_end_attribute_name.empty?
-              member_end_attribute_name = member_obj.name
-            end
-
-            # Get cardinality for this end
-            member_cardinality_str = if is_start
-                                       ea_connector.destcard
-                                     else
-                                       ea_connector.sourcecard
-                                     end
-
-            # Create association from this class's perspective
-            associations << Lutaml::Uml::Association.new.tap do |assoc| # rubocop:disable Metrics/BlockLength
-              assoc.xmi_id = normalize_guid_to_xmi_format(ea_connector.ea_guid,
-                                                          "EAID")
-              unless ea_connector.name.nil? || ea_connector.name.empty?
-                assoc.name = ea_connector.name
-              end
-
-              # Owner is always the current class (matches XMI)
-              assoc.owner_end = find_object_by_id(object_id)&.name
-              assoc.owner_end_xmi_id = normalized_owner_xmi_id
-              assoc.owner_end_attribute_name = owner_end_attribute_name
-
-              # Member is the other end
-              assoc.member_end = member_obj.name
-              assoc.member_end_xmi_id = normalize_guid_to_xmi_format(
-                member_obj.ea_guid, "EAID"
-              )
-              assoc.member_end_attribute_name = member_end_attribute_name
-
-              # Set member_end_type based on connector type
-              ea_type = ea_connector.connector_type
-              assoc.member_end_type = ea_type&.downcase
-
-              # Set cardinality
-              if member_cardinality_str && !member_cardinality_str.empty?
-                parsed = parse_cardinality(member_cardinality_str)
-                if parsed[:min] || parsed[:max]
-                  assoc.member_end_cardinality = Lutaml::Uml::Cardinality.new
-                    .tap do |card|
-                      card.min = parsed[:min]
-                      card.max = parsed[:max]
-                    end
-                end
-              end
-
-              # Note: XMI does not include connector notes
-              # in Association definition
-            end
-          end
-
-          associations.compact
-        end
-
-        # Load association-based attributes
-        # (navigable association ends with role names)
-        # @param object_id [Integer] Object ID
-        # @return [Array<Lutaml::Uml::TopElementAttribute>]
-        # Association-based attributes
-        def load_association_attributes(object_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-          return [] if object_id.nil?
-
-          attributes = []
-
-          assoc_types = ["Association", "Aggregation", "Composition"].freeze
-          assoc_connectors = database.connectors_for_object(object_id)
-            .select { |c| assoc_types.include?(c.connector_type) }
-          obj = find_object_by_id(object_id)
-          obj_pkg_name = find_package_name(obj&.package_id)
-
-          assoc_connectors.each do |ea_connector| # rubocop:disable Metrics/BlockLength
-            # Check if this object is the source (owner) or target (member)
-            if ea_connector.start_object_id == object_id
-              # This class is the source - check for dest role
-              next if ea_connector.destrole.nil? || ea_connector.destrole.empty?
-
-              target_obj = find_object_by_id(ea_connector.end_object_id)
-              next unless target_obj
-
-              target_obj_pkg_name = find_package_name(target_obj.package_id)
-
-              attributes << create_association_attribute(
-                name: ea_connector.destrole,
-                type: target_obj.name,
-                type_xmi_id: target_obj.ea_guid,
-                association_xmi_id: ea_connector.ea_guid,
-                cardinality: ea_connector.destcard,
-                definition: ea_connector.notes,
-                gen_name: obj.name,
-                name_ns: obj_pkg_name,
-                type_ns: target_obj_pkg_name,
-                is_src: false,
-              )
-            elsif ea_connector.end_object_id == object_id
-              # This class is the target - check for source role
-              if ea_connector.sourcerole.nil? || ea_connector.sourcerole.empty?
-                next
-              end
-
-              source_obj = find_object_by_id(ea_connector.start_object_id)
-              next unless source_obj
-
-              source_obj_pkg_name = find_package_name(source_obj.package_id)
-
-              attributes << create_association_attribute(
-                name: ea_connector.sourcerole,
-                type: source_obj.name,
-                type_xmi_id: source_obj.ea_guid,
-                association_xmi_id: ea_connector.ea_guid,
-                cardinality: ea_connector.sourcecard,
-                definition: ea_connector.notes,
-                gen_name: obj.name,
-                name_ns: obj_pkg_name,
-                type_ns: source_obj_pkg_name,
-              )
-            end
-          end
-
-          attributes.compact
-        end
-
-        # Create an attribute from association end
-        # @param name [String] Attribute name (role name)
-        # @param type [String] Attribute type (class name)
-        # @param type_xmi_id [String] Type XMI ID
-        # @param association_xmi_id [String] Association XMI ID
-        # @param cardinality [String] Cardinality string
-        # @param gen_name [String] Name of the generalization object
-        # @return [Lutaml::Uml::GeneralAttribute] Created attribute
-        def create_association_attribute( # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/ParameterLists
-          name:, type:, type_xmi_id:,
-          association_xmi_id:, cardinality:, definition:,
-          gen_name:, name_ns:, type_ns:, is_src: true
-        )
-          Lutaml::Uml::GeneralAttribute.new.tap do |attr|
-            attr.name = name
-            attr.type = type
-            attr.gen_name = gen_name
-            attr.definition = definition
-            attr.xmi_id = normalize_guid_to_xmi_format(type_xmi_id, "EAID")
-            attr.association = normalize_guid_to_xmi_format(
-              association_xmi_id, "EAID"
-            )
-            attr.has_association = true
-            attr.id = normalize_guid_to_xmi_src_dst_format(
-              association_xmi_id, "EAID", is_src
-            )
-            attr.name_ns = name_ns
-            attr.type_ns = type_ns
-
-            # Map cardinality if present
-            if cardinality && !cardinality.empty?
-              parsed = parse_cardinality(cardinality)
-              if parsed[:min] || parsed[:max]
-                attr.cardinality = Lutaml::Uml::Cardinality.new.tap do |card|
-                  card.min = parsed[:min]
-                  card.max = parsed[:max]
-                end
-              end
-            end
-          end
-        end
-
-        # Find package name by ID
-        # @param package_id [Integer] Package ID
-        # @return [String, Nil] Package name or nil
-        def find_package_name(package_id)
-          return nil if package_id.nil?
-
-          database.find_package(package_id)&.name
+          ObjectPropertyTransformer.new(database).transform_collection(ea_props)
         end
       end
     end