lutaml 0.9.43 → 0.10.0

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "base_transformer"
+require "lutaml/uml"
+
+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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "base_transformer"
+require_relative "attribute_transformer"
+require_relative "operation_transformer"
+require_relative "constraint_transformer"
+require_relative "tagged_value_transformer"
+require_relative "association_transformer"
+require "lutaml/uml"
+
+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)
+
+            # Set package path
+            data_type.package_path = calculate_package_path(
+              ea_object.package_id,
+            )
+
+            # 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
+            attts = load_attributes(ea_object.ea_object_id)
+            assoc_attts = load_association_attributes(ea_object.ea_object_id)
+            data_type.attributes = attts + assoc_attts
+
+            # 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?
+
+          query = "SELECT * FROM t_attribute WHERE Object_ID = ? ORDER BY Pos"
+          rows = database.connection.execute(query, object_id)
+
+          ea_attributes = rows.map do |row|
+            Models::EaAttribute.from_db_row(row)
+          end
+
+          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?
+
+          query = "SELECT * FROM t_operation WHERE Object_ID = ? ORDER BY Pos"
+          rows = database.connection.execute(query, object_id)
+
+          ea_operations = rows.map do |row|
+            Models::EaOperation.from_db_row(row)
+          end
+
+          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?
+
+          query = <<-SQL
+            SELECT * FROM t_connector
+            WHERE Connector_Type = 'Association'
+            AND (Start_Object_ID = ? OR End_Object_ID = ?)
+          SQL
+
+          rows = database.connection.execute(query, [object_id, object_id])
+
+          assoc_transformer = AssociationTransformer.new(database)
+          normalized_xmi_id = normalize_guid_to_xmi_format(object_guid, "EAID")
+
+          rows.filter_map do |row|
+            ea_connector = Models::EaConnector.from_db_row(row)
+            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

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative "base_transformer"
+require "lutaml/uml"
+require_relative "../../uml/diagram_object"
+require_relative "../../uml/diagram_link"
+
+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")
+            # TODO: Fix diagram_type assignment -
+            # lutaml-model compatibility issue
+            # diagram.diagram_type = ea_diagram.diagram_type
+
+            # 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
+
+            # Load diagram id
+            diagram.package_id = ea_diagram.package_id
+          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?
+
+          query = "SELECT * FROM t_package WHERE Package_ID = ?"
+          rows = database.connection.execute(query, package_id)
+          return nil if rows.empty?
+
+          Models::EaPackage.from_db_row(rows.first)
+        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?
+
+          query = "SELECT * FROM t_diagramobjects WHERE Diagram_ID = ?"
+          rows = database.connection.execute(query, diagram_id)
+
+          rows.filter_map do |row|
+            ea_obj = Models::EaDiagramObject.from_db_row(row)
+            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?
+
+          query = "SELECT * FROM t_diagramlinks WHERE DiagramID = ?"
+          rows = database.connection.execute(query, diagram_id)
+
+          rows.filter_map do |row|
+            ea_link = Models::EaDiagramLink.from_db_row(row)
+            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?
+
+          query = "SELECT * FROM t_connector WHERE Connector_ID = ?"
+          rows = database.connection.execute(query, connector_id)
+          return nil if rows.empty?
+
+          Models::EaConnector.from_db_row(rows.first)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require "lutaml/uml"
+
+module Lutaml
+  module Qea
+    module Factory
+      # Builds and validates UML Document structure
+      # Ensures all required document sections are populated correctly
+      class DocumentBuilder
+        attr_reader :document
+
+        # Initialize builder with new document
+        # @param name [String] Document name
+        def initialize(name: "EA Model")
+          @document = Lutaml::Uml::Document.new
+          @document.name = name
+          # Don't initialize collections - they have default values
+        end
+
+        # Add packages to document
+        # @param packages [Array<Lutaml::Uml::Package>] Packages to add
+        # @return [self] For method chaining
+        def add_packages(packages)
+          return self if packages.nil? || packages.empty?
+
+          @document.packages.concat(packages)
+          self
+        end
+
+        # Add classes to document
+        # @param classes [Array<Lutaml::Uml::Class>] Classes to add
+        # @return [self] For method chaining
+        def add_classes(classes)
+          return self if classes.nil? || classes.empty?
+
+          @document.classes.concat(classes)
+          self
+        end
+
+        # Add enums to document
+        # @param enums [Array<Lutaml::Uml::Enum>] Enums to add
+        # @return [self] For method chaining
+        def add_enums(enums)
+          return self if enums.nil? || enums.empty?
+
+          @document.enums.concat(enums)
+          self
+        end
+
+        # Add data types to document
+        # @param data_types [Array<Lutaml::Uml::DataType>] Data types to add
+        # @return [self] For method chaining
+        def add_data_types(data_types)
+          return self if data_types.nil? || data_types.empty?
+
+          @document.data_types.concat(data_types)
+          self
+        end
+
+        # Add instances to document
+        # @param instances [Array<Lutaml::Uml::Instance>] Instances to add
+        # @return [self] For method chaining
+        def add_instances(instances)
+          return self if instances.nil? || instances.empty?
+
+          @document.instances.concat(instances)
+          self
+        end
+
+        # Add associations to document
+        # @param associations [Array<Lutaml::Uml::Association>] Associations
+        # @return [self] For method chaining
+        def add_associations(associations)
+          return self if associations.nil? || associations.empty?
+
+          @document.associations.concat(associations)
+          self
+        end
+
+        # Set document metadata
+        # @param title [String] Document title
+        # @param caption [String] Document caption
+        # @return [self] For method chaining
+        def set_metadata(title: nil, caption: nil)
+          @document.title = title if title
+          @document.caption = caption if caption
+          self
+        end
+
+        # Build and return the document
+        # @param validate [Boolean] Whether to validate before returning
+        # @return [Lutaml::Uml::Document] The built document
+        # @raise [ValidationError] If validation fails
+        def build(validate: true)
+          validate! if validate
+          @document
+        end
+
+        # Validate document integrity
+        # @return [Boolean] True if valid
+        # @raise [ValidationError] If validation fails
+        def validate! # rubocop:disable Metrics/MethodLength
+          errors = []
+          warnings = []
+
+          # Check for duplicate xmi_ids
+          check_duplicate_xmi_ids(errors)
+
+          # Check association references (warnings only for missing refs)
+          check_association_references(warnings)
+
+          # Print warnings if any
+          unless warnings.empty?
+            warn "Document validation warnings:"
+            warnings.each { |w| warn "  - #{w}" }
+          end
+
+          raise ValidationError, errors.join("; ") unless errors.empty?
+
+          true
+        end
+
+        # Get document statistics
+        # @return [Hash] Statistics about document contents
+        def stats
+          {
+            packages: @document.packages.size,
+            classes: @document.classes.size,
+            enums: @document.enums.size,
+            data_types: @document.data_types.size,
+            instances: @document.instances.size,
+            associations: @document.associations.size,
+          }
+        end
+
+        private
+
+        # Check for duplicate xmi_ids across all elements
+        # @param errors [Array<String>] Error accumulator
+        def check_duplicate_xmi_ids(errors)
+          xmi_ids = collect_all_xmi_ids
+          duplicates = xmi_ids.group_by { |id| id }
+            .select { |_, v| v.size > 1 }
+            .keys
+
+          unless duplicates.empty?
+            errors << "Duplicate xmi_ids found: #{duplicates.join(', ')}"
+          end
+        end
+
+        # Collect all xmi_ids from document
+        # @return [Array<String>] All xmi_ids
+        def collect_all_xmi_ids # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+          ids = []
+
+          # Collect from top-level elements
+          ids.concat(@document.packages.filter_map(&:xmi_id))
+          ids.concat(@document.classes.filter_map(&:xmi_id))
+          ids.concat(@document.enums.filter_map(&:xmi_id))
+          ids.concat(@document.data_types.filter_map(&:xmi_id))
+          ids.concat(@document.instances.filter_map(&:xmi_id))
+
+          # Recursively collect from packages (where most classes actually are)
+          @document.packages.each do |package|
+            ids.concat(collect_package_xmi_ids(package))
+          end
+
+          ids
+        end
+
+        # Recursively collect all xmi_ids from a package and its descendants
+        # @param package [Lutaml::Uml::Package] Package to collect from
+        # @return [Array<String>] All xmi_ids in package hierarchy
+        def collect_package_xmi_ids(package) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          ids = []
+
+          # Collect from package's elements
+          ids.concat(package.classes.filter_map(&:xmi_id)) if package.classes
+          ids.concat(package.enums.filter_map(&:xmi_id)) if package.enums
+          if package.data_types
+            ids.concat(package.data_types.filter_map(&:xmi_id))
+          end
+          if package.instances
+            ids.concat(package.instances.filter_map(&:xmi_id))
+          end
+
+          # Recursively collect from child packages
+          package.packages&.each do |child_package|
+            ids.concat(collect_package_xmi_ids(child_package))
+          end
+
+          ids
+        end
+
+        # Check that all association references are valid
+        # @param warnings [Array<String>] Warning accumulator
+        def check_association_references(warnings) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          return if @document.associations.empty?
+
+          all_xmi_ids = collect_all_xmi_ids.to_set
+          invalid_associations = []
+
+          @document.associations.each do |assoc|
+            has_invalid_member = !check_association_end_valid?(
+              assoc, :member_end_xmi_id, all_xmi_ids
+            )
+            has_invalid_owner = !check_association_end_valid?(
+              assoc, :owner_end_xmi_id, all_xmi_ids
+            )
+
+            if has_invalid_member || has_invalid_owner
+              invalid_associations << assoc
+              if has_invalid_member
+                add_invalid_end_warning(assoc, :member_end_xmi_id, all_xmi_ids,
+                                        warnings)
+              end
+              if has_invalid_owner
+                add_invalid_end_warning(assoc, :owner_end_xmi_id, all_xmi_ids,
+                                        warnings)
+              end
+            end
+          end
+
+          # Remove invalid associations from document
+          unless invalid_associations.empty?
+            @document.associations.reject! do |a|
+              invalid_associations.include?(a)
+            end
+            warnings << "Removed #{invalid_associations.size} association(s) " \
+                        "with invalid references"
+          end
+        end
+
+        # Check if association end reference is valid
+        # @param assoc [Lutaml::Uml::Association] Association
+        # @param attr [Symbol] Attribute to check (should be xmi_id attribute)
+        # @param valid_ids [Set<String>] Set of valid xmi_ids
+        # @return [Boolean] True if valid or nil
+        def check_association_end_valid?(assoc, attr, valid_ids)
+          value = assoc.send(attr)
+          return true if value.nil?
+
+          valid_ids.include?(value)
+        end
+
+        # Add warning for invalid association end
+        # @param assoc [Lutaml::Uml::Association] Association
+        # @param attr [Symbol] Attribute to check (should be xmi_id attribute)
+        # @param valid_ids [Set<String>] Set of valid xmi_ids
+        # @param warnings [Array<String>] Warning accumulator
+        def add_invalid_end_warning(assoc, attr, valid_ids, warnings) # rubocop:disable Metrics/MethodLength
+          value = assoc.send(attr)
+          return if value.nil?
+
+          unless valid_ids.include?(value)
+            # Get the corresponding name attribute for better error messages
+            name_attr = attr.to_s.gsub("_xmi_id", "").to_sym
+            name_value = begin
+              assoc.send(name_attr)
+            rescue StandardError
+              nil
+            end
+
+            warnings << "Association #{assoc.xmi_id} references " \
+                        "invalid #{name_attr}: #{name_value}"
+          end
+        end
+
+        # Custom validation error
+        class ValidationError < StandardError; end
+      end
+    end
+  end
+end