ea 0.1.0 → 0.1.4

data/lib/ea/qea/factory/attribute_transformer.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      # Transforms EA attributes to UML attributes
+      class AttributeTransformer < BaseTransformer
+        # Transform EA attribute to UML attribute
+        # @param ea_attribute [EaAttribute] EA attribute model
+        # @return [Lutaml::Uml::TopElementAttribute] UML attribute
+        def transform(ea_attribute) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return nil if ea_attribute.nil?
+
+          Lutaml::Uml::TopElementAttribute.new.tap do |attr|
+            attr.name = ea_attribute.name
+            attr.type = ea_attribute.type
+            attr.visibility = map_visibility(ea_attribute.scope)
+
+            # XMI uses the TYPE's XMI ID, not the attribute's ID
+            type_xmi_id = lookup_type_xmi_id(ea_attribute.classifier)
+            attr.xmi_id = type_xmi_id || normalize_guid_to_xmi_format(
+              ea_attribute.ea_guid, "EAID"
+            )
+
+            attr.id = normalize_guid_to_xmi_format(ea_attribute.ea_guid, "EAID")
+            attr.static = ea_attribute.static? ? "true" : nil
+            attr.is_derived = ea_attribute.derived == "1"
+
+            # Map cardinality if bounds are present
+            if ea_attribute.lowerbound || ea_attribute.upperbound
+              attr.cardinality = build_cardinality(
+                ea_attribute.lowerbound,
+                ea_attribute.upperbound,
+              )
+            end
+
+            # Map definition/notes
+            attr.definition = normalize_line_endings(ea_attribute.notes) unless
+              ea_attribute.notes.nil? || ea_attribute.notes.empty?
+
+            # Load and transform attribute tags
+            attr.tagged_values = load_attribute_tags(ea_attribute.id)
+          end
+        end
+
+        private
+
+        # Look up the type object's XMI ID from classifier
+        # @param classifier_id [Integer] Classifier ID
+        # @return [String, nil] Type's XMI ID
+        def lookup_type_xmi_id(classifier_id) # rubocop:disable Metrics/AbcSize
+          return nil if classifier_id.nil? || classifier_id.to_i.zero?
+
+          obj = database.find_object(classifier_id.to_i)
+          return nil unless obj
+
+          normalize_guid_to_xmi_format(obj.ea_guid, "EAID")
+        end
+
+        # Build cardinality from lower and upper bounds
+        # @param lower [String] Lower bound
+        # @param upper [String] Upper bound
+        # @return [Lutaml::Uml::Cardinality] Cardinality object
+        def build_cardinality(lower, upper)
+          return nil if lower.nil? && upper.nil?
+
+          Lutaml::Uml::Cardinality.new.tap do |card|
+            card.min = lower || "0"
+            card.max = upper || "*"
+          end
+        end
+
+        # Load and transform attribute tags for an attribute
+        # @param attribute_id [Integer] Attribute ID
+        # @return [Array<Lutaml::Uml::TaggedValue>] UML tagged values
+        def load_attribute_tags(attribute_id)
+          return [] if attribute_id.nil?
+          return [] unless database.attribute_tags
+
+          # Filter attribute tags for this attribute from the in-memory
+          # collection
+          ea_tags = database.attribute_tags.select do |tag|
+            tag.element_id == attribute_id
+          end
+
+          # Transform to UML tagged values
+          tag_transformer = AttributeTagTransformer.new(database)
+          tag_transformer.transform_collection(ea_tags)
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/factory/base_transformer.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      # Abstract base class for all EA to UML transformers
+      # Implements the Strategy pattern for model transformation
+      class BaseTransformer
+        attr_reader :database
+
+        # Initialize transformer with database reference
+        # @param database [Ea::Qea::Database] QEA database instance
+        def initialize(database)
+          @database = database
+        end
+
+        # Transform a single EA model to UML model
+        # @param ea_model [BaseModel] EA model instance
+        # @return [Object] UML model instance
+        # @raise [NotImplementedError] Must be implemented by subclasses
+        def transform(ea_model)
+          raise NotImplementedError,
+                "#{self.class} must implement #transform"
+        end
+
+        # Transform a collection of EA models to UML models
+        # @param collection [Array<BaseModel>] Collection of EA models
+        # @return [Array<Object>] Collection of UML models
+        def transform_collection(collection)
+          return [] if collection.nil? || collection.empty?
+
+          collection.filter_map { |item| transform(item) }
+        end
+
+        # Map EA visibility to UML visibility
+        # @param ea_visibility [String] EA visibility value
+        # @return [String] UML visibility value
+        def map_visibility(ea_visibility) # rubocop:disable Metrics/CyclomaticComplexity
+          return "public" if ea_visibility.nil? || ea_visibility.empty?
+
+          case ea_visibility.downcase
+          when "private" then "private"
+          when "protected" then "protected"
+          when "package" then "package"
+          else "public"
+          end
+        end
+
+        # Parse cardinality string to min/max values
+        # @param cardinality_str [String] Cardinality string (e.g., "0..1",
+        #   "1..*")
+        # @return [Hash] Hash with :min and :max keys
+        def parse_cardinality(cardinality_str)
+          return { min: nil, max: nil } if cardinality_str.nil? ||
+            cardinality_str.empty?
+
+          parts = cardinality_str.split("..")
+          if parts.size == 2
+            { min: parts[0], max: parts[1] }
+          elsif parts.size == 1
+            { min: parts[0], max: parts[0] }
+          else
+            { min: nil, max: nil }
+          end
+        end
+
+        # Convert boolean-like values to actual boolean
+        # @param value [Object] Value to convert
+        # @return [Boolean] Boolean value
+        def to_boolean(value)
+          return false if value.nil?
+          return value if [true, false].include?(value)
+
+          value.to_s == "1" || value.to_s.downcase == "true"
+        end
+
+        # Normalize EA GUID to XMI ID format
+        # Converts {GUID-WITH-HYPHENS} to PREFIX_GUID_WITH_UNDERSCORES
+        # @param ea_guid [String] EA GUID in format
+        # "{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}"
+        # @param prefix [String] Prefix to add (e.g., "EAID", "EAPK")
+        # @return [String, nil] XMI ID in format
+        # "PREFIX_XXXXXXXX_XXXX_XXXX_XXXX_XXXXXXXXXXXX"
+        def normalize_guid_to_xmi_format(ea_guid, prefix = "EAID")
+          return nil if ea_guid.nil? || ea_guid.empty?
+
+          # Remove braces and replace hyphens with underscores
+          clean = ea_guid.tr("{}", "").tr("-", "_")
+          "#{prefix}_#{clean}"
+        end
+
+        # Convert ea_guid to XMI SRC ID format
+        def normalize_guid_to_xmi_src_dst_format(
+          ea_guid, prefix = "EAID", is_src = true # rubocop:disable Style/OptionalBooleanParameter
+        )
+          xmi_id = normalize_guid_to_xmi_format(ea_guid, prefix)
+
+          # Trim prefix and add _src or _dst
+          src_dst = is_src ? "src" : "dst"
+          clean = xmi_id[(prefix.length + 3), xmi_id.length]
+          "#{prefix}_#{src_dst}#{clean}"
+        end
+
+        # Normalize line endings from Windows (\r\n) to Unix (\n)
+        # EA database stores text with Windows line endings, but XMI uses Unix
+        # @param text [String, nil] Text to normalize
+        # @return [String, nil] Text with normalized line endings
+        def normalize_line_endings(text)
+          return nil if text.nil?
+
+          text.gsub("\r\n", "\n")
+        end
+
+        # Find object by ID
+        # @param object_id [Integer] Object ID
+        # @return [Models::EaObject, nil] EA object or nil
+        def find_object_by_id(object_id)
+          return nil if object_id.nil?
+
+          database.find_object(object_id)
+        end
+
+        # Load and transform tagged values for an element
+        # @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?
+
+          ea_tags = database.tagged_values_for_element(ea_guid)
+          TaggedValueTransformer.new(database).transform_collection(ea_tags)
+        end
+
+        # Load and transform attributes for an object
+        # @param object_id [Integer] Object ID
+        # @return [Array<Lutaml::Uml::TopElementAttribute>] UML attributes
+        def load_attributes(object_id)
+          return [] if object_id.nil?
+
+          ea_attributes = database.attributes_for_object(object_id)
+            .sort_by { |a| a.pos || 0 }
+          AttributeTransformer.new(database).transform_collection(ea_attributes)
+        end
+
+        # Load and transform operations for an object
+        # @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 }
+          OperationTransformer.new(database).transform_collection(ea_operations)
+        end
+
+        # Load and transform constraints for an object
+        # @param object_id [Integer] Object ID
+        # @return [Array<Lutaml::Uml::Constraint>] UML constraints
+        def load_constraints(object_id)
+          return [] if object_id.nil?
+
+          ea_constraints = database.constraints_for_object(object_id)
+          ConstraintTransformer.new(database).transform_collection(ea_constraints)
+        end
+
+        # Load and transform object properties for an object
+        # @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?
+
+          ea_props = database.properties_for_object(object_id)
+          ObjectPropertyTransformer.new(database).transform_collection(ea_props)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      class ClassTransformer < BaseTransformer
+        def transform(ea_object)
+          return nil if ea_object.nil?
+          return nil unless transformable?(ea_object)
+
+          Lutaml::Uml::UmlClass.new.tap do |klass|
+            assign_basic_properties(klass, ea_object)
+            assign_features(klass, ea_object)
+            assign_relationships(klass, ea_object)
+          end
+        end
+
+        private
+
+        def transformable?(ea_object)
+          ea_object.uml_class? || ea_object.interface?
+        end
+
+        def assign_basic_properties(klass, ea_object)
+          klass.name = ea_object.name
+          klass.xmi_id = normalize_guid_to_xmi_format(ea_object.ea_guid, "EAID")
+          klass.is_abstract = ea_object.abstract?
+          klass.type = "Class"
+          klass.visibility = map_visibility(ea_object.visibility)
+          assign_stereotypes(klass, ea_object)
+          assign_definition(klass, ea_object)
+        end
+
+        def assign_stereotypes(klass, ea_object)
+          stereotypes = build_stereotypes(ea_object)
+          klass.stereotype = stereotypes unless stereotypes.empty?
+        end
+
+        def assign_definition(klass, ea_object)
+          return if ea_object.note.nil? || ea_object.note.empty?
+
+          klass.definition = normalize_line_endings(ea_object.note)
+        end
+
+        def assign_features(klass, ea_object)
+          klass.attributes = load_all_attributes(ea_object)
+          assign_feature_collections(klass, ea_object)
+        end
+
+        def assign_feature_collections(klass, ea_object)
+          klass.operations = load_operations(ea_object.ea_object_id)
+          klass.constraints = load_constraints(ea_object.ea_object_id)
+          klass.tagged_values = load_tagged_values(ea_object.ea_guid)
+          klass.tagged_values.concat(
+            load_object_properties(ea_object.ea_object_id),
+          )
+        end
+
+        def assign_relationships(klass, ea_object)
+          gen_builder = GeneralizationBuilder.new(database)
+          assoc_builder = AssociationBuilder.new(database)
+
+          klass.generalization = gen_builder.load_generalization(
+            ea_object.ea_object_id,
+          )
+          klass.association_generalization = gen_builder
+            .load_association_generalizations(ea_object.ea_object_id)
+
+          klass.associations = assoc_builder.load_class_associations(
+            ea_object.ea_object_id, ea_object.ea_guid
+          )
+        end
+
+        def load_all_attributes(ea_object)
+          gen_builder = GeneralizationBuilder.new(database)
+          assoc_builder = AssociationBuilder.new(database)
+
+          attrs = load_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),
+          )
+          attrs + assoc_attrs
+        end
+
+        def build_stereotypes(ea_object)
+          stereotypes = []
+          add_direct_stereotype(stereotypes, ea_object)
+          add_xref_stereotype(stereotypes, ea_object)
+          add_interface_stereotype(stereotypes, ea_object)
+
+          stereotypes
+        end
+
+        def add_direct_stereotype(stereotypes, ea_object)
+          return unless ea_object.stereotype && !ea_object.stereotype.empty?
+
+          stereotypes << ea_object.stereotype
+        end
+
+        def add_xref_stereotype(stereotypes, ea_object)
+          xref_stereotype = StereotypeLoader.new(database)
+            .load_from_xref(ea_object.ea_guid)
+          return unless xref_stereotype && !stereotypes.include?(xref_stereotype)
+
+          stereotypes << xref_stereotype
+        end
+
+        def add_interface_stereotype(stereotypes, ea_object)
+          return unless ea_object.interface? && !stereotypes.include?("interface")
+
+          stereotypes << "interface"
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/factory/constraint_transformer.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      # Transforms EA ObjectConstraint to UML Constraint
+      #
+      # This transformer converts Enterprise Architect constraint definitions
+      # (typically OCL constraints) to standard UML Constraint objects.
+      #
+      # @example Transform a constraint
+      #   ea_constraint = Models::EaObjectConstraint.new(
+      #     constraint_id: 1,
+      #     object_id: 4,
+      #     constraint: "count(self.legalConstraints) >= 1",
+      #     constraint_type: "Invariant",
+      #     weight: 0.0,
+      #     status: "Approved"
+      #   )
+      #   transformer = ConstraintTransformer.new(database)
+      #   uml_constraint = transformer.transform(ea_constraint)
+      class ConstraintTransformer < BaseTransformer
+        # Transform EA constraint to UML Constraint
+        #
+        # @param ea_constraint [Models::EaObjectConstraint] EA constraint model
+        # @return [Lutaml::Uml::Constraint, nil] UML constraint or nil
+        def transform(ea_constraint) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          return nil unless ea_constraint
+
+          Lutaml::Uml::Constraint.new.tap do |constraint|
+            # Generate unique ID for the constraint
+            constraint.xmi_id = "constraint_#{ea_constraint.constraint_id}" if
+              ea_constraint.constraint_id
+
+            # Generate descriptive name from constraint body or use ID
+            constraint.name = constraint_name(ea_constraint)
+
+            # Map constraint properties
+            constraint.body = ea_constraint.constraint
+            constraint.type = ea_constraint.constraint_type
+            constraint.weight = ea_constraint.weight&.to_s
+            constraint.status = ea_constraint.status
+          end
+        end
+
+        private
+
+        # Generate descriptive name from constraint body
+        #
+        # Extracts the first meaningful part of the constraint body to use
+        # as a descriptive name. Falls back to a generic name if extraction
+        # fails.
+        #
+        # @param ea_constraint [Models::EaObjectConstraint] EA constraint
+        # @return [String] Constraint name
+        def constraint_name(ea_constraint) # rubocop:disable Metrics/MethodLength
+          return "constraint_#{ea_constraint.constraint_id}" unless
+            ea_constraint.constraint
+
+          body = ea_constraint.constraint.to_s.strip
+
+          # Try to extract a meaningful name from the constraint body
+          # Take first 50 chars or until special chars
+          name_part = body[0..50].split(/[()<>=\s]/).first&.strip
+
+          if name_part && !name_part.empty?
+            name_part
+          else
+            "constraint_#{ea_constraint.constraint_id}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/factory/data_type_transformer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      # Transforms EA objects (DataType type) to UML data types
+      class DataTypeTransformer < BaseTransformer
+        # Transform EA object to UML data type
+        # @param ea_object [EaObject] EA object model
+        # @return [Lutaml::Uml::DataType] UML data type
+        def transform(ea_object) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+          return nil if ea_object.nil?
+          return nil unless ea_object.data_type?
+
+          Lutaml::Uml::DataType.new.tap do |data_type| # rubocop:disable Metrics/BlockLength
+            # Map basic properties
+            data_type.name = ea_object.name
+            data_type.xmi_id = normalize_guid_to_xmi_format(ea_object.ea_guid,
+                                                            "EAID")
+            data_type.is_abstract = ea_object.abstract?
+            data_type.type = "DataType"
+            data_type.visibility = map_visibility(ea_object.visibility)
+
+            # Map stereotype
+            if ea_object.stereotype && !ea_object.stereotype.empty?
+              data_type.stereotype = [ea_object.stereotype]
+            end
+
+            # Map definition/notes
+            data_type.definition = ea_object.note unless
+              ea_object.note.nil? || ea_object.note.empty?
+
+            # Load and transform attributes
+            data_type.attributes = load_attributes(ea_object.ea_object_id)
+
+            # Load and transform operations
+            data_type.operations = load_operations(ea_object.ea_object_id)
+
+            # Load and transform constraints
+            data_type.constraints = load_constraints(ea_object.ea_object_id)
+
+            # Load and transform tagged values
+            data_type.tagged_values = load_tagged_values(ea_object.ea_guid)
+
+            # Load associations for this data type
+            data_type.associations = load_associations(ea_object.ea_object_id,
+                                                       ea_object.ea_guid)
+          end
+        end
+
+        private
+
+        # Load associations for a data type
+        # @param object_id [Integer] Object ID
+        # @param object_guid [String] Object GUID
+        # @return [Array<Lutaml::Uml::Association>] UML associations
+        def load_associations(object_id, object_guid) # rubocop:disable Metrics/MethodLength
+          return [] if object_id.nil?
+
+          assoc_connectors = database.connectors_for_object(object_id)
+            .select { |c| c.connector_type == "Association" }
+
+          assoc_transformer = AssociationTransformer.new(database)
+          normalized_xmi_id = normalize_guid_to_xmi_format(object_guid, "EAID")
+
+          assoc_connectors.filter_map do |ea_connector|
+            assoc = assoc_transformer.transform(ea_connector)
+
+            next unless assoc && assoc.owner_end_xmi_id == normalized_xmi_id
+
+            assoc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ea/qea/factory/diagram_transformer.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Ea
+  module Qea
+    module Factory
+      # Transforms EA diagrams to UML diagrams
+      #
+      # This transformer loads diagram data along with diagram objects
+      # (visual placement) and diagram links (visual connector routing)
+      # to create a complete UML diagram representation.
+      class DiagramTransformer < BaseTransformer
+        # Transform EA diagram to UML diagram
+        # @param ea_diagram [EaDiagram] EA diagram model
+        # @return [Lutaml::Uml::Diagram] UML diagram
+        def transform(ea_diagram) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
+          return nil if ea_diagram.nil?
+
+          Lutaml::Uml::Diagram.new.tap do |diagram| # rubocop:disable Metrics/BlockLength
+            # Map basic properties
+            diagram.name = ea_diagram.name
+            diagram.xmi_id = normalize_guid_to_xmi_format(ea_diagram.ea_guid,
+                                                          "EAID")
+
+            # Map package relationship - use GUID not numeric ID
+            if ea_diagram.package_id
+              package = find_package(ea_diagram.package_id)
+              if package
+                diagram.package_id = normalize_guid_to_xmi_format(
+                  package.ea_guid, "EAPK"
+                )
+                diagram.package_name = package.name
+              end
+            end
+
+            # Map definition/notes
+            diagram.definition = ea_diagram.notes unless
+              ea_diagram.notes.nil? || ea_diagram.notes.empty?
+
+            # Map stereotype
+            if ea_diagram.stereotype && !ea_diagram.stereotype.empty?
+              diagram.stereotype = [ea_diagram.stereotype]
+            end
+
+            # Load and transform diagram objects (visual placement)
+            diagram_objects = load_diagram_objects(ea_diagram.diagram_id)
+            if diagram_objects.any?
+              diagram.diagram_objects.concat(diagram_objects)
+            end
+
+            # Load and transform diagram links (visual routing)
+            diagram_links = load_diagram_links(ea_diagram.diagram_id)
+            diagram.diagram_links.concat(diagram_links) if diagram_links.any?
+
+            # Load diagram type
+            diagram.diagram_type = ea_diagram.diagram_type
+          end
+        end
+
+        private
+
+        # Find package by ID
+        # @param package_id [Integer] Package ID
+        # @return [EaPackage, nil] EA package or nil if not found
+        def find_package(package_id)
+          return nil if package_id.nil?
+
+          database.find_package(package_id)
+        end
+
+        # Load diagram objects for a diagram
+        # @param diagram_id [Integer] Diagram ID
+        # @return [Array<Lutaml::Uml::DiagramObject>] UML diagram objects
+        def load_diagram_objects(diagram_id)
+          return [] if diagram_id.nil?
+
+          ea_objects = database.diagram_objects_for(diagram_id)
+          ea_objects.filter_map do |ea_obj|
+            transform_diagram_object(ea_obj)
+          end
+        end
+
+        # Transform EA diagram object to UML diagram object
+        # @param ea_obj [Models::EaDiagramObject] EA diagram object
+        # @return [Lutaml::Uml::DiagramObject] UML diagram object
+        def transform_diagram_object(ea_obj) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          return nil if ea_obj.nil?
+
+          Lutaml::Uml::DiagramObject.new.tap do |obj|
+            obj.diagram_object_id = ea_obj.ea_object_id.to_s
+            obj.left = ea_obj.rectleft
+            obj.top = ea_obj.recttop
+            obj.right = ea_obj.rectright
+            obj.bottom = ea_obj.rectbottom
+            obj.sequence = ea_obj.sequence
+            obj.style = ea_obj.objectstyle
+
+            # Try to find and set xmi_id from the referenced object
+            if ea_obj.ea_object_id
+              uml_object = find_object_by_id(ea_obj.ea_object_id)
+              if uml_object
+                obj.object_xmi_id = normalize_guid_to_xmi_format(
+                  uml_object.ea_guid, "EAID"
+                )
+              end
+            end
+          end
+        end
+
+        # Load diagram links for a diagram
+        # @param diagram_id [Integer] Diagram ID
+        # @return [Array<Lutaml::Uml::DiagramLink>] UML diagram links
+        def load_diagram_links(diagram_id)
+          return [] if diagram_id.nil?
+
+          ea_links = database.diagram_links_for(diagram_id)
+          ea_links.filter_map do |ea_link|
+            transform_diagram_link(ea_link)
+          end
+        end
+
+        # Transform EA diagram link to UML diagram link
+        # @param ea_link [Models::EaDiagramLink] EA diagram link
+        # @return [Lutaml::Uml::DiagramLink] UML diagram link
+        def transform_diagram_link(ea_link) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          return nil if ea_link.nil?
+
+          Lutaml::Uml::DiagramLink.new.tap do |link|
+            link.connector_id = ea_link.connectorid.to_s
+            link.geometry = ea_link.geometry
+            link.style = ea_link.style
+            link.hidden = ea_link.hidden?
+            link.path = ea_link.path
+
+            # Try to find and set xmi_id from the referenced connector
+            if ea_link.connectorid
+              connector = find_connector_by_id(ea_link.connectorid)
+              if connector
+                link.connector_xmi_id = normalize_guid_to_xmi_format(
+                  connector.ea_guid, "EAID"
+                )
+              end
+            end
+          end
+        end
+
+        # Find connector by ID
+        # @param connector_id [Integer] Connector ID
+        # @return [Models::EaConnector, nil] EA connector or nil if not found
+        def find_connector_by_id(connector_id)
+          return nil if connector_id.nil?
+
+          database.find_connector(connector_id)
+        end
+      end
+    end
+  end
+end