lutaml 0.10.18 → 0.11.2

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

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  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::Class.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? ||
-            ea_object.object_type == "ProxyConnector" ||
-            ea_object.object_type == "Text"
-        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
-
-        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
-
-        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
-
-        def load_constraints(object_id)
-          return [] if object_id.nil?
-          return [] unless database.object_constraints
-
-          ea_constraints = database.object_constraints.select do |c|
-            c.ea_object_id == object_id
-          end
-          ConstraintTransformer.new(database).transform_collection(ea_constraints)
-        end
-
-        def load_tagged_values(ea_guid)
-          return [] if ea_guid.nil?
-          return [] unless database.tagged_values
-
-          ea_tags = database.tagged_values.select do |tag|
-            tag.element_id == ea_guid
-          end
-          TaggedValueTransformer.new(database).transform_collection(ea_tags)
-        end
-
-        def load_object_properties(object_id)
-          return [] if object_id.nil?
-          return [] unless database.object_properties
-
-          ea_props = database.object_properties.select do |prop|
-            prop.ea_object_id == object_id
-          end
-          ObjectPropertyTransformer.new(database).transform_collection(ea_props)
-        end
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  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/lutaml/qea/factory/data_type_transformer.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  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 and transform attributes for a data type
-        # @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 }
-
-          attribute_transformer = AttributeTransformer.new(database)
-          attribute_transformer.transform_collection(ea_attributes)
-        end
-
-        # Load and transform operations for a data type
-        # @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)
-        end
-
-        # Load and transform constraints for a data type
-        # @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
-
-          ea_constraints = database.object_constraints.select do |c|
-            c.ea_object_id == object_id
-          end
-
-          constraint_transformer = ConstraintTransformer.new(database)
-          constraint_transformer.transform_collection(ea_constraints)
-        end
-
-        # Load and transform tagged values for a data type
-        # @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
-
-          ea_tags = database.tagged_values.select do |tag|
-            tag.element_id == ea_guid
-          end
-
-          tag_transformer = TaggedValueTransformer.new(database)
-          tag_transformer.transform_collection(ea_tags)
-        end
-
-        # 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/lutaml/qea/factory/diagram_transformer.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  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